5.4Collections工具类、Arrays工具类、集合遍历方法总结以及集合嵌套

Collections工具类

集合的工具类，区别于Collection是集合的根接口。

常用方法

sort(List<T> list)  //排序
sort(List<T> list, Comparator<? super T> c)  //比较器排序

max(Collection coll)  //最大值
max(Collection coll，Comparator<? super T> comp)  //比较器最大值

binarySearch(List<? extends Comparable<? super T>> list, T key)  //二分查找
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)   //比较器二分查找

reverse(List<?> list)  //集合元素反转
reverseOrder()  //返回一个Comparator比较器  强行对自然排序进行反转
reverseOrder(Comparator<T> cmp)   //返回一个比较器  强行对原比较器顺序进行反转

shuffle(List<?> list)   //集合中的元素随机排序

demo：基本方法

import java.util.ArrayList;
import java.util.Collections;

public class Test2 {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("sdfh");
		al.add("ajdk");
		al.add("jakl");
		System.out.println(al);  //[sdfh, ajdk, jakl]
		
		Collections.sort(al);
		System.out.println(al);  //[ajdk, jakl, sdfh]
		
		String max = Collections.max(al);
		System.out.println(max);  //sdfh
		
		int index = Collections.binarySearch(al,"sdfh");  //2
		System.out.println(index);
		
		Collections.reverse(al);
		System.out.println(al);  //[sdfh, jakl, ajdk]
		
		Collections.shuffle(al);
		System.out.println(al);  //[ajdk, sdfh, jakl]
	} 
}

demo：比较器方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test2 {
	public static void main(String[] args) {
		ArrayList<Student> al = new ArrayList<Student>();
		al.add(new Student("chen0",10));
		al.add(new Student("chen2",20));
		al.add(new Student("chen1",30));
		al.add(new Student("chen1",20));
		
		//先按年龄排序，年龄相同按姓名排序
		Collections.sort(al, new Comparator<Student>(){
			@Override
			public int compare(Student stu1, Student stu2) {
				
				int num = stu1.getAge() - stu2.getAge();
				return num ==0 ? stu1.getName().compareTo(stu2.getName()) : num;
			}
			
		});
		System.out.println(al); //[姓名chen0年龄10, 姓名chen1年龄20, 姓名chen2年龄20, 姓名chen1年龄30]
		
		Collections.sort(al,Collections.reverseOrder(new Comparator<Student>() {
				public int compare(Student stu1, Student stu2) {	
				int num = stu1.getAge() - stu2.getAge();
				return num ==0 ? stu1.getName().compareTo(stu2.getName()) : num;
			}
		}));
		System.out.println(al);  //[姓名chen1年龄30, 姓名chen2年龄20, 姓名chen1年龄20, 姓名chen0年龄10]
	}
}
//Student部分没变
class Student{
	private String name;
	private int age;
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//重写hashCode方法
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	//重写equals方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "姓名"+name+"年龄"+age;
	}
}

同步方法

synchronizedList(List<T> list)   //返回加同步锁的List集合 保证线程安全
synchronizedSet(Set<T> s)   //返回加同步锁的Set集合  保证线程安全
synchronizedMap(Map<K,V> m)   //返回加同步锁的Map集合  保证线程安全

Arrays工具类

之前常用类中数组部分已经介绍了一点，这次统一介绍下。

常用方法：

基本都是重载方法

sort(int[] a)   //排序
binarySearch(int[] a, int key)  //二分查找
copyOf(int[] original, int newLength)   //复制
copyOfRange(int[] original, int from, int to)   //复制一部分
equals(int[] a, int[] a2)   //判断相同
toString(int[] a)  //数组转字符串
asList(T... a)   //数组转为List集合

