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 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 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 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 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 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 list = new ArrayList<>();//多态写法
list.add("a");
list.add("b");
list.add("c");
list.add("a");
System.out.println("使用迭代器遍历:");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
打印结果：
使用迭代器遍历:
a
b
c
a c）使用增强for循环遍历
List 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 linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]
打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈] （2）使用addFirst()方法往集合的开头添加一个元素
LinkedList 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 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 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 linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]
//获取列表的第一个元素
System.out.println("第一个元素为：" + linked.getFirst());
打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
第一个元素为：迪丽热巴 （6）使用getLast()方法获取集合中最后一个元素
LinkedList linked = new LinkedList<>();//创建LinkedList集合对象，不能使用多态
//使用add方法往集合中添加元素
linked.add("迪丽热巴");
linked.add("古力娜扎");
linked.add("马尔扎哈");
System.out.println(linked);//[迪丽热巴, 古力娜扎, 马尔扎哈]
//获取列表的最后一个元素
System.out.println("最后一个元素为：" + linked.getLast());
打印结果：
[迪丽热巴, 古力娜扎, 马尔扎哈]
最后一个元素为：马尔扎哈 （7）使用removeFirst()方法移除集合中第一个元素
LinkedList 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 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 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 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 set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(5);
set.add(7);
set.add(2);
set.add(7);//不能存储重复的元素 （2）使用迭代器遍历Set集合（不能使用普通的for循环遍历）
Set set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(5);
set.add(7);
set.add(2);
set.add(7);//不能存储重复的元素
System.out.println("使用迭代器遍历集合：");
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());//2,5,7
}
打印结果：
使用迭代器遍历集合：
2
5
7 （3） 使用增强for循环遍历Set集合
Set 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 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 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
5506、Collections（集合工具类）【静态方法，可以直接使用 类名.方法名 调用】
（1）使用addAll()方法往集合中添加多个元素
ArrayList list = new ArrayList<>();
//往集合中添加多个元素
Collections.addAll(list, "www", "henu", "edu", "cn");
System.out.println(list);
打印结果：
[www, henu, edu, cn] （2）使用shuffle()方法打乱集合中元素的顺序
ArrayList 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 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 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{
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 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 list = new ArrayList<>();
Collections.addAll(list, 2, 5, 3, 7, 1);
System.out.println(list);
Collections.sort(list, new Comparator() {
//重写比较的规则
@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 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() {
//重写比较的规则
@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}]