Java集合Collection 体系集合详解（ArrayList，LinkedList，HashSet，TreeSet...）
Posted 橙 子_
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java集合Collection 体系集合详解（ArrayList，LinkedList，HashSet，TreeSet...）相关的知识，希望对你有一定的参考价值。
文章目录
- 1. 概念
- 2. 集合和数组的区别
- 3. 集合的体系结构
- 4. Collection父接口
- 5. List 子接口
- 6. List 实现类
- 7. Set 子接口
- 8. Set 实现类
- 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
) 详解 Collection集合