> 文档中心 > 【Java集合】Collection 体系集合详解(ArrayList,LinkedList,HashSet,TreeSet...)

【Java集合】Collection 体系集合详解(ArrayList,LinkedList,HashSet,TreeSet...)

【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 体系集合:

【Java集合】Collection 体系集合详解(ArrayList,LinkedList,HashSet,TreeSet...)

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 实现类采用双向链表结构实现,增删快,查询慢。

【Java集合】Collection 体系集合详解(ArrayList,LinkedList,HashSet,TreeSet...)
同样的,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 方法,必须重写该方法来确定是否为重复元素,否则程序会出现异常。

【Java集合】Collection 体系集合详解(ArrayList,LinkedList,HashSet,TreeSet...)

示例:

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 包的使用详解