List集合（ArrayList集合、LinkedList集合）、Set接口（HashSet、LinkedHashSet）、可变参数

LIst集合

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

List接口特点：

1. 它是一个元素存取有序的集合。

2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口中常用方法

• public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
• public E get(int index) :返回集合中指定位置的元素。
• public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

ArrayList集合

java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快

LinkedList集合

java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表

LinkedList中常用方法

• public void addFirst(E e) :将指定元素插入此列表的开头。
• public void addLast(E e) :将指定元素添加到此列表的结尾。
• public E getFirst() :返回此列表的第一个元素。
• public E getLast() :返回此列表的最后一个元素。
• public E removeFirst() :移除并返回此列表的第一个元素。
• public E removeLast() :移除并返回此列表的最后一个元素。
• public E pop() :从此列表所表示的堆栈处弹出一个元素。
• public void push(E e) :将元素推入此列表所表示的堆栈。
• public boolean isEmpty() ：如果列表不包含元素，则返回true。

在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

Set接口

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口,与 List 接口不

同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

HashSet集合

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。 java.util.HashSet 底层的实现其实是一个 java.util.HashMap 支持。

HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性 的方式依赖于： hashCode 与 equals 方法。

HashSet集合存储数据的结构（哈希表）

在JDK1.8之前，哈希表底层采用数组+链表实现，而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树。

HashSet存储自定义类型元素

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

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

    public Student() {
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        HashSet<Student> s = new HashSet<>();
        Student stu = new Student(15,"lihua");
        Student stu1 = new Student(13,"lihua");
        Student stu2 = new Student(14,"zhaohua");
        Student stu3 = new Student(15,"zhanghua");

        s.add(stu);
        s.add(stu1);
        s.add(stu2);
        s.add(stu3);

//        System.out.println(s);
        for (Student s1:s) {
            System.out.println(s1);
        }
    }
}

LinkedHashSet集合

链表和哈希表组合的一个数据存储结构。 保证元素唯一，且有序。

public class LinkedHashSetDemo {
    public static void main(String[] args) {
//        LinkedHashSet<String> link = new LinkedHashSet<>();//有序
        HashSet<String> link = new HashSet<>();//无序
        link.add("bbb");
        link.add("aaa");
        link.add("ccc");
        link.add("bbc");
        for (String s:link) {
            System.out.println(s);
        }
    }
}

可变参数（定义一个方法需要接受多个参数，并且多个参数类型一致）

修饰符 返回值类型 方法名(参数类型... 形参名){ }

修饰符 返回值类型 方法名(参数类型[] 形参名){ }

后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 44, 462, 41, 25}; 
        int sum = getSum(arr); 
        System.out.println(sum); 
        // 6 7 2 12 2121 
        // 求 这几个元素和 6 7 2 12 2121 
        int sum2 = getSum(6, 5, 12, 24, 1952); 
        System.out.println(sum2);
    }

//    private static int getSum(int[] arr) {
//        int sum = 0;
//        for(int a : arr) {
//            sum += a;
//        }
//        return sum;
//    }
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }
}

如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。