ArrayList集合、LinkedList集合、HashSet集合、LinkedHashSet集合、可变参数、Collections（集合工具类）

目录

1、ArrayList集合（查询快，增删慢）

（1-a）使用add()方法往集合中添加元素

（1-b）使用add()方法在指定的索引处添加新的元素

（2）使用remove()方法移除列表中指定位置的元素，并返回被移除的元素

（3）使用set()方法用指定元素替换集合中指定位置的元素，并返回被替换的元素

（4）List集合的遍历

a）使用普通的for循环遍历

b）使用迭代器遍历

c）使用增强for循环遍历

 2、LinkedList集合（查询慢，增删快）

（1）使用add()方法往集合中添加元素

（2）使用addFirst()方法往集合的开头添加一个元素

（3）使用push()方法往集合的开头添加一个元素

（4）使用addLast()方法往集合的结尾添加一个元素 

（5）使用getFirst()方法获取集合中第一个元素

（6）使用getLast()方法获取集合中最后一个元素

（7）使用removeFirst()方法移除集合中第一个元素

（8）使用pop()方法移除集合中第一个元素

（9）使用removeLast()方法移除集合中最后一个元素 

（10）使用clear()方法移除列表中所有元素，并使用isEmpty()方法判断集合是否为空

3、HashSet集合

（1）使用add()方法往集合中添加元素

（2）使用迭代器遍历Set集合（不能使用普通的for循环遍历）

（3） 使用增强for循环遍历Set集合 

（4）HashSet存储自定义类型元素

a）定义一个Person类，用于创建对象存储Person类型的数据（重写toString方法、hashCode方法和equals方法）

b）定义一个DemoHashSetSavePerson类，用于测试存储Person类型的数据

4、LinkedHashSet集合

5、可变参数

6、Collections（集合工具类）【静态方法，可以直接使用  类名.方法名  调用】

（1）使用addAll()方法往集合中添加多个元素

（2）使用shuffle()方法打乱集合中元素的顺序

（3）使用sort()方法将集合中的Integer类型的元素按照默认的规则（默认升序）排序

（4）使用sort()方法将集合中的String类型的元素按照默认的规则（默认升序）排序

（5）使用sort()方法将集合中的自定义类型（Person）的元素按照默认的规则（默认升序）排序

a）首先定义一个Person类，用于创建自定义类型的元素，并且实现Comparable接口，重写接口中的compareTo方法

b）创建ArrayList集合，用于存储Person类型的元素

（6）使用sort()方法将集合中的Integer类型的元素按照自定义的规则排序

（7）使用sort()方法将集合中的自定义类型（Student）的元素按照自定义的规则排序

a）首先定义一个Student类，用于创建自定义类型的元素

b）创建ArrayList集合，用于存储Student类型的元素 

---

1、ArrayList集合（查询快，增删慢）

List集合有三大特点：①有序：存储的元素顺序和取出的顺序一样 ②包含一些带有索引的方法（List集合特有） ③List集合允许存储重复的元素（由于ArrayList集合实现了List接口，因此ArrayList集合也包含这些特点）

（1-a）使用add()方法往集合中添加元素

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println(list);

打印结果：
[a, b, c, a]

（1-b）使用add()方法在指定的索引处添加新的元素

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println(list);
//在b和c之间添加"xxx"
list.add(2, "xxx");
System.out.println(list);

打印结果：
[a, b, c, a]
[a, b, xxx, c, a]

（2）使用remove()方法移除列表中指定位置的元素，并返回被移除的元素

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println(list);
//移除指定索引处的元素
String remove = list.remove(2);
System.out.println("被移除的元素：" + remove);
System.out.println(list);

打印结果：
[a, b, c, a]
被移除的元素：c
[a, b, a]

（3）使用set()方法用指定元素替换集合中指定位置的元素，并返回被替换的元素

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println(list);
//替换某个元素，并返回被替换的元素
String a = list.set(2, "A");
System.out.println("被替换的元素为：" + a);
System.out.println(list);

