Java-Collections集合常用方法

Collections集合常用操作方法；
   public static <T> boolean addAll(Collection<T>,T...elements):向集合中一次添加任意数量元素
   public static void shuffle(List<?> list):打乱集合顺序
   public static <T> void sort(List<T> list):将集合中的元素按照默认规则排序
          1.已经定义好的类，已经实现并重写Comparable接口中的compareTo方法可以直接使用,默认升序排列                                         
          2.自定义类型，需要实现并重写Comparable接口(java.lang包)中的compareTo方法
                      int compareTo(T o)将此对象与指定的对象进行比较以进行排序。
                              *this.stuAge-o.stuAge:升序排列
                              *o.stuAge-this.age:降序排列
   public static <T> void sort(List<T> list,Comparator<? super T>):将集合中指定元素按照指定规则排序                           
         1.已经定义好的类和自定义类型，都需要实现并重写Comparable接口(java.util包)中的compare方法
                     int compare(T o1, T o2)：比较其两个参数的顺序 
                              *o1.stuAge-o2.stuAge:升序排列
                              *o2.stuAge-o1.age:降序排列            
                                       

public class CollectionMethodDemo {
	public static void main(String[] args) {
		Collection<String> col=new ArrayList<>();
		//public static <T> boolean addAll(Collection<T>,T...elements):向集合中一次添加任意数量元素
		//当然也可以使用add方法添加多个元素
//		col.add("abc");
//		col.add("def");
//		col.add("ghi");
		Collections.addAll(col, "abc","def","ghi");
		System.out.println(col);//输出结果：[abc, def, ghi]
		
		//public static void shuffle(List<?> list):打乱集合顺序,注意需要是List集合
		//Collections.shuffle(col);错误写法
		ArrayList<String> al1=new ArrayList<>();
		Collections.addAll(al1, "abc","def","ghi");//输出结果：[abc, def, ghi]
		Collections.shuffle(al1);
		System.out.println(al1);//输出结果：[def, ghi, abc] 可能每次输出顺序都不同
		
		// public static <T> void sort(List<T> list):将集合中的元素按照默认规则排序
		//Java已经定义好的类，已经重写了Compareble接口，可以直接使用，以Integer和String类为例
		ArrayList<Integer> al2= new ArrayList<>();
		Collections.addAll(al2,2,1,4,3);
		System.out.println(al2);//输出结果：[2, 1, 4, 3]
		Collections.sort(al2);
		System.out.println(al2);//输出结果：[1, 2, 3, 4]
		
		ArrayList<String> al3= new ArrayList<>();
		Collections.addAll(al3,"cd","ab","efg");
		System.out.println(al3);//输出结果：[cd, ab, efg]
		Collections.sort(al3);
		System.out.println(al3);//输出结果：[ab, cd, efg]
		
		//自定义类型，需要重写Compareble接口中的compare方法
		Student stu1 = new Student("张三",18);
		Student stu2 = new Student("李四",16);
		Student stu3 = new Student("王五",19);
		ArrayList<Student> al4= new ArrayList<>();
		Collections.addAll(al4, stu1,stu2,stu3);
		System.out.println(al4);//输出结果：[Student [stuName=张三, stuAge=18], Student [stuName=李四, stuAge=16], Student [stuName=王五, stuAge=19]]
		Collections.sort(al4);
		System.out.println(al4);//升序排序输出结果：[Student [stuName=李四, stuAge=16], Student [stuName=张三, stuAge=18], Student [stuName=王五, stuAge=19]]
		                        //降序排序输出结果：[Student [stuName=王五, stuAge=19], Student [stuName=张三, stuAge=18], Student [stuName=李四, stuAge=16]]
	
	
	    // public static <T> void sort(List<T> list,Comparator<? super T>):将集合中指定元素按照指定规则排序
	    //Java已经定义好的类
		ArrayList<Integer> al5= new ArrayList<>();
		Collections.addAll(al5,2,1,4,3);
		System.out.println(al5);//输出结果：[2, 1, 4, 3]
		//使用匿名类对象进行
		Collections.sort(al5,new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				//return o1-o2;//升序
				return o2-o1;//降序
			}
			
		});
		System.out.println(al2);//升序输出结果：[1, 2, 3, 4]
		                        //降序输出结果：[4, 3, 2, 1]
		
	  
		// 自定义的类
		//单一属性进行排序
		Student stu01 = new Student("张三",18);
		Student stu02 = new Student("李四",16);
		Student stu03 = new Student("王五",19);
		ArrayList<Student> al6= new ArrayList<>();
		Collections.addAll(al6, stu01,stu02,stu03);
		Collections.sort(al6,new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				// TODO Auto-generated method stub
				//return o1.getStuAge()-o2.getStuAge();//按年龄升序
				return o2.getStuAge()-o1.getStuAge();//按年龄升序
			}
		});
	      System.out.println(al6);//升序输出结果：[Student [stuName=李四, stuAge=16], Student [stuName=张三, stuAge=18], Student [stuName=王五, stuAge=19]]
	                              //升序输出结果：[Student [stuName=王五, stuAge=19], Student [stuName=张三, stuAge=18], Student [stuName=李四, stuAge=16]]
	
	      
	      
	    //多属性进行排序
			Student stu04 = new Student("张三",18);
			Student stu05 = new Student("李四",16);
			Student stu06 = new Student("王五",19);
			Student stu07 = new Student("王五",18);
			ArrayList<Student> al7= new ArrayList<>();
			Collections.addAll(al7, stu04,stu05,stu06,stu07);
			Collections.sort(al7,new Comparator<Student>() {

				@Override
				public int compare(Student o1, Student o2) {
					// TODO Auto-generated method stub
					//return o1.getStuAge()-o2.getStuAge();//按年龄升序，如果不进行判断，出现相同的属性值时，就会按照出现的先后顺序进行排列
				//用一个变量接收返回值，然后再进行判断
					int  a = o1.getStuAge()-o2.getStuAge();
					if(a==0){
						a=o1.getStuName().charAt(0)-o2.getStuName().charAt(0);//年龄相同，采用名字首字母进行排序
					}
					return a;
					
				
				}
			});
		      System.out.println(al7);//按年龄升序，不进行判断输出结果：Student [stuName=李四, stuAge=16], Student [stuName=张三, stuAge=18], Student [stuName=王五, stuAge=18], Student [stuName=王五, stuAge=19]]
		                              //升序输出结果：[Student [stuName=李四, stuAge=16], Student [stuName=张三, stuAge=18], Student [stuName=王五, stuAge=18], Student [stuName=王五, stuAge=19]]
	}

}

class Student implements Comparable<Student>{
	private String stuName;
	private int stuAge;
	public Student() {
		// TODO Auto-generated constructor stub
	}
	
	public Student(String stuName, int stuAge) {
		super();
		this.stuName = stuName;
		this.stuAge = stuAge;
	}

	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public int getStuAge() {
		return stuAge;
	}
	public void setStuAge(int stuAge) {
		this.stuAge = stuAge;
	}
	
    @Override
	public String toString() {
		return "Student [stuName=" + stuName + ", stuAge=" + stuAge + "]";
	}

  //重写compareTo方法
	@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
		//return this.stuAge-o.stuAge;//升序排序
		return o.stuAge-this.stuAge;//降序排序
		
		
	}

	
	
	
}