Java基础<十三>---> 集合-工具类

第一 工具类

工具类的Collections和Arrays中的方法全是静态的，下面主要总结几个比较重要的方法。

一、Collections工具类：在Collections工具类中很多方法是用于对集合进行操作的，如比较，查找，随机排序等等

1、查找：

T max(Collection<? extends T> coll) ---> 根据集合的自然顺序，获取coll集合中的最大元素

T max(Collection<? extends T> coll,Comparator<? super T> comp) ---> 根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey) ---> 二分法搜索list集合中的指定对象

2、替换：

void fill(List<? super T> list, T obj) ---> 将list集合中的全部元素替换成指定对象obj

boolean replaceAll(List<T> lsit,T oldVal,T newVal) ---> 使用newVal替换list集合中的oldVal值

3、排序：

void shuffle(List<?> list) ---> 使用默认随机源对list集合中的元素进行随机排序

void sort(Lsit<T> list) ---> 根据自然顺序对list集合中的元素进行排序

void sort(List<T> lsit,Comparator<? super T> c) ---> 根据指定比较器c的排序方式对list集合进行排序

4、反转

reverse(List<?> list) ---> 反转list集合中元素的顺序

Comparator reverseOrder() ---> 返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

Comparator reverseOrder(Comparator<T> cmp) ---> 返回一个比较器，强行逆转了指定比较器的顺序

import java.util.*;
class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		sortDemo();

	}

	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list,new StrLenComparator());

		sop(list);

		//int index = Collections.binarySearch(list,"aaaa");
		//int index = halfSearch(list,"cc");
		int index = halfSearch2(list,"aaaa",new StrLenComparator());
		sop("index="+index);
	}

	public static int halfSearch(List<String> list,String key)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;

		while(min<=max)
		{
			mid = (max+min)>>1;//  /2;

			String str = list.get(mid);

			int num = str.compareTo(key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;

		while(min<=max)
		{
			mid = (max+min)>>1;//  /2;

			String str = list.get(mid);

			int num = cmp.compare(str,key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*,new StrLenComparator()*/);
		sop("max="+max);
	}

	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		
		sop(list);

		//Collections.sort(list);
		Collections.sort(list,new StrLenComparator());
		//Collections.swap(list,1,2);
		sop(list);
		
	}

	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);
	}
}
/*
class Student
{
}
list.add(new Student());

public static <T extends Comparable<? super T>> void sort(List<T> list)
{
	
}
*/

用collections的fill方法替换掉其中一部分元素：

public class UtilsTest {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("aaaa");
		list.add("bbbb");
		list.add("ccccc");
		list.add("dddddddd");
		list.add("eeeee");
		list.add("fffff");
		System.out.println("开始的:" + list);
		fillPart(list, 2, 4, "kkkkk");
	}

	private static void fillPart(List<String> list, int start, int end,
			String str) {
		List<String> li = new ArrayList<String>();
		for (int i = start; i < end; i++) {
			li.add(list.get(i));
			list.remove(list.get(i));
		}
		System.out.println("循环后的：" + list);
		Collections.fill(li, str);
		list.addAll(start, li);
		System.out.println("最后结果的：" + list);
	}
}

5、Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口，

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的

提供的方法中有可以对list集合进行排序，二分查找等方法。

通常常用的集合都是线程不安全的。因为要提高效率。

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

二、Arrays工具类：

1、Lsit<T> asList(T... a) ---> 将数组转换为集合

注意：将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的，如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

a.如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素

b.如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在

2、binarySearch()：查找方法，fill()：替换方法，sort()：排序方法等

特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作

如：sort(T[] a,Comparator<? super T> c)

fill(int[]a,int from,int to)等

3、String toString() 可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式

4、集合转为数组

void toString(String[] s) ---> 将集合转为指定数组s，并可通过Arrays.toString(s)获取数组s中的元素

1）指定类型的数组定义的长度：

a.当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size

b.当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组，并且多出的元素的值为null

2）为何将集合转为数组：为了限定对集合中元素的操作，如增删，因为想对创建的集合不做增删方面的操作。

import java.util.*;
class  ArraysDemo
{
	public static void main(String[] args) 
	{
//		int[] arr = {2,4,5};
//
//		System.out.println(Arrays.toString(arr));

		String[] arr = {"abc","cc","kkkk"};

		//把数组变成list集合有什么好处？
		/*
		可以使用集合的思想和方法来操作数组中的元素。

		注意：将数组变成集合，不可以使用集合的增删方法。
		因为数组的长度是固定。
		contains。
		get
		indexOf()
		subList();

		如果你增删。那么会反生UnsupportedOperationException,

		*/
		List<String> list = Arrays.asList(arr);
		//sop("contains:"+list.contains("cc"));
		//list.add("qq");//UnsupportedOperationException,

		//sop(list);

		//int[] nums = {2,4,5};
		Integer[] nums = {2,4,5};

		
		List<Integer> li = Arrays.asList(nums);

		/*
		如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		*/
		sop(li);

	}
	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);
	}

}

