Collections用法总结

Collections是一个包装类，其中包含有各种有关集合操作的静态多态方，比如可以作用在List和Set上，此类不能实例化。

排序

Integer[] array = new Integer[]{3, 10, 4, 0, 2};
List<Integer> integers = Arrays.asList(array);
Collections.sort(integers);
out.println(integers); //[0, 2, 3, 4, 10]

在这里借用了Arrays的asList方法，该方法可以将数组转成一个List。这里也只能对封装类型Integer数组调用asList方法，如果是int型的数组调用asList会出现其他问题。可以查考Arrays用法总结。

随机排序

out.println(integers); //[0, 2, 3, 4, 10]
Collections.shuffle(integers);
out.println(integers); //[0, 3, 10, 2, 4]

反转

out.println(integers); //[0, 3, 10, 2, 4]
Collections.reverse(integers);
out.println(integers); //[4,2,10,3,0]

 

Collections.binarySearch (Collection,Object  )解释：查找指定集合中得元素，返回所查找得元素索引
List<Integer> list = new ArrayList<> (  );
list.add ( 1 );
list.add ( 2 );
list.add ( 3 );
list.add ( 34 );
list.add ( 43 );
int ss = Collections.binarySearch ( list,2 );
System.out.println (ss);//1


填充（覆盖）元素

array = new Integer[]{3, 10, 4, 0, 2};
integers = Arrays.asList(array);
Collections.fill(integers, -1);
out.println(integers); //[-1, -1, -1, -1, -1]
out.println(Arrays.toString(array)); //[-1, -1, -1, -1, -1]

通过输出可以发现原数组的值也跟着发生了变化，因为是封装类型，所以Integer[]中和List<Integer>中的元素指向的是用一个Integer对象的地址，所以两个会一起变化。

替换元素
array = new Integer[]{3, 10, 4, 4, 4};
integers = Arrays.asList(array);
Collections.replaceAll(integers, 4, -4);//(含义：替换批定元素为某元素，若要替换得值存在在返回TRUE否则返回FALSE)
out.println(integers); //[3, 10, -4, -4, -4]

拷贝List

out.println(integers); //[3, 10, -4, -4, -4]
List<Integer> integersCopy = new ArrayList<>();  integersCopy.add(1);
integersCopy.add(1);
integersCopy.add(1);
integersCopy.add(1);
integersCopy.add(1);
integersCopy.add(1);
//如果不对List调用add方法，integerCopy还是空的，下面的copy方法会出错
Collections.copy(integersCopy, integers);
out.println(integersCopy); //[3, 10, -4, -4, -4, 1]


返回List中的最大值，最小值

array = new Integer[]{3, 10, 4, 0, 2};
integers = Arrays.asList(array);
out.println(integers);
out.println(Collections.min(integers)); //0
out.println(Collections.max(integers)); //10

源列表中第一次和最后一次出现指定列表的起始位置

Integer[] array1 = new Integer[]{3, 10, 4, 0, 2, 4, 0};
List integers1 = Arrays.asList(array1);
Integer[] array2 = new Integer[]{4, 0};
List integers2 = Arrays.asList(array2);
out.println(Collections.lastIndexOfSubList(integers1, integers2)); //5
out.println(Collections.indexOfSubList(integers1, integers2)); //2(含义：查找integers2首次出现在integers1位置索引从0开始)

 

fill(List list,Object o)解释:用对象 o 替换集合list中所有元素。

List list = Arrays.asList ( "1 2 323 4 5 6".split ( " " ) );
Collections.fill ( list,"我是被替换的" );
System.out.println (list);//[我是被替换的, 我是被替换的, 我是被替换的, 我是被替换的, 我是被替换的, 我是被替换的]

循环移动

out.println(integers); [3, 10, 4, 0, 2]
Collections.rotate(integers, 1); //[2, 3, 10, 4, 0] 依次右移一位
out.println(integers);
Collections.rotate(integers, -2); //[10, 4, 0, 2, 3] 依次左移两位
out.println(integers);

二分查找，返回所在的下标。没有找到返回负的下标值。

array = new Integer[]{0, 2, 4, 10, 20};
integers = Arrays.asList(array);
out.println(Collections.binarySearch(integers, 4)); //2
out.println(Collections.binarySearch(integers, 9)); //-4

指定元素在集合中出现的次数

array = new Integer[]{0, 2, 4, 4, 20};
integers = Arrays.asList(array);
out.println(Collections.frequency(integers, 4)); //2

得到对象的n份拷贝

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
List<List<Integer>> lists = Collections.nCopies(3, numbers);
out.println(lists); //[[1], [1], [1]]
numbers.add(2);
out.println(lists); //[[1, 2], [1, 2], [1, 2]]

Collections.nCopies(n, object)返回一个List对象，该List对象中含有对象object的n份拷贝，然而实际上列表中并没有存储n份拷贝，从中任意取出一个时，得到的是同一个object。

转载于:https://www.cnblogs.com/ysySelf/p/11044652.html