Java ArrayList类
2019-06-10 本文已影响0人
SnailLi
好记性不如烂笔头之：Java ArrayList类的一些使用方法
package cn.sl.arrayList.ui;
import java.util.*;
import java.util.function.Predicate;
/**
* Created by snailLi on 2019/6/6
*
* @description: ArrayList类的使用
*/
public class Test {
/**
* ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：
* 动态的增加和减少元素
* 实现了ICollection和IList接口
* 灵活的设置数组的大小
*/
public static void main(String[] args) {
int[] array = new int[]{6,6,5,9,3,5,96,46,25,68,5,9,9,354,26,26,54,23,9,872,2,5,654,32,5};
Test.addArray(array);
Test.addArray();
Test.remove();
Test.conversion();
Test.sort();
Test.operation();
}
/**
* ArrayList动态添加元素
* 方法：add()
*
* */
public static void addArray (int[] array){
/**
* Appends the specified element to the end of this list.
*
* 将指定的元素追加到此列表的末尾。
* */
ArrayList oddList = new ArrayList();//奇数
ArrayList evenList = new ArrayList();//偶数
for (int j : array) {
//奇数 偶数
if (j % 2 ==0){
evenList.add(j);
}
else {
oddList.add(j);
}
}
System.out.println("将指定的元素追加到此列表的末尾:\n" + "奇数列表:" + oddList + "\n" + "偶数列表:" + evenList);
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any
* subsequent elements to the right (adds one to their indices).
*
* 将指定元素插入列表中的指定位置。将当前位于该位置的元素(如果有的话)和
* 随后的任何元素向右移动(将一个元素添加到它们的索引中)。
*
* */
ArrayList newList = new ArrayList();
for (int j: array) {
newList.add(j);
}
//把元素添加到指定的索引中
newList.add(0,123);
System.out.println("\n将一个元素添加到它们的索引中:\n" + newList);
/**
* Constructs a list containing the elements of the specified collection,
* in the order they are returned by the collection's iterator.
*
*构造包含指定集合的元素的列表，按集合的迭代器返回元素的顺序排列。
*
* */
ArrayList list = new ArrayList(Arrays.asList(array,array));
System.out.println("\n构造包含指定集合的元素的列表，按集合的迭代器返回元素的顺序排列:\n" + list);
}
/**
*插入元素
*/
public static void addArray (){
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("c");
list.add("d");
list.add("e");
System.out.println(list + "\n");
ArrayList<String> array = new ArrayList<String>();
array.add("b");
/**
* 将集合中的某个元素插入ArrayList的指定索引处--addAll(int index, CollectionE> c);
*/
list.addAll(1,array);
System.out.println("将集合中的某个元素插入ArrayList的指定索引处:" + list + "\n");
ArrayList<String> newList = new ArrayList<String>();
newList.add("f");
/**
* 将集合中的某个元素插入ArrayList的最后面---addAll(Collection<? extends E> c);
*/
list.addAll(newList);
System.out.println("将集合中的某个元素插入ArrayList的最后面:" + list);
}
/**
* 删除元素
* @return
*/
public static void remove (){
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
System.out.println(list + "\n");
/**
* 从ArrayList中移除特定对象的第一个匹配项,注意是第一个-- remove(Object o)
*/
list.remove("b");
System.out.println("从ArrayList中移除特定对象的第一个匹配项:\n" + list + "\n");
/**
* 移除ArrayList的指定索引处的元素--remove(int index);
*/
list.remove(list.size()-1);
System.out.println("移除ArrayList的指定索引处的元素:\n" + list);
/**
* 从该列表中删除指定集合中包含的所有元素--removeAll(Collection<?> c)
*/
ArrayList<String> newList = new ArrayList<String>();
newList.add("a");
newList.add("b");
list.removeAll(newList);
System.out.println("从该列表中删除指定集合中包含的所有元素:\n" + list);
/**
* 删除列表所有元素
*/
list.clear();
System.out.println("删除列表所有元素:\n" + list);
/**
* 过滤特定的元素
*/
ArrayList<String> list2 = new ArrayList<>();
list2.add("张三");
list2.add("李四");
list2.add("王二");
list2.add("李麻子");
list2.add("刘三");
list2.removeIf(obj-> {
return obj.contains("李") || obj.contains("张");
});
System.out.println("\n过滤特定元素:" + list2);
ArrayList<Integer> list3 = new ArrayList<>();
Random r = new Random(1);
for (int i = 0; i < 50; i++) {
Integer in = r.nextInt(100);
list3.add(in);
}
System.out.println("\n过滤特定元素:" + list3);
list3.removeIf(obj-> {
return obj % 2 ==0;
});
System.out.println("\n过滤特定元素:" + list3);
}
/**
* List转换为数组&&数组转换为List
*/
public static void conversion(){
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
System.out.println(list + "\n");
/**
* Returns an array containing all of the elements in this list in proper sequence
* (from first to last element); the runtime type of the returned array is that of
* the specified array. If the list fits in the specified array, it is returned therein.
* Otherwise, a new array is allocated with the runtime type of the
* specified array and the size of this list.
*
* 返回一个数组，该数组包含列表中按正确顺序排列的所有元素
* (从第一个元素到最后一个元素);返回数组的运行时类型是指定数组的运行时类型。
* 如果列表符合指定的数组，则返回其中的列表。
* 否则，将使用指定数组的运行时类型和该列表的大小分配一个新数组。
*/
String[] stringArray = list.toArray(new String[list.size()]);
// 错误方式：使用String[] 强转会出现ClassCastException （类转换异常）
// String[] stringArray = (String[]) list.toArray();
System.out.println("List转换为数组--<T> T[] toArray(T[] a):\n" + Arrays.toString(stringArray));
/**
* Returns an array containing all of the elements in this list in proper
* sequence (from first to last element).
*
* 返回一个数组，该数组按适当的顺序(从第一个元素到最后一个元素)包含列表中的所有元素。
*/
Object[] obj = list.toArray();
System.out.println("List转换为数组--Object[] toArray():\n" + Arrays.toString(obj));
String[] string = {"a","b","c","d"};
/**
* Returns a fixed-size list backed by the specified array. (Changes to the returned list
* "write through" to the array.) This method acts as bridge between array-based
* and collection-based APIs, in combination with {@link Collection#toArray}.
* The returned list is serializable and implements {@link RandomAccess}.
*
* 返回指定数组支持的固定大小列表。(对返回列表“write through”到数组的更改。)
* 此方法与{@link Collection#toArray}结合，充当基于数组和基于集合的api之间的桥梁。
* 返回的列表是可序列化的，并实现{@link RandomAccess}。
*/
List<String> stringList = Arrays.asList(string);
// 注意的是：返回的集合我们不能对其增删元素，否则会抛出异常，并且对集合的元素进行修改会影响数组对应的元素。
// stringList.add("e");
System.out.println("数组转换为List--<T> List<T> asList(T... a):\n" + stringList);
List<String> newStringList = new ArrayList<String>();
/**
* Appends all of the elements in the specified collection to the end of this list,
* in the order that they are returned by the specified collection's iterator (optional operation).
* The behavior of this operation is undefined if the specified collection is modified while the
* operation is in progress. (Note that this will occur if the specified
* collection is this list, and it's nonempty.)
*
* 将指定集合中的所有元素按照指定集合的迭代器(可选操作)返回的顺序追加到此列表的末尾。
* 如果在操作进行期间修改了指定的集合，则此操作的行为未定义。
* (注意，如果指定的集合是这个列表，并且它不是空的，则会发生这种情况。)
*/
newStringList.addAll(Arrays.asList(string));
System.out.println("数组转换为List--boolean addAll(Collection<? extends E> c):\n" + newStringList);
}
/**
* 排序
*/
public static void sort(){
ArrayList<Integer> list = new ArrayList<Integer>();
/**
* 生成10个1到100以内的随机数
*/
Random r = new Random(1);
for (int i = 0; i < 10; i++) {
Integer in = r.nextInt(100);
list.add(in);
}
System.out.println("生成10个1到100以内的随机数集合:\n" + list);
Collections.sort(list);
System.out.println("升序:\n" + list);
Collections.sort(list,Collections.reverseOrder());
System.out.println("降序:\n" + list);
/**
* 最大的数&&最小的数
*/
int mun = Collections.max(list);
int mun1 = Collections.min(list);
System.out.println("list列表:\n" + list + "\n最大的数是:" + mun + "\n最小的数是:" + mun1);
/**
*Collections的sort方法是对集合元素进行自然排序，那么两个元素对象之间就一定要有大小之分。
* 这个大小之分是如何界定的？实际上，在使用Collections的sort排序的集合元素都必须是Comparable接口的实现类，
* 该接口表示其子类是可比较的，因为实现该接口必须重写抽象方法：
* int compareTo(T t);
* 该方法用于使当前对象与给定对象进行比较。
* 若当前对象大于给定对象，那么返回值应为>0的整数。
* 若小于给定对象，那么返回值应为<0的整数。
* 若两个对象相等，则应返回0。
* Comparator接口
* 一旦Java类实现了Comparable接口，其比较逻辑就已经确定，如果希望在排序的操作中临时指定比较规则，可以采用Compartor接口回调的范式。
* Comparator接口要求实现类必须重写其定义的方法： int compare（T o1,T o2）;
* 该方法的返回值要求：
* 若o1>o2，则返回值应>0；
* 若o1<o2，则返回值应<0；
* 若o1=o2，则返回值应=0。
*
*/
}
public static void operation(){
ArrayList<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("b");
System.out.println(list + "\n");
/**
* 如果list含有元素o，返回true
*/
String string = "b";
if (list.contains(string)){
System.out.println("\nlist集合包含元素" + string);
}
else {
System.out.println("\nlist集合不包含元素" + string);
}
/**
* list是否包含元素
*/
if (list.isEmpty()){
System.out.println("\nlist集合不包含任何元素");
}
else {
System.out.println("\nlist集合包含至少一个元素元素");
}
/**
* 返回指定index处的元素
*/
int index = 2;
String str = list.get(index);
System.out.println("\nlist列表的第" + index + "个索引下的元素为:" + str);
/**
*获取list中第一个匹配元素的index
*/
int index1 = list.indexOf(string);
System.out.println("\n获取list中第一个匹配元素" + string + "的下标为:" + index1);
/**
* 获取list中最后一个匹配元素的index
*/
int index2 = list.lastIndexOf(string);
System.out.println("\n获取list中最后一个匹配元素" + string + "的下标为:" + index2);
/**
* 替换指定index（下标）处的元素
*/
String replace = "3";
String s = list.set(index,replace);
System.out.println("\n替换list列表第" + index +"个下标的元素为:" + replace + ",新列表为:" + list);
/**
* 替换指定的元素
*/
Collections.replaceAll(list,"3","c");
System.out.println("\n替换指定的元素3为c:" + list);
}
}