打印结果：
[a, b, c, a]
被替换的元素为：c
[a, b, A, a]

（4）List集合的遍历

a）使用普通的for循环遍历

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println("使用普通的for循环遍历:");
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));//使用get()方法获得指定索引处的元素
}

打印结果：
使用普通的for循环遍历:
a
b
c
a

b）使用迭代器遍历

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println("使用迭代器遍历:");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

打印结果：
使用迭代器遍历:
a
b
c
a

c）使用增强for循环遍历

List<String> list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println("使用增强for循环:");
for (String s : list) {
    System.out.println(s);
}

打印结果：
使用增强for循环:
a
b
c
a

 2、LinkedList集合（查询慢，增删快）

特点：里边包含了大量的操作首尾元素的方法。使用LinkedList集合特有的方法，不能使用多态

（1）使用add()方法往集合中添加元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]

（2）使用addFirst()方法往集合的开头添加一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//往集合的开头添加元素(与push方法效果一样)
linked.addFirst("www");
System.out.println(linked);

打印结果：
[www, 迪丽热巴, 古力娜扎, 马尔扎哈]

（3）使用push()方法往集合的开头添加一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//往集合的开头添加元素(与push方法效果一样)
linked.addFirst("www");
System.out.println(linked);
//往集合的开头添加元素(与addFirst方法效果一样)
linked.push("http");
System.out.println(linked);

打印结果：
[http, www, 迪丽热巴, 古力娜扎, 马尔扎哈]

（4）使用addLast()方法往集合的结尾添加一个元素 

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//往集合的末尾添加元素(与add方法效果一样)
linked.addLast("com");
System.out.println(linked);
//往集合的末尾添加元素(与addLast方法效果一样)
linked.add("cn");
System.out.println(linked);

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈, com, cn]

（5）使用getFirst()方法获取集合中第一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//获取列表的第一个元素
System.out.println("第一个元素为：" + linked.getFirst());

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
第一个元素为：迪丽热巴

（6）使用getLast()方法获取集合中最后一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//获取列表的最后一个元素
System.out.println("最后一个元素为：" + linked.getLast());

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
最后一个元素为：马尔扎哈

（7）使用removeFirst()方法移除集合中第一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//移除第一个元素(与pop方法效果一样)
String s = linked.removeFirst();
System.out.println("被移除的第一个元素为：" + s);
System.out.println(linked);

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
被移除的第一个元素为：迪丽热巴
[古力娜扎, 马尔扎哈]

（8）使用pop()方法移除集合中第一个元素

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//移除第一个元素(与removeFirst方法效果一样)
String pop = linked.pop();
System.out.println("被移除的第一个元素为：" + pop);
System.out.println(linked);

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
被移除的第一个元素为：迪丽热巴
[古力娜扎, 马尔扎哈]

（9）使用removeLast()方法移除集合中最后一个元素 

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

//移除最后一个元素
String s = linked.removeLast();
System.out.println("被移除的最后一个元素为：" + s);
System.out.println(linked);

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
被移除的第一个元素为：马尔扎哈
[迪丽热巴, 古力娜扎]

（10）使用clear()方法移除列表中所有元素，并使用isEmpty()方法判断集合是否为空

LinkedList<String> linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]

if (linked.isEmpty()) {
    System.out.println("列表为空");
} else {
    System.out.println("列表不为空");
}

linked.clear();//移除列表中所有元素

if (linked.isEmpty()) {
    System.out.println("列表为空");
} else {
    System.out.println("列表不为空");
}

打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
列表不为空
列表为空

3、HashSet集合

Set集合有三大特点：①无序：存储的元素顺序和取出的顺序有可能不一样 ②不允许存储重复的元素 ③没有索引，没有带索引的方法，也不能使用普通的for循环遍历（由于HashSet集合实现了Set接口，因此HashSet集合也包含这些特点）

（1）使用add()方法往集合中添加元素

Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(5);
set.add(7);
set.add(2);
set.add(7);//不能存储重复的元素

