Collection 和Collections的区别以及Collections的常用方法

1. Collection:
Collection是集合类的上层接口，Set,List就是继承了Collection接口。
2.Collections:
Collections是继承于Object类下的一个包装类，它包含对集合进行操作的多态方法(静态)。如果提供给它的集合或类对象是null,那么在调用这个包装类里面的方法时，都会抛出一个空指针异常。
Collections类的方法：
(1) copy(List<? super T> dest, List<? extends T> src);
将一个列表中的所有元素复制到另一个列表中 ，复制之后不会改变元素在列表的顺序,必须保证目的列表的长度大于或者等于原列表的长度否则会抛出索引越界异常
src:原列表    dest:目的列表
int srcSize = src.size();
if (srcSize > dest.size())
throw new IndexOutOfBoundsException(“Source does not fit in dest”);

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		//List<Integer> list2 =new ArrayList<>(10);//这里的10只是指定了列表的容量，而并不是列表的长度
		//Arrays.alist(T...a) //返回由指定数组支持的固定长度的列表
		List<Integer> list2 = new ArrayList<>(Arrays.asList(new Integer[list1.size()]));
		Collections.copy(list2, list1);
		for (Integer integer : list2) {
			System.out.println(integer);
		}
	}

1
2
3
4
5

(2)disjoint(Collection<?> c1, Collection<?> c2)
如果两个指定的集合没有共同的元素，则返回 true 。集合不能为空。

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		List<Integer> list2 =new ArrayList<>();
		for(int i =6;i<=10;i++){
			list2.add(i);
		}
		boolean flag = Collections.disjoint(list1, list2);
		System.out.println(flag);
	}

true

(3)fill(List<? super T> list, T obj)
用指定的元素代替指定列表的所有元素。

//用fill方法替换掉list集合部分元素
public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		List<Integer> list2 =list1.subList(0, 2);//截取了1，2
		Collections.fill(list2,6);//把截取的元素都用6来替换
		for (Integer integer : list1) {
			System.out.println(integer);
		}
	}

6
6
3
4
5

(4) indexOfSubList(List<?> source, List<?> target)
返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		//遍历原列表中的元素
		for (Integer integer : list1) {
			System.out.print(integer+" ");
		}
		System.out.println();
		List<Integer> list2 =list1.subList(2, 4);//截取3，4
		//遍历子列表中的元素
		for (Integer integer : list2) {
			System.out.print(integer+" ");
		}
		System.out.println();
		//返回子列表在原列表第一次出现的位置
		int index =Collections.indexOfSubList(list1,list2);
		System.out.println(index);
	}

1 2 3 4 5 1 2 3 4 5 
3 4 
2

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

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		Collections.reverse(list1);
		for (Integer integer : list1) {
			System.out.println(integer);
		}
	}

5
4
3
2
1

(6)sort(List list)
根据其元素的natural ordering对指定的列表进行排序。

package Test02;

public class Student implements Comparable<Student>  {
	private String name;
	private double score;
	
	public Student() {
		super();
	}
	public Student(String name, double score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	@Override
	public int compareTo(Student o) {
		if(this.score<o.score){
			return -1;
		}else{
			return 1;	
		}
	}
}

public class TestSort {
	public static void main(String[] args) {
		Student s1 =new Student("张三",80);
		Student s2 =new Student("李四",70);
		Student s3 =new Student("王五",90);
		List<Student> list =new ArrayList<>();
		list.add(s1);
		list.add(s2);
		list.add(s3);
		Collections.sort(list);
		for (Student student : list){
			System.out.println(student.getName()+"\t"+student.getScore());
		}
	}
}

李四	70.0
张三	80.0
王五	90.0

(7)sort(List list, Comparator<? super T> c)
根据指定的比较器引起的顺序对指定的列表进行排序。

public class Student{
	private String name;
	private double score;
	
	public Student() {
		super();
	}
	public Student(String name, double score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
}

public class TestSort01 {
	public static void main(String[] args) {
		Student s1 =new Student("张三",80);
		Student s2 =new Student("李四",70);
		Student s3 =new Student("王五",90);
		List<Student> list =new ArrayList<>();
		list.add(s1);
		list.add(s2);
		list.add(s3);
		Collections.sort(list,new Comparator<Student>(){
			@Override
			public int compare(Student o1, Student o2) {
				return (int)(o1.getScore()-o2.getScore());
			}
		});
		for (Student student : list) {
			System.out.println(student.getName()+"\t"+student.getScore());
		}
	}
}

李四	70.0
张三	80.0
王五	90.0

(8)max/min(Collection<? extends T> coll)
根据其元素的 自然顺序返回给定集合的最大/(小)元素。

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		System.out.println("list集合中的最大元素："+Collections.max(list1));
		System.out.println("list集合中的最小元素："+Collections.min(list1));
	}

list集合中的最大元素：5
list集合中的最小元素：1

此处不需要再实现Comparable接口了，因为Integer这个包装类已经实现这个接口了
public final class Integer extends Number implements Comparable{}

(9)max/min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最大/(小)元素。

public static void main(String[] args) {
		List<Integer> list1 =new ArrayList<>();
		for(int i =1;i<=5;i++){
			list1.add(i);
		}
		Integer intemax =Collections.max(list1, new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1-o2;
			}	
		});
		Integer intemin =Collections.min(list1, new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1-o2;
			}	
		});
		System.out.println("list集合中的最大元素："+intemax);
		System.out.println("list集合中的最小元素："+intemin);
	}

list集合中的最大元素：5
list集合中的最小元素：1