【Java集合】Collection 体系集合详解（ArrayList，LinkedList，HashSet，TreeSet...）
文章目录
- 1. 概念
- 2. 集合和数组的区别
- 3. 集合的体系结构
- 4. Collection父接口
- 5. List 子接口
- 6. List 实现类
- 6.1 ArrayList 类
- 6.2 Vector 类
- 6.3 LinkedList 类
- 6.4 ArrayList和LinkedList的区别
- 7. Set 子接口
- 8. Set 实现类
- 8.1 HashSet 类
- 8.2 TreeSet 类
- 9. Collections 工具类
- Java编程基础教程系列
1. 概念
集合是对象的容器，定义了多个对对象操作的方法，实现了和数组一样的功能，集合类全部位于java.util.* 包中，使用该类前需要进行导包操作导入相应的 Java 类。
先上脑图：
那么集合和前面学习的数组有什么区别呢？
2. 集合和数组的区别
集合和数组主要有两个方面的区别，首先是数组的长度是固定的，而集合长度不固定。其次是，数组可以存储基本数据类型和引用数据类型的变量，而集合只能存储引用数据类型的变量。
对于基本数据类型，我们一般进行装箱操作后即可存储在集合中，即把基本数据类型的变量封装成包装类的对象。这也体现了 Java 万物皆对象的特点。
3. 集合的体系结构
Java中封装了很多的集合类，接下类的一段时间，我们就要一起探讨 Java 集合类的学习。由于Java集合类的知识繁杂，所以我们要先了解 Java 集合的体系结构，然后进行深入的学习。
Java集合结构庞大，其主要分为两大类，单列集合 Collection 和双列集合 map。所谓的单列集合是一次只能添加一个数据，而双列集合就是一次可以添加一对数据。
接下来从这两大类开始学习，首先要学习的是单列集合 Collection 体系集合：
4. Collection父接口
Collection 接口位于整个集合体系的最顶层，是一个根接口。 JDK 不提供此接口的任何直接实现，它提供了更具体的子接口的实现，如 Set 和 List ，两个接口具有不同的功能。
Lsit 接口的特点是添加的元素有序，可重复，有索引。有序指的是存取顺序，可重复是指集合中允许重复元素的存在，有索引是指每个元素都有对应的索引。 Set 接口添加的元素的特点相反，无序，不可重复，无索引。
Interface Collection 表示一组任意类型的对象。 一些集合允许重复元素，而其他集合不允许。我们主要从添加元素删除元素遍历集合等方面学习 Collection 的使用。
常用的方法：
boolean add(Object obj) //添加一个对象。
boolean addAll(Collection c) //讲一个集合中的所有对象添加到此集合中。
void clear() //清空此集合中的所有对象。
boolean contains(Object o) //检查此集合中是否包含o对象。
boolean equals(Object o) //比较此集合是否与指定对象相等。
boolean isEmpty() //判断此集合是否为空。
boolean remove(Object o) //在此集合中移除o对象。
int size() //返回此集合中的元素个数。
Object[] toArray() //姜此集合转换成数组。
示例：创建集合，添加元素，删除元素，遍历集合元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
//创建集合
Collection collection=new ArrayList();
//添加元素
collection.add("张三");
collection.add("李四");
//打印元素个数
System.out.println("元素个数:"+collection.size());
//打印集合
System.out.println(collection);
//删除元素
collection.remove("张三");
System.out.println("此时元素个数:"+collection.size());
//遍历集合元素
//1.增强for
for(Object object :collection){
System.out.println(object);
}
//2.迭代器
Iterator iterator=collection.iterator();
while(iterator.hasNext()){
String s=(String)iterator.next();
System.out.println(s);
}
}
}
这里添加的是字符串类型的对象到集合中，我们还可以添加任何类型的对象到集合中。需要注意的是在使用迭代器遍历集合元素时，不可以使用该集合类的删除方法，会引发并发修改异常。此时，如果要删除元素，可以使用迭代器中的 remove() 方法。
在使用迭代器遍历集合元素时，首先使用 hasNext() 方法，判断集合中是否还有剩余元素，如果有，使用 next() 方法拿到该元素，同时还可以使用 remove() 方法删除该元素。
5. List 子接口
List 接口继承自 Collection 接口，其具有有序，可重复，有索引的特点。我们可以使用索引来对集合元素进行操作。除了 Collection 接口中的方法外，List 还另外的定义了很多方法来对集合元素进行操作。
示例：
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
//创建集合
List list = new ArrayList<>();
//添加元素
list.add("李四");
list.add("王五");
list.add("小张");
list.add("小明");
list.add("小王");
list.add(0, "张三");
//打印集合元素个数
System.out.println(list.size());
//打印集合元素
System.out.println(list);
//删除集合元素
list.remove(2);
System.out.println(list);
//遍历集合元素
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//使用列表迭代器遍历集合元素
ListIterator lit = list.listIterator();
while (lit.hasNext()) {
System.out.println(lit.nextIndex() + ":" + lit.next());
}
while (lit.hasPrevious()) {
System.out.println(lit.previousIndex() + ":" + lit.previous());
}
//判断
System.out.println(list.contains("张三"));
System.out.println(list.isEmpty());
//获取元素位置
System.out.println(list.indexOf("李四"));
//获取其子集，左闭右开
List list1 = list.subList(1, 3);
System.out.println(list1);
}
}
不同与 Collection 接口的是，我们可以利用索引删除集合元素，在遍历集合元素时，除了之前的方法，由于多了元素的索引，所以我们还可以使用 for 循环来遍历，同时还添加了列表迭代器来遍历集合元素。
6. List 实现类
6.1 ArrayList 类
ArrayList 实现类集合是使用数组实现的，其特点是查询快，增删慢。运行效率快，但是线程不安全。
ArrayList 实现了 List 接口，而 List 接口继承自 Collection 接口，所以它继承了两者的方法，。
示例：
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
//创建集合
ArrayList arrayList=new ArrayList();
//添加元素
Student s1=new Student("张三",18);
Student s2=new Student("李四",19);
Student s3=new Student("王五",20);
arrayList.add(s1);
arrayList.add(s2);
arrayList.add(s3);
//打印集合
System.out.println(arrayList.size());
System.out.println(arrayList.toString());
//删除元素
arrayList.remove(s1);
System.out.println(arrayList.size());
System.out.println(arrayList.toString());
//使用迭代器遍历
ListIterator lt=arrayList.listIterator();
while (lt.hasNext()){
Student s=(Student) lt.next();
System.out.println(s);
}
//判断
System.out.println(arrayList.isEmpty());
System.out.println(arrayList.contains(s1));
//查找
System.out.println(arrayList.indexOf(s2));
}
}
这里我们使用了学生类举例：
/*
* 学生类
*/
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.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 String toString() {
return "Student [name=" + name + ", age=" + age +"]";
}
}
6.2 Vector 类
Vector 实现类集合也是采用数组实现的，其不同于 ArrayList 的是运行效率较慢，但是线程安全。
Vector 实现了 List 接口，而 List 接口继承自 Collection 接口，所以它继承了两者的方法， 因为在开发中这个类已经不在常用了，所以只对类本身新增的几个方法讲解一下。
示例：
import java.util.Vector;
public class Test {
public static void main(String[] args) {
//创建集合
Vector vector=new Vector();
//添加元素
vector.add("张三");
vector.add("李四");
vector.add("王五");
//增加的方法
System.out.println(vector.firstElement());
System.out.println(vector.lastElement());
System.out.println(vector.elementAt(2));
}
}
6.3 LinkedList 类
LinkedList 实现类采用双向链表结构实现，增删快，查询慢。
同样的，LinkList 实现了 List 接口，而 List 接口继承自 Collection 接口，所以它继承了两者的方法， 其使用基本相似，这里不在赘述，需要强调的是，此类的集合也可以使用类似于前面的方法进行遍历。
在前面讲解的三种 List 的实现类集合中，由于集合中的元素是有索引存在的，所以在进行删除元素时，我们不仅可以利用索引删除元素，还可以利用引用删除元素。其底层是利用了 equals() 方法判断两个引用地址是否相同，这里可以重写 equals() 方法，用来判断对象的内容是否相同。
6.4 ArrayList和LinkedList的区别
我们已经探讨了两者的基本使用，前面说到，前者使用数组结构存储，而后者是双向链表的结构存储，所以，两者不同点在于，前者在内存中占用地址连续的内存空间，而后者的地址空间可能不连续。
7. Set 子接口
Set 接口位于 java.util 包中，Set 是一个无序集合，即存入和取出数据的顺序不一定相同。Set 集合中不可以添加重复元素。
Set 接口除了继承自 Collection 接口的所有方法如 add，equals 和 hashCode 方法外 ， 还增加了其他规定。 下面使用往集合中添加学生类举例：
/*
* 学生类
*/
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.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 String toString() {
return "Student [name=" + name + ", age=" + age +"]";
}
}
List 是一个接口，所以不能实例化对象，这里创建 List 的引用指向其实现类 HashSet 的对象。
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
/*
set接口的使用:继承自Collection的接口，使用方法类似。
特点是无序，不可重复，无索引
*/
//创建集合
Set<String> hashSet = new HashSet<String>();
//添加数据
hashSet.add("x");
hashSet.add("z");
hashSet.add("y");
System.out.println(hashSet.size());
System.out.println(hashSet);
//删除数据
hashSet.remove("x");
System.out.println(hashSet.size());
System.out.println(hashSet);
//遍历数据
for(String s:hashSet){
System.out.println(s);
}
Iterator<String> iterator = hashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println(hashSet.contains("y"));
System.out.println(hashSet.isEmpty());
}
}
Java 8 以后，new HashSet 中的 String 可以省略，并且集合中的数据具有无序性，如上述字符串打印时一般按字母顺序排列。
遍历集合中的数据时，由于 List 集合中的元素没有索引，索引无法使用 fori 的方法遍历，但是同样可以是使用增强 for 和迭代器的方法进行遍历。
8. Set 实现类
8.1 HashSet 类
HashSet 类位于 java.util 包中，其实现了 Set 接口。HashSet 类集合使用哈希表的方式存储数据，数据不可重复。
示例：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
/*
HashSet使用：实现了Set接口，常用方法类似，使用哈希表（链接+数组+红黑树）的方式存储数据
不可存储重复数据
*/
//创建集合
HashSet<Student> students = new HashSet<>();
//添加数据
Student s1 = new Student("zhang",18);
Student s2 = new Student("li",19);
Student s3 = new Student("wang", 20);
students.add(s1);
students.add(s2);
students.add(s3);
System.out.println(students.size());
System.out.println(students.toString());
//删除数据
students.remove(s3);
//遍历集合
for (Student s:students
) {
System.out.println(s);
}
Iterator<Student> iterator = students.iterator();
while(iterator.hasNext()){
System.out.println( iterator.next());
}
//判断
System.out.println(students.contains(s1));
System.out.println(students.isEmpty());
}
}
8.2 TreeSet 类
同样的，TreeSet 类也位于 java.util 包中，其实现了 Set 接口，使用方法十分类似。TreeSet 类集合使用了红黑数的方式存储数据，集合中数据不可重复。
该类实现了 SortSet 接口，对集合元素自动排序。并且元素对象的类型必须实现 Comparable 接口，指定排序规则，该接口中只有一个 CompareTo 方法，必须重写该方法来确定是否为重复元素，否则程序会出现异常。
示例：
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
/*
TreeSet使用：实现了Set接口，常用方法类似，使用红黑树的方式存储数据
不可存储重复数据
*/
//创建集合
TreeSet<Student> students = new TreeSet<Student>();
//添加数据
Student s1 = new Student("zhang",18);
Student s2 = new Student("li",19);
Student s4 =new Student("zhang",18);
students.add(s1);
students.add(s2);
students.add(s4);
//删除数据
students.remove(s1);
//遍历集合
for (Student s:students
) {
System.out.println(s);
}
//判断
System.out.println(students.contains(s2));
System.out.println(students.isEmpty());
}
}
集合中的元素对象的类必须实现Comparable 接口，重写该接口中的CompareTo 方法。示例：
public class Student implements Comparable<Student>{
@Override
public int compareTo(Student o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.age - o.getAge();
return n1 == 0 ? n2 : n1;
}
除了实现 Comparable 接口里的比较方法，TreeSet 也提供了一个带比较器 Comparator 的构造方法，使用匿名内部类来实现它。示例：
import java.util.Comparator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet<Student> persons=new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 先按年龄比较
// 再按姓名比较
int n1=o1.getAge()-o2.getAge();
int n2=o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Student s1=new Student("x",21);
Student s2=new Student("z", 22);
Student s3=new Student("y", 21);
persons.add(s1);
persons.add(s2);
persons.add(s3);
System.out.println(persons.toString());
}
}
9. Collections 工具类
Collections 集合工具类不同于前面的 Collection 类，是两个完全不同的概念。Collections 类位于 java.util 包中。Collections 类提供了一系列的静态方法，可以实现对集合元素的排序，添加一些元素，随机排序，替换等操作。
一些常用的方法的示例：
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
/*
Collections工具类
*/
List<Integer> integers = new ArrayList<Integer>();
integers.add(11);
integers.add(2);
integers.add(13);
integers.add(8);
//排序
Collections.sort(integers);
System.out.println(integers.toString());
//复制
List<Integer> dest=new ArrayList<Integer>();
for (int i = 0; i < 4; i++) {
dest.add(0);
}
Collections.copy(dest,integers);
System.out.println(dest.toString());
//二分查找
int i=Collections.binarySearch(integers,11);
System.out.println(i);
//反转
Collections.reverse(integers);
System.out.println(integers);
//打乱
Collections.shuffle(integers);
System.out.println(integers);
//把List转为数组
Integer[] array= integers.toArray(new Integer[0]);
System.out.println(array.length);
System.out.println(Arrays.toString(array));
//数组转为List;受限类型，此时不允许该集合中数据的增删操作。
Integer[] arr={1,2,4,3,6};
List<Integer> ints = Arrays.asList(arr);
System.out.println(ints.toString());
}
}
Collections 类不能 new 对象，不是因为没有构造方法，而是因为 Collections 的构造方法被私有化处理了。但是调用方法可以直接通过类名调用 Collections 类的方法，因为 Collections 类中的方法都是被 static修饰了，可以直接用类名调用。
Java编程基础教程系列
【Java基础】Java常用类详解
【Java基础】Java API文档使用详解
【Java基础】Java 包的使用详解