Java基础:可变参数与Collections工具类的常用方法

可变参数

可变参数：是JDK1.5之后出现的新特性
使用前提：

• 当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数

使用格式：

• 修饰符 返回值类型 方法名(数据类型…变量名){}

可变参数的原理：

• 可变参数底层就是一个数组，根据传递参数个数的不同，会创建不同长度的数组，来存储这些参数
• 传递的参数个数，可以是0个(不传递)，1，2，3，…多个

可变参数的注意事项：

• 1.一个方法的参数列表，只能有一个可变参数
• 2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾*/

* public class Demo01 {
    public static void main(String[] args) {
        add();
        int i1 = add(10);
        int i2 = add(10, 20);
        System.out.println(i1);
        System.out.println(i2);

        定义一个计算(0-n)整数和的方法
* 已知：计算整数的和，数据类型已经确定int
* 但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数
* add();就会创建一个长度为0的数组，new int[0]
* add(10);就会创建一个长度为1的数组，存储传递过来的参数new int[]{10};
* add(10,20);就会创建一个长度为2的数组，存储传递过来的参数 new int[]{10,20};
 */
    }
    //可变参数终极写法
    public static void method(Object...obj){}
//    public static void method(int...add,String...str){}//不能一个方法中有两个可变参数
    public static void method(int a,String...b){}//一个方法中，需要将可变参数放在最后一个定义
    public static int add(int...arr){
//        System.out.println(arr);//[I@2d98a335
//        System.out.println(arr.length);//0  长度是0的数组
        //定义一个初始化变量，记录累加求和
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }
}

Collections类

操作集合的工具类：Collections
java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：

• public static boolean addAll(Collection c,T…elements):往集合中添加一些元素
• public static void shuffle(List<?> list)打乱顺序：打乱集合顺序*/

package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class Demo01Collections {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,12,1,2,3,5);
        System.out.println(arrayList);
        Collections.shuffle(arrayList);
        System.out.println(arrayList);
    }
}

java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

• public static void sort(List list):将集合中元素按照默认规则排序

**注意：**sort(List list)使用前提:被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则

Comparable接口的排序规则：

• 自己(this)-参数：升序
  对于自定义类来说，需要重写*/

package collections;
import java.util.ArrayList;
import java.util.Collections;
public class Demo02Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(4);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        ArrayList<String> str = new ArrayList<>();
        str.add("a");
        str.add("c");
        str.add("b");
        System.out.println(str);
        Collections.sort(str);
        System.out.println(str);
        ArrayList<Person> list1 = new ArrayList<>();
        list1.add(new Person("小王",18));
        list1.add(new Person("小猪",22));
        list1.add(new Person("小鱼",16));
        System.out.println(list1);
        Collections.sort(list1);
        System.out.println(list1);
    }
}
package collections;

public class Person implements Comparable<Person>{
    private String name;
    private int age;
   public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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() {
    }
    @Override
    public int compareTo(Person o) {
        return this.getAge() - o.getAge();
    }
}

java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

• public static void sort(List list,Comparator<? super T>):将集合中元素按指定规则排序

Comparator和Comparable的区别

• Comparable:自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
• Comparator:相当于找一个第三方的裁判，比较两个

Comparator的排序规则：

•   o1-o2;升序
  

package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo03Sort {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);
        System.out.println(list);//【1，3，2】
        //重写比较规则
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(list);
        ArrayList<Student> stu = new ArrayList<>();
        stu.add(new Student("小何",22));
        stu.add(new Student("小李",20));
        stu.add(new Student("小郭",18));
        System.out.println(stu);
        Collections.sort(stu, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(stu);
    }
}
package collections;
public class Student {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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 Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}