目录
List接口
集合框架：
list接口：
ArrayList:
概念：
使用场景：
常用用法：
代码举例：
注意：
LinkedList:
概念：
使用场景：
语法：
常用方法（LinkedList提供了大量首尾操作的方法）：
代码举例：
set接口
HashSet:
概念：
HashSet存储自定义类型元素：
代码举例：
注意：
LikedHashSet:
概念：
结论：
举例代码：
List接口
集合框架：
list接口：
ArrayList:
概念：
用法类似于数组，且其容量可按需要动态调整，亦被称为动态数组。
数组最大的痛点是大小固定（可以改变，但是很麻烦） ArrayList底层是用数组实现的，所以名字里带了个数组（Array）。
ArrayList底层是通过数组实现，查询快、增删慢。API文档上说ArrayList不是同步的，即多线程环境下不安全，但是效率高。
使用场景：
1.频繁访问列表中的某一个元素。
2.只需要在列表末尾进行添加和删除元素操作。
常用用法：
1.public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
2.public E get(int index):返回集合中指定位置的元素。
3.public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
4.public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。(index:要更改的索引（集合下标），element：要更改成的内容)
代码举例：
//新建集合
ArrayList
在上述代码中，我们用的全是string类型的数据（我没改类型，我在尖括号里面写的是Object，也没事如果你想变成string类型的话，就把Object变成string就行），如果我们要存储基本数据类型的数据（所有集合都只能存引用数据类型），我们就得用基本类型的包装类。
ArrayList
注意：
List接口下的子类都可以使用上面的用法，但是在set接口下的子类没有get/set方法，但是有别的方法。
LinkedList:
概念：
LinkedList使用链表实现，查询慢，增删快，适用于经常插入、删除大量数据的场合，适合采用迭代器Iterator遍历。
LinkedList实现了List和Deque（双端队列）接口。
使用场景：
1.你需要通过循环迭代来访问列表中的某些元素。
2.需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
语法：
LinkedList list = new LinkedList(); // 普通创建方法(一般普通方法用的比较多)
或者
LinkedList list = new LinkedList(Collection c); // 使用集合创建链表
常用方法（LinkedList提供了大量首尾操作的方法）：
1.public void addFirst(E e):将指定元素插入此列表的开头。
2.public void addLast(E e):将指定元素添加到此列表的结尾。
3.public E getFirst():返回此列表的第一个元素。
4.public E getLast():返回此列表的最后一个元素。
5.public E removeFirst():移除并返回此列表的第一个元素。
6.public E removeLast():移除并返回此列表的最后一个元素。
**7.**public E pop():从此列表所表示的堆栈处弹出一个元素(使用这个会把这个集合的第一个元素删除，然后返回这个元素)。
**8.**public void push(E e):将元素推入此列表所表示的堆栈(就是在第一个元素前在插入一个元素)。
9.public boolean isEmpty()：如果列表不包含元素，则返回true。
代码举例：
LinkedList
set接口
HashSet:
概念：
它是set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。HashSet底层的实现其实是一个java.util.HashMap支持。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
HashSet存储自定义类型元素：
第一步：
自定义类型也就是我们自己创建的实体类
第二步：
使用HashSet集合
代码举例：
//实体类
public class Student {
//私有属性
private String name;
private int age;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
//重写equals方法
@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 &&
name.equals(student.name);
}
//重写hashCode
@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;
}
//重写tostring方法
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
//测试HashSet
//新建Hashset集合 让他装自定义类对象
HashSet set = new HashSet<>();
//新建自定义类对象
Student s= new Student("陈妍", 20);
//把对象添加到集合去
set.add(s);
set.add(new Student("曹兔子",23));
set.add(new Student("陈妍",20));
//遍历集合
for (Student student : set) {
System.out.println(student);
}//Student{name='曹兔子', age=23} Student{name='陈妍', age=20}
注意：
如果不重写equals方法和HashSet方法的话，添加相同的元素，hashset里面的元素会相同。
LikedHashSet:
概念：
set是无序、唯一的话，可以使用LikedHashSet--它是HashSet下面的一个子类，底层使用了LinkedHashMap，在HashSet的哈希表数据结构基础之上，增加了一个双向链表用来记录元素添加的顺序，能按照添加顺序遍历输出。需要频繁遍历的话效率可能高于HashSet。
结论：
LinkedHashSet 底层采用双向链表实现，可以保证元素的插入顺序，又因为是HashSet的子类，所以插入的元素不能重复。
举例代码：
public static void main(String[] args) {
//新建一个集合（输出数据是有序的集合）
LinkedHashSet set = new LinkedHashSet<>();
//在集合里添加元素
set.add("ccc");
set.add("bbb");
set.add("aav");
//使用迭代器遍历输出元素
Iterator ite = set.iterator();
while (ite.hasNext()){
System.out.println(ite.next());//ccc bbb aav
}
}
集合框架：
list接口：
概念：
用法类似于数组，且其容量可按需要动态调整，亦被称为动态数组。
数组最大的痛点是大小固定（可以改变，但是很麻烦） ArrayList底层是用数组实现的，所以名字里带了个数组（Array）。
ArrayList底层是通过数组实现，查询快、增删慢。API文档上说ArrayList不是同步的，即多线程环境下不安全，但是效率高。
使用场景：
1.频繁访问列表中的某一个元素。
2.只需要在列表末尾进行添加和删除元素操作。
常用用法：
1.public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
2.public E get(int index):返回集合中指定位置的元素。
3.public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
4.public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。(index:要更改的索引（集合下标），element：要更改成的内容)
代码举例：
//新建集合 ArrayList在上述代码中，我们用的全是string类型的数据（我没改类型，我在尖括号里面写的是Object，也没事如果你想变成string类型的话，就把Object变成string就行），如果我们要存储基本数据类型的数据（所有集合都只能存引用数据类型），我们就得用基本类型的包装类。
ArrayList
注意：
List接口下的子类都可以使用上面的用法，但是在set接口下的子类没有get/set方法，但是有别的方法。
LinkedList:
概念：
LinkedList使用链表实现，查询慢，增删快，适用于经常插入、删除大量数据的场合，适合采用迭代器Iterator遍历。
LinkedList实现了List和Deque（双端队列）接口。
使用场景：
1.你需要通过循环迭代来访问列表中的某些元素。
2.需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
语法：
LinkedList list = new LinkedList(); // 普通创建方法(一般普通方法用的比较多)
或者
LinkedList list = new LinkedList(Collection c); // 使用集合创建链表
常用方法（LinkedList提供了大量首尾操作的方法）：
1.public void addFirst(E e):将指定元素插入此列表的开头。
2.public void addLast(E e):将指定元素添加到此列表的结尾。
3.public E getFirst():返回此列表的第一个元素。
4.public E getLast():返回此列表的最后一个元素。
5.public E removeFirst():移除并返回此列表的第一个元素。
6.public E removeLast():移除并返回此列表的最后一个元素。
**7.**public E pop():从此列表所表示的堆栈处弹出一个元素(使用这个会把这个集合的第一个元素删除，然后返回这个元素)。
**8.**public void push(E e):将元素推入此列表所表示的堆栈(就是在第一个元素前在插入一个元素)。
9.public boolean isEmpty()：如果列表不包含元素，则返回true。
代码举例：
LinkedList
set接口
HashSet:
概念：
它是set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。HashSet底层的实现其实是一个java.util.HashMap支持。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
HashSet存储自定义类型元素：
第一步：
自定义类型也就是我们自己创建的实体类
第二步：
使用HashSet集合
代码举例：
//实体类
public class Student {
//私有属性
private String name;
private int age;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
//重写equals方法
@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 &&
name.equals(student.name);
}
//重写hashCode
@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;
}
//重写tostring方法
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
//测试HashSet
//新建Hashset集合 让他装自定义类对象
HashSet set = new HashSet<>();
//新建自定义类对象
Student s= new Student("陈妍", 20);
//把对象添加到集合去
set.add(s);
set.add(new Student("曹兔子",23));
set.add(new Student("陈妍",20));
//遍历集合
for (Student student : set) {
System.out.println(student);
}//Student{name='曹兔子', age=23} Student{name='陈妍', age=20}
注意：
如果不重写equals方法和HashSet方法的话，添加相同的元素，hashset里面的元素会相同。
LikedHashSet:
概念：
set是无序、唯一的话，可以使用LikedHashSet--它是HashSet下面的一个子类，底层使用了LinkedHashMap，在HashSet的哈希表数据结构基础之上，增加了一个双向链表用来记录元素添加的顺序，能按照添加顺序遍历输出。需要频繁遍历的话效率可能高于HashSet。
结论：
LinkedHashSet 底层采用双向链表实现，可以保证元素的插入顺序，又因为是HashSet的子类，所以插入的元素不能重复。
举例代码：
public static void main(String[] args) {
//新建一个集合（输出数据是有序的集合）
LinkedHashSet set = new LinkedHashSet<>();
//在集合里添加元素
set.add("ccc");
set.add("bbb");
set.add("aav");
//使用迭代器遍历输出元素
Iterator ite = set.iterator();
while (ite.hasNext()){
System.out.println(ite.next());//ccc bbb aav
}
}
LinkedList使用链表实现，查询慢，增删快，适用于经常插入、删除大量数据的场合，适合采用迭代器Iterator遍历。
LinkedList实现了List和Deque（双端队列）接口。
使用场景：1.你需要通过循环迭代来访问列表中的某些元素。
2.需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
语法：
LinkedList list = new LinkedList(); // 普通创建方法(一般普通方法用的比较多)
或者
LinkedList list = new LinkedList(Collection c); // 使用集合创建链表
常用方法（LinkedList提供了大量首尾操作的方法）：
1.public void addFirst(E e):将指定元素插入此列表的开头。
2.public void addLast(E e):将指定元素添加到此列表的结尾。
3.public E getFirst():返回此列表的第一个元素。
4.public E getLast():返回此列表的最后一个元素。
5.public E removeFirst():移除并返回此列表的第一个元素。
6.public E removeLast():移除并返回此列表的最后一个元素。
**7.**public E pop():从此列表所表示的堆栈处弹出一个元素(使用这个会把这个集合的第一个元素删除，然后返回这个元素)。
**8.**public void push(E e):将元素推入此列表所表示的堆栈(就是在第一个元素前在插入一个元素)。
9.public boolean isEmpty()：如果列表不包含元素，则返回true。
代码举例：LinkedList
HashSet:
概念：
它是set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。HashSet底层的实现其实是一个java.util.HashMap支持。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
HashSet存储自定义类型元素：
第一步：
自定义类型也就是我们自己创建的实体类
第二步：
使用HashSet集合
代码举例：
//实体类
public class Student {
//私有属性
private String name;
private int age;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
//重写equals方法
@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 &&
name.equals(student.name);
}
//重写hashCode
@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;
}
//重写tostring方法
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
//测试HashSet
//新建Hashset集合 让他装自定义类对象
HashSet set = new HashSet<>();
//新建自定义类对象
Student s= new Student("陈妍", 20);
//把对象添加到集合去
set.add(s);
set.add(new Student("曹兔子",23));
set.add(new Student("陈妍",20));
//遍历集合
for (Student student : set) {
System.out.println(student);
}//Student{name='曹兔子', age=23} Student{name='陈妍', age=20}
注意：
如果不重写equals方法和HashSet方法的话，添加相同的元素，hashset里面的元素会相同。
LikedHashSet:
概念：
set是无序、唯一的话，可以使用LikedHashSet--它是HashSet下面的一个子类，底层使用了LinkedHashMap，在HashSet的哈希表数据结构基础之上，增加了一个双向链表用来记录元素添加的顺序，能按照添加顺序遍历输出。需要频繁遍历的话效率可能高于HashSet。
结论：
LinkedHashSet 底层采用双向链表实现，可以保证元素的插入顺序，又因为是HashSet的子类，所以插入的元素不能重复。
举例代码：
public static void main(String[] args) {
//新建一个集合（输出数据是有序的集合）
LinkedHashSet set = new LinkedHashSet<>();
//在集合里添加元素
set.add("ccc");
set.add("bbb");
set.add("aav");
//使用迭代器遍历输出元素
Iterator ite = set.iterator();
while (ite.hasNext()){
System.out.println(ite.next());//ccc bbb aav
}
}
它是set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。HashSet底层的实现其实是一个java.util.HashMap支持。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。
HashSet存储自定义类型元素：
第一步：
自定义类型也就是我们自己创建的实体类
第二步：
使用HashSet集合
代码举例：//实体类
public class Student {
//私有属性
private String name;
private int age;
//构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
//重写equals方法
@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 &&
name.equals(student.name);
}
//重写hashCode
@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;
}
//重写tostring方法
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
//测试HashSet
//新建Hashset集合 让他装自定义类对象
HashSet set = new HashSet<>();
//新建自定义类对象
Student s= new Student("陈妍", 20);
//把对象添加到集合去
set.add(s);
set.add(new Student("曹兔子",23));
set.add(new Student("陈妍",20));
//遍历集合
for (Student student : set) {
System.out.println(student);
}//Student{name='曹兔子', age=23} Student{name='陈妍', age=20}
注意：
如果不重写equals方法和HashSet方法的话，添加相同的元素，hashset里面的元素会相同。
概念：set是无序、唯一的话，可以使用LikedHashSet--它是HashSet下面的一个子类，底层使用了LinkedHashMap，在HashSet的哈希表数据结构基础之上，增加了一个双向链表用来记录元素添加的顺序，能按照添加顺序遍历输出。需要频繁遍历的话效率可能高于HashSet。
结论：
LinkedHashSet 底层采用双向链表实现，可以保证元素的插入顺序，又因为是HashSet的子类，所以插入的元素不能重复。