（2）使用迭代器遍历Set集合（不能使用普通的for循环遍历）

Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(5);
set.add(7);
set.add(2);
set.add(7);//不能存储重复的元素
System.out.println("使用迭代器遍历集合：");
Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next());//2,5,7
}

打印结果：
使用迭代器遍历集合：
2
5
7

（3） 使用增强for循环遍历Set集合 

Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(5);
set.add(7);
set.add(2);
set.add(7);//不能存储重复的元素
System.out.println("使用增强for循环遍历集合：");
for (Integer integer : set) {
    System.out.println(integer);
}

打印结果：
使用增强for循环遍历集合：
2
5
7

（4）HashSet存储自定义类型元素

要想保证Set集合存储的元素唯一，必须重写hashCode方法和equals方法。要求：同名同年龄的人，视为同一个人，只能存储一次

a）定义一个Person类，用于创建对象存储Person类型的数据（重写toString方法、hashCode方法和equals方法）

package com.itheima.demo02Set;

import java.util.Objects;

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

    public Person() {
    }

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

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}

b）定义一个DemoHashSetSavePerson类，用于测试存储Person类型的数据

package com.itheima.demo02Set;

import java.util.HashSet;

public class Demo03HashSetSavePerson {
    public static void main(String[] args) {
        //创建HashSet集合存储Person
        HashSet<Person> people = new HashSet<>();
        Person person1 = new Person("迪丽热巴", 21);
        Person person2 = new Person("迪丽热巴", 21);
        Person person3 = new Person("古力娜扎", 19);
        people.add(person1);
        people.add(person2);
        people.add(person3);
        System.out.println(people);
    }
}

打印结果：
[Person{name='迪丽热巴', age=21}, Person{name='古力娜扎', age=19}]

4、LinkedHashSet集合

LinkedHashSet集合特点：底层是一个哈希表（数组+链表/红黑树）+ 链表：多了一条链表（记录元素的存储顺序），保证元素有序

HashSet<String> hashSet = new HashSet<>();
hashSet.add("www");
hashSet.add("henu");
hashSet.add("edu");
hashSet.add("edu");
hashSet.add("cn");
System.out.println(hashSet);//[henu, www, edu, cn] 无序，不允许重复
System.out.println("============");

LinkedHashSet linked = new LinkedHashSet();
linked.add("www");
linked.add("henu");
linked.add("edu");
linked.add("edu");
System.out.println(linked);//[www, henu, edu, cn] 有序，不允许重复

打印结果：
[henu, www, edu, cn]
============
[www, henu, edu, cn]

5、可变参数

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

定义格式：定义方法时使用 修饰符 返回值类型 方法名(数据类型...变量名){}

可变参数的原理：底层是一个数组，根据传递参数的个数不同，会创建不同长度的数组，来存储这些参数。传递的参数个数，可以是0个（不传递），1，2...多个

package com.itheima.demo04VarArgs;

