Java基础——集合框架工具类(Collections类和Arrays类)

个人小结：集合框架工具类中常用的有Collections和Arrays，他们提供了很多封装好的静态方法，专门用于对集合数据的操作，非常方便快捷。

一、Collections

Collections是对集合框架的一个工具类。它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

常见方法：

1、max(Collection<? extends T> coll) ：根据元素的自然顺序，返回给定 collection 的最大元素。

2、max(Collection<? extends T> coll, Comparator<? super T> comp) ： 根据指定比较器产生的顺序，返回给定 collection 的最大元素。

3、binarySearch(List<? extends Comparable<? super T>> list, T key) ： 使用二分搜索法搜索指定列表，以获得指定对象。

4、binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ：使用二分搜索法搜索指定列表，以获得指定对象。

5、fill(List<? super T> list, T obj) ：使用指定元素替换指定列表中的所有元素。

6、replaceAll(List<T> list, T oldVal, T newVal) ：使用另一个值替换列表中出现的所有某一指定值

7、swap(List<?> list, int i, int j) ： 在指定列表的指定位置处交换元素

8、sort(List<T> list) ：根据元素的自然顺序 对指定列表按升序进行排序

9、sort(List<T> list, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定列表进行排序

10、reverse(List<?> list) ：反转指定列表中元素的顺序。

11、reverseOrder() ：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

12、reverseOrder(Comparator<T> cmp) ：返回一个比较器，它强行逆转指定比较器的顺序。

Collections与Collection的区别：

1、Collection是java.util包下的集合接口，是多种集合结构的根接口。Collection提供了对集合对象进行基本操作的通用接口方法，JDK 不提供此接口的任何直接实现，但它提供更具体的子接口（如 Set和 List）的实现。Collection的意义在于为各种具体的集合对象提供最大化的统一操作方式，如插入、删除、判断一个元素是否其成员、遍历等基本操作。

2、Collections是java.util包下一个类，此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。这些方法可以实现对各类集合对象的搜索,排序,线程安全化等操作。它包含在 collection上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

示例：

import java.util.*;class  CollectionsDemo{public static void main(String[] args) {//sortDemo();//排序//maxDemo();//求最大值binarySearchDemo();//二分查找}<span style="white-space:pre"></span>//<span style="font-family: Arial, Helvetica, sans-serif;">二分查找</span>public static void binarySearchDemo(){List<String> list = new ArrayList<String> ();list.add("abcd");list.add("aaaa");list.add("z");list.add("kkkkh");list.add("ggg");list.add("a");Collections.sort(list,new StrLenComparator());sop(list);//int index  = Collections.binarySearch(list,"ggg");//sop("index="+index);//int index2 = halfSearch(list,"ggg");//sop("index2="+index2);int index3 = halfSearch2(list,"aaaa",new StrLenComparator());sop("index3="+index3);}<span style="white-space:pre"></span>//求最大值<span style="white-space:pre"></span>public static void maxDemo(){List<String> list = new ArrayList<String> ();list.add("abcd");list.add("aaaa");list.add("z");list.add("kkkkh");list.add("ggg");list.add("a");sop(list);String max = Collections.max(list/*,new StrLenComparator()*/);sop("max="+max);}<span style="white-space:pre"></span>//排序public static void sortDemo(){List<String> list = new ArrayList<String> ();list.add("abcd");list.add("aaaa");list.add("z");list.add("kkkk");list.add("ggg");list.add("a");sop(list);//Collections.sort(list);Collections.sort(list,new StrLenComparator());sop(list); }<span style="white-space:pre"></span>//封装打印功能public static void sop(Object obj){System.out.println(obj);}}//实现比较器接口class StrLenComparator implements Comparator<String>{public int compare(String s1,String s2){if (s1.length()>s2.length())return 1;if (s1.length()<s2.length())return -1;return s1.compareTo(s2);}}

练习：

import java.util.*;class StrComparator implements Comparator<String>//实现比较器接口{public int compare(String s1,String s2){/*int num = s1.compareTo(s2);if(num>0)return -1;if(num<0)return 1;return num;*/return s2.compareTo(s1);}}//自定义一个比较字符串长度的比较器class StrLenComparator implements Comparator<String>{public int compare(String s1,String s2){if (s1.length()>s2.length())return 1;if (s1.length()<s2.length())return -1;return s1.compareTo(s2);}}class CollectionsDemo2 {public static void main(String[] args) {fillDemo();//替换replaceAllDemo();//<span style="font-family: Arial, Helvetica, sans-serif;">新字符子串替换旧字符子串</span>orderDemo();//排序}<span style="white-space:pre"></span>//排序public static void orderDemo(){//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());  //new StrComparatorTreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));ts.add("abcd");ts.add("aaaa");ts.add("z");ts.add("kkkkh");ts.add("ggg");ts.add("a");Iterator it = ts.iterator();while (it.hasNext()){sop(it.next());}}<span style="white-space:pre"></span>//新字符子串替换旧字符子串public static void replaceAllDemo(){List<String> list = new ArrayList<String> ();list.add("abcd");list.add("aaaa");list.add("z");list.add("kkkkh");list.add("ggg");list.add("a");sop(list);Collections.replaceAll(list,"ggg","pp");Collections.reverse(list);sop(list);}/*练习。fill方法可以将list集合中所有元素替换成指定元素，将list集合中部分元素替换成指定元素。*/public static void fillDemo(){List<String> list = new ArrayList<String> ();list.add("abcd");list.add("aaaa");list.add("z");list.add("kkkkh");list.add("ggg");list.add("a");sop(list);Collections.fill(list,"pp");sop(list);}<span style="white-space:pre"></span>//封装打印功能public static void sop(Object obj){System.out.println(obj);}}

运行结果：

二、Arrays

 Arrays是用于操作数组的工具类。里边的方法也全是静态的。

常见方法：

asList方法：将数组转换成list集合。
String[] arr = {"abc","kk","qq"};
List<String> list = Arrays.asList(arr);//将arr数组转成list集合。
将数组转换成集合的好处：可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set； 
注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
如果数组中存储的是引用数据类型，作为集合的元素可以直接用集合方法操作。
如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

示例：

import java.util.*;class ArraysDemo {public static void main(String[] args) {//int[] arr = {2,4,5};//sop(Arrays.toString(arr));String [] arrStr = {"abc","cc","kkkk"};//把数组变成list集合有什么好处？/*可以使用集合的思想和方法来操作数组中的元素。*/List<String> list =Arrays.asList(arrStr);//sop("contains:"+list.contains("cc"));//list.add("qq"); //UnsupportedOperationException,//sop(list);int[] nums = {2,4,5};List<int[]> li = Arrays.asList(nums);Integer[] in = {3,4,5};List<Integer> li2 = Arrays.asList(in);/*如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。*/sop(li);sop(li2);}public static boolean myContains(String[] arr,String key){for (int x=0; x<arr.length ;x++ ){if (arr[x].equals(key))return true;}return false;}public static void sop(Object obj){System.out.println(obj);}}

运行结果：

集合变数组：

用的是Collection接口中的方法：toArray();
注意：

如果给toArray传递的指定类型的数组长度小于了集合的size，那么toArray方法，会自动再创建一个该类型的数据，长度为集合的size。
如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。
将集合变成数组的好处：为了限定对元素的操作。不需要进行增删了。

示例：

import java.util.*;class CollectionToArray {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");<span style="white-space:pre"></span>//指定长度和size相等的数组String [] arr = al.toArray(new String[al.size()]);System.out.println(Arrays.toString(arr));}}

运行结果：

三、Jdk5.0新特性：

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

1、高级for循环：for each语句，for each简化了迭代器。
格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for( 元素类型 变量名 : Collection集合 & 数组 ) { …}
1.1 高级for循环和传统for循环的区别：
高级for循环在使用时，必须要明确被遍历的目标（可以是Collection集合或者数组），在遍历过程中不能对元素进行操作。

如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
1.2 高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用for each语句。
1.3 增强for循环迭代数组：
String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
for(String s : arr) {
System.out.println(s);

}
1.4 单列集合 Collection：
List list = new ArrayList();
list.add("aaa");
// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
for(Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
1.5 双列集合 Map：
Map map = new HashMap();
map.put("a", "aaa");
// 传统方式：必须掌握这种方式
Set entrys = map.entrySet(); // 1.获得所有的键值对Entry对象
iter = entrys.iterator(); // 2.迭代出所有的entry
while(iter.hasNext()) {
Map.Entry entry = (Entry) iter.next();
String key = (String) entry.getKey(); // 分别获得key和value
String value = (String) entry.getValue();
System.out.println(key + "=" + value);
}
// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
for(Object obj : map.entrySet()) {
Map.Entry entry = (Entry) obj;  // obj 依次表示Entry
System.out.println(entry.getKey() + "=" + entry.getValue());
}
1.6 增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；
int[] arr = {1,2,3};
for(int num : arr) {
num = 0; //不能改变数组的值
}
System.out.println(arr[1]); //2

示例：

import java.util.*;class ForEachDemo {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc4");for (String s : al){s = "kk";System.out.println(s);}//System.out.println(al);/*Iterator<String> it = al.iterator();while (it.hasNext()){System.out.println(it.next());}*///高级for循环对数组的操作int[] arr = {3,5,1};for (int i : arr ){System.out.println("i:"+i);}HashMap<Integer,String> hm = new HashMap<Integer,String>();hm.put(1,"a");hm.put(2,"b");hm.put(3,"c");//高级for循环对map集合的操作1Set<Integer> keySet = hm.keySet();for (Integer i : keySet){System.out.println(i+"::"+hm.get(i));}//高级for循环对map集合的操作2Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();for (Map.Entry<Integer,String> me : entrySet ){System.out.println(me.getKey()+":::"+me.getValue());}}}

运行结果：

2、可变参数（...）：

用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

和以前接收数组不一样的是：
以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。

示例：

import java.util.*;class ParamMethodDemo {public static void main(String[] args) {//show(3,4);//虽然少定义了多个方法，//但是每次都要定义一个数组，作为实际参数。/*int[] arr = {3,4};show(arr);int[] arr1 = {3,4,5};show(arr1);*//*可变参数，其实就是上一种数组参数的简写形式。不用每次都手动的建立数组对象。只要将操作的元素作为参数传递即可。隐式滴将这些参数封装成了数组。*/show("haha",2,2,3,4,5,6);//show(2,2,3,4,5,6,4,5,6,75);}public static void show(String str,int... arr)//使用可变参数{System.out.println(str);<span style="white-space:pre"></span>for(int i : arr)<span style="white-space:pre"></span>{<span style="white-space:pre"></span>System.out.println(i);<span style="white-space:pre"></span>}}}

运行结果：

3、静态导入：

就是导入类中的所有静态成员，简化静态成员的书写。
写法：
       import static java.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。
       没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);
注意：
       当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
       当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。

示例：

import java.util.*;import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。 import static java.lang.System.*;//导入了System类中所有的静态成员。class StaticImport  extends Object{public static void main(String[] args) {int[] arr = {3,1,5};sort(arr);//省略了Arrays.int index = binarySearch(arr,1);/*System.*/out.println(Arrays.toString(arr));//省略了System.System.out.println("index="+ index);}}

运行结果：