可变类型参数，Collections的addAll()方法，sort方法，shuffle方法

/*
可变参数:
概述:在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化.
格式:
修饰符 返回值类型 方法名(数据类型… 变量名){}
*/
#### 注意事项

​ 1.一个方法只能有一个可变参数
//public static void getNums(int…sum,String…strings){
//编译报错，有两个可变参数
//}
​ 2.如果方法中有多个参数，可变参数要放到最后。
//public static void getNums(String…nus,int a){
//编译报错，可变参数没有放到最后
//}
2.Collections的addAll()方法

  ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"ad","1","我是中国人");//第一个参数是list集合
        //第二个参数是元素类型
        System.out.println(list);

3.Collections的shuffle方法

• public static void shuffle(List<?> list):打乱集合顺序。
• 代码如下：

package Collecions的常用方法;

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

/**
 * @author weijisheng
 * @create 2021-07-31 11:19
 */
public class ShuffleTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(23);
        list.add(13);
        list.add(223);
        list.add(1);
        list.add(57);
        list.add(18);
        list.add(45);
        list.add(45);
        System.out.println(list);//[23, 13, 223, 1, 57, 18, 45, 45]
        Collections.shuffle(list);//打乱集合顺序
        System.out.println(list);//[45, 223, 23, 45, 18, 57, 1, 13]
    }
}

4.Collections的sort方法。

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

在这里插入代码片

总结：

- public static void shuffle(List<?> list):打乱集合顺序。
- public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
    默认规则: 事先写好的排序规则
    在哪里写好排序规则?---->集合元素所属的类中写好排序规则(通过实现Comparable接口,重写compareTo(T o)方法写好排序规则)
     排序规则: 
		前减后  升序 
    	后减前  降序
    	前: this   后:参数  
    	代码如下：
    	

```java
package Collecions的常用方法;

import java.util.Comparator;

/**
 * @author weijisheng
 * @create 2021-07-31 14:36
 */
public class Student implements Comparable {
    int age;

    public Student(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
```java
package Collecions的常用方法;

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

/**
 * @author weijisheng
 * @create 2021-07-31 14:36
 */
public class SortTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student student1 = new Student(12);
        Student student2 = new Student(12);
        Student student3 = new Student(21);
        Student student4 = new Student(15);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        System.out.println(list);//[Student{age=12}, Student{age=12}, Student{age=21}, Student{age=15}]
        Collections.sort(list);//要想用这个方法必须实现Comparable接口，而且实现compareto方法。或则通过匿名内部类实现
        System.out.println(list);//[Student{age=21}, Student{age=15}, Student{age=12}, Student{age=12}]
    }
}

@Override
public int compareTo(Object o) {
    //制定规则排序
    //前减后，升序。后减前，降序。
    //前this,后参数o
    Student o1=null;
    if(o instanceof Student){
         o1= (Student) o;
    }
    return o1.age-this.age;
}

}

- public static <T> void sort(List<T> list，Comparator<? super T>  com):将集合中元素按照指定规则排序。
   指定规则排序:  通过Comparator参数来指定
   通过传入Comparator接口的匿名内部类,重写compare(T o1,T o2)方法,在该方法中指定排序规则      
      排序规则: 
		前减后  升序 
    	后减前  降序
    	前: 第一个参数   后:第二个参数    
    	注意：Integer类型的可以直接相减，但是字符串虽然实现接口，但是必须要firstString.compareTo(secondString);

package Collecions的常用方法;

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

/**
 * @author weijisheng
 * @create 2021-07-31 14:36
 */
public class SortTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        Student student1 = new Student(12);
        Student student2 = new Student(12);
        Student student3 = new Student(21);
        Student student4 = new Student(15);
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        System.out.println(list);//[Student{age=12}, Student{age=12}, Student{age=21}, Student{age=15}]
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age - o2.age;
            }
        });//要想用这个方法必须实现Comparable接口，而且实现compareto方法。
        System.out.println(list);//[Student{age=12}, Student{age=12}, Student{age=15}, Student{age=21}]
    }
}

第二种内部类实现方式比第一种方式更好，因为第一种的话创建不同的对象的话，无法实现在不同的对象上实现降序升序结果。