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 StrComparator
				
		TreeSet<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集合的操作1
		Set<Integer> keySet = hm.keySet();
		for (Integer i : keySet)
		{
			System.out.println(i+"::"+hm.get(i));
		}
		//高级for循环对map集合的操作2
		Set<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);
	}
}

运行结果：