二 增强for循环

1、格式：

for(数据类型 变量名 : 被遍历的集合（Collection）或数组){执行语句}

2、说明：

1）对集合进行遍历，只能获取集合的元素，但是不能对集合进行操作。

2）迭代器除了遍历外，还可进行remove集合中元素的操作，如果使用ListIterator，还可在遍历过程中，对集合进行增删改查的操作。

3、传统for循环和增强for循环区别：

增强for循环有局限性。必须有被遍历的目标；而传统for循环有索引。所以建议在遍历数组时，使用传统for循环。

/*
 * 增强for循环练习
 * 格式：for(数据类型     变量名  ： 被遍历的集合(Collection)或数组 ){}
 * 对集合进行遍历只能获取元素不能操作集合
 * 
 * 一般for和高级for的区别
 * 高级for有个极限性必须有被遍历的目标
 * 在遍历数组时最好还是可以用一般for，因为可以定义角标，对其进行操作
 */
public class ImproveForTest {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(15);
		list.add(1);
		list.add(8);
		
		method(list);
		method_map();
	}
	
	private static void method(ArrayList<Integer> list){
		for(Integer i : list){
			System.out.println(i);
			i = 3;//for循环只能遍历集合不能操作集合
		}
		System.out.println("list:" + list);//for循环只能遍历集合不能操作集合
	}
	
	private static void method_map(){
		HashMap<Integer,String> hashmap = new HashMap<Integer, String>();
		hashmap.put(5, "dad");
		hashmap.put(4, "dg");
		hashmap.put(2, "hhhhh");
		hashmap.put(7, "aaaaaaa");
		
		Set<Integer> keySet = hashmap.keySet();
		for(Integer i : keySet){
			System.out.println("keysey:" + i + "," + hashmap.get(i));
		}
		
//		Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
//		for(Map.Entry<Integer,String> me : entrySet)
		for(Map.Entry<Integer,String> me : hashmap.entrySet()){
			System.out.println("map.entry:" + me.getKey() + "," + me.getValue());
		}
	}
}

三 可变参数

如果在参数列表中传入多个参数，个数不确定，每次都要复写该方法，可变参数的出现就可以省去复写的麻烦，而直接对数组进行操作

注意：可变参数一定要定义在参数列表的后面。

/*
JDK1.5版本出现的新特性。

方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。
*/
class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		//show(3,4);
		/*
		//虽然少定义了多个方法。
		但是每次都要定义一个数组。作为实际参数。

		int[] arr = {3,4};
		show(arr);

		int[] arr1 = {2,3,4,5};
		show(arr1);
		*/

		/*
		可变参数。
		其实就是上一种数组参数的简写形式。
		不用每一次都手动的建立数组对象。
		只要将要操作的元素作为参数传递即可。
		隐式将这些参数封装成了数组。

		*/
		show("haha",2,3,4,5,6);
		//show(2,3,4,5,6,4,2,35,9,"heh");
		//show();

	}
	public static void show(String str,int... arr)
	{
		System.out.println(arr.length);
	}
	/*
	public static void show(int[] arr)
	{
		
	}
	*/
	/*
	public static  void show(int a,int b)
	{
		System.out.println(a+","+b);
	}
	public static  void show(int a,int b,int c)
	{}
	*/
}

四 静态导入

静态导入，是将类中的所有静态成员导入进来，但需要注意的是，当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

当类名重名时，需要制定具体的包名；当方法名重名时，制定具体所属的对象或类。

1、import static java.util.Arrays.*; ---> 写入的是Arrays类中的所有静态成员。

2、import static java.lang.System.*; ---> 导入了System类中的所有静态成员

/*
StaticImport  静态导入。

当类名重名时，需要指定具体的包名。
当方法重名是，指定具备所属的对象或者类。
*/

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
/*
packa/Demo.class 
packb/Demo.class

import packa.*;
import packb.*;
*/

import static  java.lang.System.*;//导入了System类中所有静态成员。

class  StaticImport //extends Object
{
	public static void main(String[] args) 
	{

		out.println("haha");
		int[] arr = {3,1,5};

		sort(arr);
		int index = binarySearch(arr,1);
		out.println(Arrays.toString(arr));
		System.out.println("Index="+index);

		ArrayList al = new ArrayList();
		al.add(1);
		al.add(3);
		al.add(2);

		out.println(al);

		sort(al);
		out.println(al);
	}
}