可变参数和Collections集合工具类

可变参数

/**
 * 可变参数：jdk1.5后出现的新特性
 * 使用前期：
 * 当方法的参数列表数据类型已经确定的时候但是参数的个数不确定的时候就可以使用可变参数
 * 使用格式：定义方法的时候使用
 * 修饰符 返回值类型 方法名（数据类型... 变量名）{};
 * 可变参数的原理：
 * 可变参数的底层就是一个数组，根据传递参数个数不同他会创建不同长度的数组来存储这些参数
 * 传递的参数个数可以是0个（不传递参数），1，2，...多个
 *
 * 可变参数使用的注意事项：
 * 1.一个方法的参数列表只能有一个可变参数
 * 2.如果方法的参数有多个，可变参数必须写在参数列表的末尾
 * public static int add(int... arr,int i){}//错误
 * public static int add(int i,int... arr){}//正确
 */
public class Test{
    public static void main(String[] args) {
//        int i = add();
//        int i = add(1);
        int i = add(1,2,4,5,6,7,8,9,6,3,4,1,1,0,1,0,10,10);
        System.out.println(i);
    }

    /**
     * 定义一个方法，计算(0 - n)个整数的方法
     * 已知：计算整数的和，数据类型已经确定int
     * 但是参数的个数不确定，不知道要计算几个整数的和
     * 这个时候我们就可以使用可变参数
     * add();就会创建一个长度为0的数组,new int[0];
     * add(1);就会创建一个长度为1的数组,存储传递过来的参数,new int[]{1};
     * add(1,2);就会创建一个长度为2的数组,存储传递过来的参数,new int[]{1,2};
     */
    public static int add(int... arr){
        //System.out.println(arr);//[I@7440e464 底层是一个数组
        //System.out.println(arr.length);//0
        //定义一个初始化的变量，来记录累加求和
        int sum = 0;
        //遍历这个数组来获取数组中的每一个元素
        for (int i : arr) {
            //累加求和
            sum += i;
        }
        //把求和结果返回
        return sum;
    }
}

Collections集合工具类

常用功能

javajava.utils.Collections是集合工具类，用来堆对集合进行操作。部分方法如下：
javapublic static <T> boolean addAll(Collection<T> c.T... elements); 往集合中添加一些元素
javapublic static void shuffle(List<?> list) 打乱集合排序
javapublic static <T> void sort(List<T> list) 将集合元素按照默认规则进行排序
javapublic static <T> void sort(List<T> list,Comparator<? super T>) 将集合中元素按照制定规则进行排序

代码实现：

public class Test{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //addAll
        Collections.addAll(list, "a", "b", "c", "d", "e", "f");
        System.out.println(list);//[a, b, c, d, e, f]

        //shuffle
        Collections.shuffle(list);
        System.out.println(list);//[f, c, a, e, d, b]

        //sort
        Collections.sort(list);
        System.out.println(list);
    }
}

public class Test{
    public static void main(String[] args) {
        /**
         * 注意：
         * 被排序的集合它里面存储的元素必须实现comparable，重写接口中的compareTo
         */
        ArrayList<Person> list = new ArrayList<>();

        list.add(new Person("张三",18));
        list.add(new Person("李四",20));
        list.add(new Person("王五",15));

        System.out.println(list);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}]
        Collections.sort(list);
        System.out.println(list);//[Person{name='王五', age=15}, Person{name='张三', age=18}, Person{name='李四', age=20}]


    }
}

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

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

    public Person(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;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {

    }
    //重写排序的规则
    @Override
    public int compareTo(Person o) {
        //return 0;//认为元素都是相同的
        //自定义排序规则，比较两个人的年龄（this，和参数Person）
        return this.getAge() - o.getAge();
    }
}