demo：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		Integer[] arr = {4,3,5,8,2,1,6,7,9};
		
		//数组转为集合，可以使用集合思想和方法操作数组
		List<Integer> list = Arrays.asList(arr);
		System.out.println(list);  //[4, 3, 5, 8, 2, 1, 6, 7, 9]
		System.out.println(list.contains(5));  //true
		
		//注意将数组变成集合后不能使用集合增删方法，因为数组长度固定
		//其他只要不涉及数组长度变化的方法都可以使用
		//list.add(11);  //java.lang.UnsupportedOperationException
		//System.out.println(list);
		
		//集合转数组
		ArrayList<String> al = new ArrayList<String>();
		al.add("chen0");
		al.add("chen1");
		al.add("chen2");
		
		//集合转数组可以限制对元素的操作
		String[] str = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(str));  //[chen0, chen1, chen2]

	}
}

集合遍历方法总结

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

public class Test {
	public static void main(String[] args) {
		List<String> ls = new ArrayList<String>();
		
		ls.add("chen0");
		ls.add("chen1");
		ls.add("chen2");
		
		System.out.println("List集合");
		//List集合
		//方式1：普通for循环
		for(int i=0;i<ls.size();i++) {
			System.out.println(ls.get(i));
		}
		System.out.println("-------------");
		//方式2：增强for循环
		for(String temp : ls) {
			System.out.println(temp);
		}
		System.out.println("-------------");
		//方式3：Iterator迭代器
		for(Iterator<String> it = ls.iterator();it.hasNext();) {
			System.out.println(it.next());
		}
		System.out.println("-------------");
		//方式4：ListIterator  List特有的迭代
		for(ListIterator<String> li = ls.listIterator();li.hasNext();) {
			System.out.println(li.next());
		}
		
		Set<String> s = new HashSet<String>();
		
		s.add("chen0");
		s.add("chen1");
		s.add("chen2");
		
		System.out.println("Set集合");
		//Set集合
		//方式1：增强for循环
		for(String temp : s) {
			System.out.println(temp);
		}
		System.out.println("-------------");
		//方式2： 迭代器
		for(Iterator<String> it = s.iterator();it.hasNext();) {
			System.out.println(it.next());
		}
		
		System.out.println("Map集合");
		Map<String,String> m = new HashMap<String,String>();
		
		m.put("chen0", "java0");
		m.put("chen1", "java1");
		m.put("chen2", "java2");
		
		//方式1：增强for循环
		for(String temp: m.values()) {
			System.out.println(temp);
		}
		System.out.println("----------");
		//方式2：keySet
		Set<String> ms = m.keySet();
		for(Iterator<String> it = ms.iterator();it.hasNext();) {
			String key = it.next();
			System.out.println(key);
			System.out.println(m.get(key));
		}
		System.out.println("----------");
		//方式3：entrySet
		Set<Map.Entry<String,String>> s1 = m.entrySet();
		for(Iterator<Map.Entry<String,String>> it = s1.iterator();it.hasNext();) {
			Map.Entry<String, String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key);
			System.out.println(value);
		}
	}
}

集合嵌套

import java.util.HashMap;
import java.util.Set;
 
public class Test2 {
	public static void main(String[] args) {
		// 定义以和HashMap集合,值为HashMap集合
		HashMap<String, HashMap<String, Integer>> gra = new HashMap<String, HashMap<String, Integer>>();
		// 定义一班的学生
		HashMap<String, Integer> cla1 = new HashMap<String, Integer>();
		cla1.put("张三", 18);
		cla1.put("李四", 21);
		gra.put("一班", cla1);
		// 定义二班的学生
		HashMap<String, Integer> cla2 = new HashMap<String, Integer>();
		cla2.put("王五", 22);
		cla2.put("赵六", 24);
		gra.put("二班", cla2);
		// 遍历
		Set<String> gks = gra.keySet();// 获取大集合gra键的集合
		for (String gk : gks) {// 遍历大集合gra键的集合
			System.out.println("班级:" + gk);// 输出班级信息
			HashMap<String, Integer> gv = gra.get(gk);// 通过大集合的键获取值
			Set<String> cks = gv.keySet();// 遍历
			for (String ck : cks) {
				Integer cv = gv.get(ck);
				System.out.println("\t姓名:" + ck + "\t年龄:" + cv);
 
			}
		}
 
	}
}
/**结果:
班级:一班
姓名:李四	年龄:21
姓名:张三	年龄:18
班级:二班
姓名:王五	年龄:22
姓名:赵六	年龄:24
*/