（java总结）可变参数、Collections工具类

package Demo32;
/*
可变参数：
    使用前提：
        当方法的参数列表数据类型已经确定，但是参数个数不确定，就可以使用可变参数
    使用格式：定义方法时使用
        修饰符 返回值类型 方法名(数据类型...变量名){}
    可变参数原理：
        可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，

 */
public class DemoVarArgs {
    public static void main(String[] args) {
        int i = add("111",10,20,30,40,50,60,70,80,90);
        System.out.println(i);
    }
    //定义计算(0~n)整数和的方法，但是不确定是几个
    //add();就会创建一个长度为0的数组
    // add(10,20); 就会创建一个长度为2的数组
    /*
    注意事项：
    1、一个方法的参数列表，只能有一个可变参数
    2、如果方法的参数有多个，那么可变参数必须写在参数列表的的末尾
     */
    private static int add(String b,int...arr) {
        //定义初始化的变量，记录累加求和
        int sum = 0;
        for(int i: arr)
        sum +=i;
        return sum;


//        System.out.println(arr);
//        System.out.println(arr.length);
//        return 0;
    }

}

package Demo32;

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

/*
java.util.ArrayList集合工具类，用来对集合进行操作，部分方法如下：
    public static <T> boolean addAll(Collection<T> c, T...elements):往集合中添加一些元素。
    public static void shuffle(List<?> List)打乱顺序：打乱集合顺序
 */
public class DemoCollections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //往集合中添加元素
//        list.add("a");
//        list.add("b");
//        list.add("c");
//        list.add("d");
 //       System.out.println(list);
        System.out.println("=============");
        Collections.addAll(list,"a","b","c");
        System.out.println(list);
        //打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);

    }
}

package Demo32;

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

/*
java.util.Collection是集合工具类，用来对集合进行操作，
    public static <T> void sort(List<T> list):将集合元素按照默认规则排序

    自定义类排序
    注意：使用前提
        被排序的集合必须实现comparable,重写接口中的方法定义排序的规则
    Comparable接口的排序规则:
        自己(this) - 参数 ：升序
        反之降序
 */
public class DemoSortComparable {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(5);
        list.add(3);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);//默认是升序

        ArrayList<Person1> list1 = new ArrayList<>();
        Person1 p1 = new Person1("张三",20);
        Person1 p2 = new Person1("李四",40);
        Person1 p3 = new Person1("王五",30);
       list1.add(p1);
       list1.add(p2);
       list1.add(p3);

        Collections.sort(list1);
        System.out.println(list1);
    }
}

package Demo32;

public class Person1 implements Comparable<Person1> {
    private String name;
    private int age;

    public Person1() {
    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

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

    //重写排序的规则
    @Override
    public int compareTo(Person1 o) {
        //return 0;认为返回都是相同的
        //自定义比较规则，比较两个人的年龄
        return this.getAge()-o.getAge();//年龄升序排序
    }
}

package Demo32;

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

/*
Comparable和Comparable的区别：
    Comparable: 自己(this)和别人(参数)比较，自己要实现Comparable接口，重写compareTo方法
    Comparator：相当于找第三个的裁判，比较两个
 */
public class DemoSortComparator {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Collections.sort(list, new Comparator<Integer>() {
            //这里是重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
             //   return o1-o2;//升序
                return o2-o1;//降序
            }
        });
        System.out.println(list);
        System.out.println("==============");

        ArrayList<Student> list1 = new ArrayList<>();
        list1.add(new Student("迪丽热巴",23));
        list1.add(new Student("古力娜扎",34));
        list1.add(new Student("玛尔扎哈",23));
        list1.add(new Student("玛尔扎哈",23));

//        Collections.sort(list1, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });
//        System.out.println(list1);

        Collections.sort(list1, 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(list1);
    }
}

package Demo32;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}