【9】Collections集合工具类 方法 addAll shuffle sort sort(list,comparato)

Collections集合工具类

java.util.Colletions是集合工具类，用来对集合进行操作，部分方法如下：

1. addAll  往集合中添加多个元素
2. shuffle  打乱集合中的元素

public class Test19 {
	public static void main(String[] args) {
		/*
		 * public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。
		 * */
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "a","b","c");//往集合中存入多个元素一次性
		System.out.println(list);
		
		/*
		 * public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
		 * */
		Collections.shuffle(list);
		System.out.println(list);//将集合中的内容打乱
		
	}
}

public static <T> void sort(List<T> list)   将集合中的元素排序 升序

如果集合是排序自定义的内容，那么自定义的类要实现comparable接口，重写compareto方法定义排序规则

如果是基本数据类型直接使用sort方法。

 person类

public class Person	implements Comparable<Person> {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		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;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public int compareTo(Person o) {
		//return this.getAge()-o.getAge();//升序
		return o.getAge()-this.getAge(); //降序
	}
	
	
}

public class Test20 {
	public static void main(String[] args) {
		/*
		 * public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
		 * 注意：
		 * 		sort方法使用前提
		 * 			被排序的集合里边存储的元素，必须实现comparable接口，重写接口中的方法compareto定义排序的规则
		 * */
		 
		//comparable接口的排序规则：
		//			自己（this）-参数，升序
		//        	参数-this 降序
		
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(4);
		list.add(2);
		list.add(3);
		Collections.sort(list);
		System.out.println(list);//sort 方法将集合中的元素升序排序 [1, 2, 3, 4]
		
		/*
		 * 自定义类的sort方法使用 
		 * */
		ArrayList<Person> plist = new ArrayList<>();
		plist.add(new Person("张三",15));
		plist.add(new Person("李四",20));
		plist.add(new Person("王五",19));
		Collections.sort(plist);
		System.out.println(plist);
		
	}
}

public static <T> void sort(List<T> list ， Comparator<? super T> ) : 将集合中元素按照指定规则排序。

                /*
		 * comparator和comparable区别：
		 * compatible：自己(this)和别人(参数)比较，自己需要实现comparable接口，重写比较的规则compareto方法
		 * comparator：相当于找一个第三方的裁判，比较两个
		 * 
		 * comparator的排序规则：01-02升序
		 * */
		ArrayList<Integer> list = new ArrayList<>();
		list.add(2);
		list.add(3);
		list.add(1);
		System.out.println(list);//[2, 3, 1]
		
		Collections.sort(list, new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return o1-o2;//升序排序
				//return o2-o1;//降序排序
			}
		});
		
		System.out.println(list);//[1, 2, 3]
		
		ArrayList<Student> as = new ArrayList<>();
		as.add(new Student("a张三",20));
		as.add(new Student("赵四",19));
		as.add(new Student("王五",25));
		as.add(new Student("b李白",20));
		/*Collections.sort(as, new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				//按照年龄升序排序
				return  o1.getAge()-o2.getAge()
			}
		});*/
		
		//如果年龄相同就按照名字的第一个字母排序
		Collections.sort(as, new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				int result = o1.getAge()-o2.getAge();
				//如果两个人的年龄相同，就按照名字的第一个字母比较
				if (result==0) {
					result=o1.getName().charAt(0)-o2.getName().charAt(0);
				}
				return result;
			}
		});
		System.out.println(as);//[name=赵四, age=19, name=a张三, age=20, name=b李白, age=20, name=王五, age=25]
	}
}