public class Demo01VarArgs {
    public static void main(String[] args) {
        System.out.println(add(10));
        System.out.println(add(10, 20));
        System.out.println(add(10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
    }

    public static int add(int... arr) {
        System.out.println("存储参数的数组位置：" + arr);
        System.out.println("参数个数：" + arr.length);
        //定义一个初始化的变量，记录累加求和
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }
    //一个方法的参数列表，只能有一个可变参数
    /*public static void method(int...a,String...b){//错误写法！

    }*/

    //如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
    /*public static void method(int a, double b, String c, int... i) {

    }*/

    //可变参数的特殊（终极）写法
    public static void method(Object...obj){

    }
}

打印结果：
存储参数的数组位置：[I@506e1b77
参数个数：1
10
存储参数的数组位置：[I@7cd84586
参数个数：2
30
存储参数的数组位置：[I@30dae81
参数个数：10
550

6、Collections（集合工具类）【静态方法，可以直接使用  类名.方法名  调用】

（1）使用addAll()方法往集合中添加多个元素

ArrayList<String> list = new ArrayList<>();
//往集合中添加多个元素
Collections.addAll(list, "www", "henu", "edu", "cn");
System.out.println(list);

打印结果：
[www, henu, edu, cn]

（2）使用shuffle()方法打乱集合中元素的顺序

ArrayList<String> list = new ArrayList<>();
//往集合中添加多个元素
Collections.addAll(list, "www", "henu", "edu", "cn");
System.out.println(list);

//打乱集合中元素的顺序
Collections.shuffle(list);
System.out.println(list);

打印结果：
[www, henu, edu, cn]
[edu, cn, henu, www]

（3）使用sort()方法将集合中的Integer类型的元素按照默认的规则（默认升序）排序

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,2,5,3,7,1);
System.out.println(list);

//将集合中的元素按默认顺序（升序）排列
Collections.sort(list);
System.out.println(list);

打印结果：
[2, 5, 3, 7, 1]
[1, 2, 3, 5, 7]

（4）使用sort()方法将集合中的String类型的元素按照默认的规则（默认升序）排序

ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"www","henu","edu","cn");
System.out.println(list1);

//将集合中的元素按默认顺序（升序）排列
Collections.sort(list1);
System.out.println(list1);

打印结果：
[www, henu, edu, cn]
[cn, edu, henu, www]

（5）使用sort()方法将集合中的自定义类型（Person）的元素按照默认的规则（默认升序）排序

注意：使用sort()方法将集合中的自定义类型（Person）的元素时，被排序的集合里边存储元素，必须实现Comparable，重写接口中的compareTo方法，定义排序的规则（Integer和String等类型已经实现Comparable接口并重写了接口中的compareTo方法）

a）首先定义一个Person类，用于创建自定义类型的元素，并且实现Comparable接口，重写接口中的compareTo方法

package com.itheima.demo05Collections;

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

    public Person() {
    }

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

    //重写排序的规则
    @Override
    public int compareTo(Person o) {
        //return 0;//默认返回0，是因为它认为元素都是相同的

        //自定义比较的规则，比较两个人的年龄
        return this.getAge()-o.getAge();//年龄升序排序
        //return o.getAge()-this.getAge();//年龄降序排序
    }
}

b）创建ArrayList集合，用于存储Person类型的元素

ArrayList<Person> list2 = new ArrayList<>();
Collections.addAll(list2,
        new Person("张三",19),
        new Person("李四",20),
        new Person("王五",16));
System.out.println(list2);

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

//将集合中的元素按默认顺序（升序）排列
Collections.sort(list2);
System.out.println(list2);

打印结果：
[Person{name='张三', age=19}, Person{name='李四', age=20}, Person{name='王五', age=16}]
[Person{name='王五', age=16}, Person{name='张三', age=19}, Person{name='李四', age=20}]

（6）使用sort()方法将集合中的Integer类型的元素按照自定义的规则排序

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 2, 5, 3, 7, 1);
System.out.println(list);

Collections.sort(list, new Comparator<Integer>() {
    //重写比较的规则
    @Override
    public int compare(Integer o1, Integer o2) {
        //return o1 - o2;//升序
        return o2 - o1;//降序
    }
});
System.out.println(list);

打印结果：
[2, 5, 3, 7, 1]
[7, 5, 3, 2, 1]

（7）使用sort()方法将集合中的自定义类型（Student）的元素按照自定义的规则排序

a）首先定义一个Student类，用于创建自定义类型的元素

package com.itheima.demo05Collections;

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

b）创建ArrayList集合，用于存储Student类型的元素 

ArrayList<Student> list1 = new ArrayList<>();
Collections.addAll(list1,
        new Student("b张三", 19),
        new Student("a赵六", 19),
        new Student("李四", 20),
        new Student("王五", 16));
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);

打印结果：
[Student{name='b张三', age=19}, Student{name='a赵六', age=19}, Student{name='李四', age=20}, Student{name='王五', age=16}]
[Student{name='王五', age=16}, Student{name='a赵六', age=19}, Student{name='b张三', age=19}, Student{name='李四', age=20}]