目录

Java集合框架的知识在Java基础阶段是极其重要的，我平时使用List、Set和Map集合时经常出错，常用方法还记不牢，
于是就编写这篇博客来完整的学习一下Java集合框架的知识，如有遗漏和错误，欢迎大家指出。
以下是我整理的大致Java集合框架内容，本篇博客就是围绕以下内容展开

注：本篇博客是根据B站Java集合框架的视频进行编写，视频原地址：【千锋】最新版 Java集合框架详解 通俗易懂

下面我们开始正式学习！！！

1.1、概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

1.2、集合与数组区别：

  • 数组长度固定，集合长度不固定

  • 数组可以存储基本类型和引用类型，集合只能存储引用类型

1.3、位置：java.util*

Collection体系集合

  • 特点:代表一组任意类型的对象，无序、无下标、不能重复

  • 方法：

（1）Demo1保存字符串（重点关注迭代器iterator的使用）

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Iterator;
  5. public class Demo1 {
  6.     public static void main(String[] args) {
  7.         //创建集合
  8.         Collection collection = new ArrayList();
  9.         //1.添加元素
  10.         collection.add("香蕉");
  11.         collection.add("苹果");
  12.         collection.add("西瓜");
  13.         System.out.println("元素个数："+collection.size());
  14.         System.out.println(collection);
  16.         //2.删除元素
  17.         //collection.remove("香蕉");
  18.         //collection.clear();//清除
  19.         //System.out.println("删除之后："+collection.size());
  21.         //3.遍历元素(重点)
  22.         System.out.println("==========================");
  23.         //方法一：增强for
  24.         for (Object object:collection) {
  25.             System.out.println(object);
  26.         }
  27.         //方法二：使用迭代器（迭代器专门用来遍历集合的一种方式）
  28.         //iterator3个方法
  29.         //hasNext();有没有下一个元素
  30.         //next();l获取下一个元素
  31.         //remove();删除当前元素
  32.         System.out.println("==========================");
  33.         Iterator iterator = collection.iterator();
  34.         while (iterator.hasNext()) {
  35.             String s = (String) iterator.next();
  36.             System.out.println(s);
  37.             // collection.remove(s);//不允许使用collection删除会引发并发修改错误，只能使用以下方法移除
  38.             //iterator.remove();
  39.         }
  40.         System.out.println("元素个数："+collection.size());
  43.         //4.判断
  44.         System.out.println(collection.contains("香蕉"));
  45.         System.out.println(collection.isEmpty());
  48.     }
  49. }

结果

（2）Demo2 保存学生信息

学生类

  1. //学生类
  2. public class Student {
  3.     private String name;
  4.     private int age;
  6.     public String getName() {
  7.         return name;
  8.     }
  10.     public void setName(String name) {
  11.         this.name = name;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Student{" +
  17.                 "name='" + name + '\'' +
  18.                 ", age=" + age +
  19.                 '}';
  20.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  26.     public void setAge(int age) {
  27.         this.age = age;
  28.     }
  30.     public Student() {
  31.     }
  33.     public Student(String name, int age) {
  34.         this.name = name;
  35.         this.age = age;
  36.     }
  38. }
  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Iterator;
  5. //  保存学生信息
  6. public class Demo2 {
  7.     public static void main(String[] args) {
  8.         //新建Collection对象
  9.         Collection collection = new ArrayList();
  11.         Student s1 = new Student("张三",18);
  12.         Student s2 = new Student("李四",19);
  13.         Student s3 = new Student("王五",21);
  14.         //1.添加数据
  15.         collection.add(s1);
  16.         collection.add(s2);
  17.         collection.add(s3);
  18.         
  19.         System.out.println("元素个数："+collection.size());
  20.         System.out.println(collection.toString());
  22.         //2.删除
  23.         //collection.remove(s1);
  24.         //System.out.println("删除之后："+collection.size());
  26.         //3.遍历
  27.         //方法一：增强for
  28.         System.out.println("========增强for===========");
  29.         for (Object object:collection) {
  30.             Student s = (Student) object;
  31.             System.out.println(s.toString());
  32.         }
  34.         //方法二：使用迭代器（迭代器专门用来遍历集合的一种方式）
  35.         System.out.println("========使用迭代器===========");
  36.         Iterator iterator = collection.iterator();
  37.         while (iterator.hasNext()) {
  38.             Student s =(Student) iterator.next();
  39.         }
  40.         System.out.println(collection.toString());
  42.         //4.判断
  43.         System.out.println(collection.contains(s1));
  44.         System.out.println(collection.isEmpty());
  47.     }
  48. }

结果

  • 特点：有序，有下标，元素可以重复

  • 方法：

（1）Demo3

  1. public class Demo3 {
  2.     public static void main(String[] args) {
  3.         //先创建一个集合对象
  4.         List list = new ArrayList();
  5.         //1.添加元素
  6.         list.add("唱");
  7.         list.add("跳");
  8.         list.add(0,"打篮球");//下标为0，放在第一位
  9.         System.out.println("元素个数:"+list.size());
  10.         System.out.println(list.toString());
  12.         //2.删除元素
  13. //        list.remove("唱");
  14. //        list.remove(1);
  15. //        System.out.println("元素个数:"+list.size());
  16. //        System.out.println(list.toString());
  19.         //3.遍历
  20.         //方法一:使用for遍历
  21.         System.out.println("===========for遍历===============");
  22.         for (int i = 0; i < list.size(); i++) {
  23.             System.out.println(list.get(i));
  24.         }
  26.         //方法二:使用增强for
  27.         System.out.println("===========增强for===============");
  28.         for (Object o:list) {
  29.             System.out.println(o);
  30.         }
  32.         //方法三:使用迭代器
  33.         System.out.println("===========迭代器===============");
  34.         Iterator iterator = list.iterator();
  35.         while (iterator.hasNext()) {
  36.             System.out.println(iterator.next());
  37.         }
  38.         //方法四:使用列表迭代器
  39.         //和迭代器的区别：可以向前或向后遍历，添加、删除、修改元素
  40.         System.out.println("===========列表迭代器===============");
  41.         ListIterator lit = list.listIterator();
  43.         System.out.println("===========列表迭代器从前往后===============");
  44.         while (lit.hasNext()) {
  45.             System.out.println(lit.nextIndex()+":"+lit.next());
  46.         }
  48.         System.out.println("===========列表迭代器从后往前===============");
  49.         while (lit.hasPrevious()) {
  50.             System.out.println(lit.previousIndex()+":"+lit.previous());
  51.         }
  54.         System.out.println("==========================");
  55.         //4.判断
  56.         System.out.println(list.contains("rap"));
  57.         System.out.println(list.isEmpty());
  59.         //5.获取位置
  60.         System.out.println(list.indexOf(2));
  62.     }
  64. }

结果

（2）Demo4

  1. public class Demo4 {
  2.     public static void main(String[] args) {
  3.         //先创建一个集合对象
  4.         List list = new ArrayList();
  5.         //1.添加数字数据(自动装箱)
  6.         list.add(17);
  7.         list.add(27);
  8.         list.add(37);
  9.         list.add(47);
  10.         list.add(57);
  11.         System.out.println("元素个数:"+list.size());
  12.         System.out.println(list.toString());
  14.         //2.删除
  15.         //注意这里是用脚标删除的，如果要用数字需要转成Object
  16.         list.remove(0);
  17.         //list.remove((Object) 17);
  18.         //list.remove(new Integer(20));
  20.         System.out.println("元素个数:"+list.size());
  21.         System.out.println(list.toString());
  24.         //3.补充方法subList:返回子集合，包含头不包含尾
  25.         List subList = list.subList(1, 3);
  26.         System.out.println(subList.toString());
  29.     }
  30. }

结果：

  • ArrayList（重点）：

    • 数组结构实现，查询快，增删慢
    • jdk1.2版本后加入,运行效率快，线程不安全

  • Vector:

    • 数组结构实现，查询快，增删慢
    • jdk1.0版本后加入,运行效率慢，线程安全

  • LinkedList:

    • 链表结构实现，增删快，查询慢
  1. /**
  2.  * ArrayList的使用
  3.  * 特点：有序，有下标，可以重复
  4.  * 存储结构：数组，查找遍历速度快，增删慢
  5.  */
  7. public class Demo5 {
  8.     public static void main(String[] args) {
  9.         //创建结合
  10.         ArrayList arrayList = new ArrayList();
  12.         //1.添加元素
  13.         Student s1 = new Student("张三",20);
  14.         Student s2 = new Student("李四",23);
  15.         Student s3 = new Student("王五",19);
  16.         arrayList.add(s1);
  17.         arrayList.add(s2);
  18.         arrayList.add(s3);
  19.         System.out.println("元素个数:"+arrayList.size());
  20.         System.out.println(arrayList.toString());
  22.         //2.删除元素
  23. //        arrayList.remove(0);
  24. //        arrayList.remove(s2);
  25.         arrayList.remove(new Student("ooof",12));//这样删除需要在Student中重写 equals(this == obj) 方法
  27.         //3.遍历元素【重点】
  28.         //使用迭代器
  29.         System.out.println("========= 使用迭代器=========");
  30.         Iterator it = arrayList.iterator();
  31.         while (it.hasNext()) {
  32.             Student s =(Student) it.next();
  33.             System.out.println(s.toString());
  34.         }
  35.         //列表迭代器
  36.         System.out.println("========= 列表迭代器=========");
  37.         ListIterator lit = arrayList.listIterator();
  38.         while (lit.hasNext()) {
  39.             Student s =(Student) lit.next();
  40.             System.out.println(s.toString());
  41.         }
  44.         System.out.println("========= 列表迭代器逆序=========");
  46.         while (lit.hasPrevious()) {
  47.             Student s =(Student) lit.previous();
  48.             System.out.println(s.toString());
  49.         }
  51.         //4.判断
  52.         System.out.println(arrayList.contains(new Student("王五",19)));
  53.         System.out.println(arrayList.isEmpty());
  54.         //5.查找
  55.         System.out.println(arrayList.indexOf(new Student("王五",19)));
  56.     }
  57. }

结果

源码分析

  • 默认容量:DEFAULT_CAPACITY = 10;

    • 注：如果没有向集合中添加任何元素，容量为0,添加一个元素之后，容量为10，每次扩容大小为原来的1.5 倍

  • 存放元素的数组：elementData

  • 实际元素个数：size

  • 添加元素：add()方法

    1. public boolean add(E e) {
    2.     modCount++;
    3.     add(e, elementData, size);
    4.     return true;
    5. }
    10.    public void ensureCapacity(int minCapacity) {
    11.         if (minCapacity > elementData.length
    12.             && !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    13.                  && minCapacity <= DEFAULT_CAPACITY)) {
    14.             modCount++;
    15.             grow(minCapacity);
    16.         }
    17.     }
    19. //grow为核心
    20.     private Object[] grow(int minCapacity) {
    21.         int oldCapacity = elementData.length;
    22.         if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    23.             int newCapacity = ArraysSupport.newLength(oldCapacity,
    24.                     minCapacity - oldCapacity, /* minimum growth */
    25.                     oldCapacity >> 1           /* preferred growth */);
    26.             return elementData = Arrays.copyOf(elementData, newCapacity);
    27.         } else {
    28.             return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    29.         }
    30.     }

  • 存储结构：数组

  • 创建集合 Vector vector = new Vector<>();

  • 增加（vector.add()）、删除(vector.remove)、判断(vector.contains())同上

  • 遍历–枚举器遍历

  1. Enumeration en = vector.elements();
  2. while(en.hasMoreElements()){
  3.   String s = (String)en.nextElement();
  4.   sout(s);
  5. }
  1. /**
  2.  *LinkedList的使用
  3.  * 存储结构：双向链表
  4.  * 可以重复添加
  5.  */
  6. public class LinkedListTest1 {
  7.     public static void main(String[] args) {
  9.         //创建集合
  10.         LinkedList linkedList = new LinkedList<>();
  11.         //1.添加元素
  12.         Student s1 = new Student("张三",20);
  13.         Student s2 = new Student("李四",23);
  14.         Student s3 = new Student("王五",19);
  15.         linkedList.add(s1);
  16.         linkedList.add(s2);
  17.         linkedList.add(s3);
  19.         System.out.println("元素个数:"+linkedList.size());
  20.         System.out.println(linkedList.toString());
  22.         //2.删除
  23. //        linkedList.remove(s1);
  24. //        System.out.println("删除之后:"+linkedList.size());
  26.         //3.遍历
  27.         //for遍历
  28.         System.out.println("========for=====");
  29.         for (int i = 0; i < linkedList.size(); i++) {
  30.             System.out.println(linkedList.get(i));
  31.         }
  32.         System.out.println("========增强for=====");
  33.         for (Object object:linkedList) {
  34.             Student s = (Student) object;
  35.             System.out.println(s.toString());
  36.         }
  37.         //迭代器
  38.         System.out.println("========迭代器=====");
  39.         Iterator it = linkedList.iterator();
  40.         while (it.hasNext()) {
  41.             Student s =(Student) it.next();
  42.             System.out.println(s.toString());
  43.         }
  44.         System.out.println("========列表迭代器=====");
  45.         ListIterator lit = linkedList.listIterator();
  46.         while (lit.hasNext()) {
  47.             Student s =(Student) lit.next();
  48.             System.out.println(s.toString());
  49.         }
  51.         //4.判断
  52.         System.out.println(linkedList.contains(s1));
  53.         System.out.println(linkedList.isEmpty());
  55.         //5.获取
  56.         System.out.println(linkedList.indexOf(s1));
  58.     }
  59. }

结果

源码分析

  1. transient int size = 0;//集合大小
  3.  transient Node<E> first;//头结点
  4.  
  5.  transient Node<E> last;//尾节点
  6.  
  7.   public boolean add(E e) {
  8.         linkLast(e);
  9.         return true;
  10.     }
  11.     
  12.    void linkLast(E e) {
  13.         final Node<E> l = last;
  14.         final Node<E> newNode = new Node<>(l, e, null);
  15.         last = newNode;
  16.         if (l == null)
  17.             first = newNode;
  18.         else
  19.             l.next = newNode;
  20.         size++;
  21.         modCount++;
  22.     }

  • ArrayList：数组，必须开辟连续空间，查询快，增删慢

  • LinkedList：双向链表，无需开辟连续空间，查询慢，增删快

泛型

  • Java泛型是JDK1.5中引入的一个新特性，其本质是參数化类型，把类型作为参数传递
  • 常见形式有泛型类、泛型接口、泛型方法
  • 语法：
    • <T,…＞T称为类型占位符，表示一种引用类型。
  • 好处：
    • (1）提高代码的重用性
    • (2）防止类型转换异常，提高代码的安全性

泛型类

  1. /**
  2.  * 泛型类
  3.  * 语法：<T>
  4.  * T表示类型占位符，表示一种引用类型，如果编写多个用逗号隔开
  5.  * */
  6. public class MyGeneric<T> {
  7.     //使用泛型T
  8.     //1.创建变量,不能new T()因为T数据类型不确定
  9.     T t;
  11.     //2.创建一个方法，作为方法的参数
  12.     public void show(T t){
  13.         System.out.println(t);
  14.     }
  16.     //3.使用泛型作为方法的返回值
  17.     public T getT(){
  18.         return t;
  19.     }
  20. }
  1. public class TestGeneric {
  2.     public static void main(String[] args) {
  3.         //使用泛型类创建对象
  4.         //注意：1.泛型只能使用引用类型，2.不同泛型类型对象之间不能相互赋值
  6.         MyGeneric<String> myGeneric = new MyGeneric<String>();
  7.         myGeneric.t = "hello";
  8.         myGeneric.show("你好");
  9.         String t1 = myGeneric.getT();
  12.         MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
  13.         myGeneric2.t = 100;
  14.         myGeneric2.show(200);
  15.         Integer t2 = myGeneric2.getT();
  18.     }
  19. }

结果：

泛型接口

  1. /**
  2.  *泛型接口
  3.  * 语法：接口名<T>
  4.  * 注意：不能使用泛型来创建静态常量
  5.  */
  7. public interface MyInterface<T> {
  8.     String name = "张三";
  10.     T server(T t);
  11. }

泛型接口实现有两种方法：

1、指定数据类型

  1. public class MyInterfaceImpl implements MyInterface<String>{
  2.     @Override
  3.     public String server(String t) {
  4.         System.out.println(t);
  5.         return t;
  6.     }
  7. }

测试

  1. MyInterfaceImpl impl = new MyInterfaceImpl();
  2. impl.server("KKKKKKKK");

2、不指定数据类型

  1. public class MyInterfaceImpl2<T> implements MyInterface<T>{
  2.     @Override
  3.     public T server(T t) {
  4.         System.out.println(t);
  5.         return t;
  6.     }

测试

  1. MyInterfaceImpl2 impl2 = new MyInterfaceImpl2();
  2. impl2.server(1000);

结果：

泛型方法

  1. /**
  2.  *泛型方法
  3.  * 语法:<T>返回值类型
  4.  */
  7. public class MyGenericMethod {
  8.     //泛型方法
  9.     public <T> void show(T t){
  10.         System.out.println("泛型方法"+t);
  11.     }
  12. }

测试

  1. //泛型方法
  2. //不需要指定类型
  3. MyGenericMethod myGenericMethod = new MyGenericMethod();
  4. myGenericMethod.show("坤坤");
  5. myGenericMethod.show(200);
  6. myGenericMethod.show(3.1415);

结果：

泛型集合

  • 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
  • 特点：
    • 编译时即可检查，而非逐行时抛出异常。
    • 访问时，不必类型转换（拆箱）。
    • 不同泛型之间引用不能相互赋值，泛型不存在多态。
  1. public class DemoCollect {
  2.     public static void main(String[] args) {
  3.         ArrayList<String> arrayList = new ArrayList<String>();
  4.         arrayList.add("xxx");
  5.         arrayList.add("yyy");
  6.         //指定String类型一下两条数据就不能添加进去
  7. //        arrayList.add(10);
  8. //        arrayList.add(20);
  10.         for (String str:arrayList) {
  11.             System.out.println(str);
  12.         }
  15.         ArrayList<Student> arrayList2 = new ArrayList<Student>();
  16.         Student s1 = new Student("张三",18);
  17.         Student s2 = new Student("李四",19);
  18.         Student s3 = new Student("王五",21);
  19.         arrayList2.add(s1);
  20.         arrayList2.add(s2);
  21.         arrayList2.add(s3);
  23.         Iterator<Student> iterator = arrayList2.iterator();
  24.         while (iterator.hasNext()) {
  25.             Student s = iterator.next();
  26.             System.out.println(s.toString());
  27.         }
  30.     }
  31. }

测试

  • 特点：无序，无下标，元素不可重复

  • 方法：全部继承自Collecton中的方法

  1. /**
  2.  * 测试Set接口的使用
  3.  * 特点：无序，无下标，元素不可重复
  4.  */
  7. public class Demo1 {
  8.     public static void main(String[] args) {
  9.         //创建集合
  10.         HashSet<String> set = new HashSet<>();
  11.         //1.添加数据
  12.         set.add("唱");
  13.         set.add("跳");
  14.         set.add("rap");
  15.         //set.add("rap");重复添加不进去
  16.         System.out.println("数据个数:"+set.size());
  17.         System.out.println(set.toString());
  19.         //2.删除
  20.         set.remove("唱");
  21.         System.out.println(set.toString());
  23.         //3.遍历【重点】
  24.         System.out.println("----增强for----");
  25.         for (String str:set) {
  26.             System.out.println(str);
  27.         }
  28.         System.out.println("----迭代器----");
  29.         Iterator<String> iterator = set.iterator();
  30.         while (iterator.hasNext()) {
  31.             String s = iterator.next();
  32.             System.out.println(s);
  33.         }
  35.         //4.判断
  36.         System.out.println(set.contains("打篮球"));
  37.         System.out.println(set.isEmpty());
  39.         
  41.     }
  42. }

测试：（注意这里添加的顺序与显示的顺序不同，因为无序）

  • HashSet【重点】：
    • 基于HashCode实现元素不重复。
    • 当存入元素的哈希码相同时，会调用equalsi进行确认，如结果为true,则拒绝后者存入。
  • TreeSet:
    • 基于排列顺序实现元素不重复。
    • 实现了SortedSet接口，对集合元素自动排序
    • 元素对象的类型必须实现Comparable接口，指定排序规则
    • 通过CompareTo方法确定是否为重复元素

HashSet的使用

（1）Demo2

  1. /***
  2.  * HashSet集合的使用
  3.  * 存储结构：哈希表（数组+链表+红黑树）
  4.  */
  5. public class Demo2 {
  6.     public static void main(String[] args) {
  7.         //新建集合
  8.         HashSet<String> hashSet = new HashSet<>();
  9.         //1.添加元素
  10.         hashSet.add("张三");
  11.         hashSet.add("李四");
  12.         hashSet.add("王五");
  13.         hashSet.add("赵六");
  14.         System.out.println("数据个数:"+hashSet.size());
  15.         System.out.println(hashSet.toString());
  17.         //2.删除
  18.         hashSet.remove("张三");
  19.         System.out.println("删除后数据个数:"+hashSet.size());
  20.         System.out.println(hashSet.toString());
  22.         //3.遍历
  23.         System.out.println("----增强for----");
  24.         for (String str:hashSet) {
  25.             System.out.println(str);
  26.         }
  27.         System.out.println("----迭代器----");
  28.         Iterator<String> iterator = hashSet.iterator();
  29.         while (iterator.hasNext()) {
  30.             String s = iterator.next();
  31.             System.out.println(s);
  32.         }
  34.         //4.判断
  35.         System.out.println(hashSet.contains("打篮球"));
  36.         System.out.println(hashSet.isEmpty());
  40.     }
  42. }

测试

（2）Demo3

person类

  1. public class Person {
  2.     private String name;
  3.     private int age;
  5.     @Override
  6.     public String toString() {
  7.         return "Person{" +
  8.                 "name='" + name + '\'' +
  9.                 ", age=" + age +
  10.                 '}';
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public Person() {
  30.     }
  32.     public Person(String name, int age) {
  33.         this.name = name;
  34.         this.age = age;
  35.     }
  39.     @Override
  40.     public int hashCode() {
  41.         int n1 = this.name.hashCode();
  42.         int n2 = this.age;
  43.         return n1+n2;
  44.     }
  46.     @Override
  47.     public boolean equals(Object o) {
  48.         if (this == o) return true;
  50.         if (o == null || getClass() != o.getClass()) return false;
  52.         if(o instanceof Person){
  53.         Person person = (Person) o;
  54.         if(this.name.equals(person.getName())&&this.age == person.getAge()){
  55.             return true;
  56.         }
  57.         }
  58.         return false;
  59.     }
  61.     
  62. }

Demo3

  1. /***
  2.  * HashSet集合的使用
  3.  * 存储结构：哈希表（数组+链表+红黑树）
  4.  * 存储过程：
  5.  * （1）根据hashcode计算保存位置，如果位置为空，则直接保存，如果不为空，执行第二步
  6.  * （2）再执行equals方法，如果equals方法为true，则认为是重复，否则形成链表
  7.  */
  8. public class Demo3 {
  9.     public static void main(String[] args) {
  12.     //新建集合
  13.     HashSet<Person> persons = new HashSet<>();
  14.     //1.添加元素
  15.     Person p1 = new Person("乔纳森-乔斯达",20);
  16.     Person p2 = new Person("乔瑟夫-乔斯达",19);
  17.     Person p3 = new Person("空条承太郎",16);
  19.     persons.add(p1);
  20.     persons.add(p2);
  21.     persons.add(p3);
  22.     persons.add(new Person("空条承太郎",16));//重写hashCode()形成链表,再重写equals()就不能添加进来了
  24.     System.out.println("元素个数:"+persons.size());
  25.     System.out.println(persons.toString());
  27.     //2.删除
  29. //    persons.remove(p1);
  30. //    persons.remove( new Person("乔纳森-乔斯达",20));//这时可以删除
  31. //    System.out.println("删除之后："+persons.toString());
  33.     //3.遍历
  34.         System.out.println("------for----");
  35.         for (Person person:persons) {
  36.             System.out.println(person.toString());
  37.         }
  38.         System.out.println("------迭代器----");
  39.         Iterator<Person> iterator = persons.iterator();
  40.         while (iterator.hasNext()) {
  41.             System.out.println(iterator.next());
  42.         }
  44.     //4.判断
  45.         System.out.println(persons.contains(p1));
  46.         System.out.println(persons.isEmpty());
  48.     }
  49. }

测试

（1）简单使用

  1. /**
  2.  * TreeSet的使用
  3.  * 存储结构：红黑树
  4.  */
  5. public class Demo4 {
  6.     public static void main(String[] args) {
  7.         //创建集合
  8.         TreeSet<String> treeSet = new TreeSet<>();
  9.         //1.添加元素
  10.         treeSet.add("xyz");
  11.         treeSet.add("abc");
  12.         treeSet.add("wer");
  13.         treeSet.add("opq");
  14.         System.out.println("元素个数："+treeSet.size());
  15.         System.out.println(treeSet.toString());
  17.         //2.删除
  18.         treeSet.remove("wer");
  19.         System.out.println("删除后元素个数："+treeSet.size());
  21.         //3.遍历
  22.         for (String str:treeSet) {
  23.             System.out.println(str);
  24.         }
  26.         //4.判断
  27.         System.out.println(treeSet.contains("opq"));
  29.     }
  30. }

（2）保存Person类的数据

  1. /**
  2.  * 使用TreeSet保存数据
  3.  * 存储结构：红黑树
  4.  * 要求：元素必须要实现Comparable接口,compareTo方法返回值为0，认为是重复元素
  5.  */
  7. public class Demo5 {
  8.     public static void main(String[] args) {
  9.         //创建集合
  10.         TreeSet<Person> persons = new TreeSet<>();
  11.         //1.添加元素
  12.         Person p1 = new Person("7乔纳森-乔斯达",20);
  13.         Person p2 = new Person("5乔瑟夫-乔斯达",19);
  14.         Person p3 = new Person("3东方仗助",16);
  15.         Person p4 = new Person("3东方仗助",17);
  17.         //直接添加不能添加进去，因为没有比较规则，即没有实现Comparable接口，需要在Person类中实现
  18.         persons.add(p1);
  19.         persons.add(p2);
  20.         persons.add(p3);
  21.         persons.add(p4);
  23.         System.out.println("元素个数："+persons.size());
  24.         System.out.println(persons.toString());
  26.         //2.删除
  27.         persons.remove(p4);
  28.         System.out.println("元素个数："+persons.size());
  30.         //3.遍历
  31.         Iterator<Person> iterator = persons.iterator();
  32.         while (iterator.hasNext()) {
  33.             System.out.println(iterator.next());
  34.         }
  36.         //4.判断
  37.         System.out.println(persons.contains(p1));
  38.     }
  39. }

person类没有实现Comparable接口

person类实现Comparable接口

  1. public class Person implements Comparable<Person>{
  2.     private String name;
  3.     private int age;
  5.     @Override
  6.     public String toString() {
  7.         return "Person{" +
  8.                 "name='" + name + '\'' +
  9.                 ", age=" + age +
  10.                 '}';
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public Person() {
  30.     }
  32.     public Person(String name, int age) {
  33.         this.name = name;
  34.         this.age = age;
  35.     }
  39.     @Override
  40.     public int hashCode() {
  41.         int n1 = this.name.hashCode();
  42.         int n2 = this.age;
  43.         return n1+n2;
  44.     }
  46.     @Override
  47.     public boolean equals(Object o) {
  48.         if (this == o) return true;
  50.         if (o == null || getClass() != o.getClass()) return false;
  52.         if(o instanceof Person){
  53.         Person person = (Person) o;
  54.         if(this.name.equals(person.getName())&&this.age == person.getAge()){
  55.             return true;
  56.         }
  57.         }
  58.         return false;
  59.     }
  61.     //先按姓名比再按年龄比
  62.     @Override
  63.     public int compareTo(Person o) {
  64.         int n1 = this.getName().compareTo(o.getName());
  65.         int n2 = this.age - o.getAge();
  66.         return n1==0?n2:n1;
  67.     }
  68. }

测试

Comparator接口实现定制比较（不需要元素实现Comparable接口）

  1. /**
  2.  * 使用TreeSet保存数据
  3.  * 存储结构：红黑树
  4.  * Comparator:实现定制比较（比较器）
  5.  */
  6. public class Demo6 {
  7.     public static void main(String[] args) {
  8.         //创建集合，并指定比较规则（匿名内部类）
  9.         TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
  10.             @Override
  11.             //先比较年龄再比较姓名
  12.             public int compare(Person o1, Person o2) {
  13.                 int n1 = o1.getAge() - o2.getAge();
  14.                 int n2 = o1.getName().compareTo(o2.getName());
  15.                 return n1==0?n2:n1;
  16.             }
  17.         });
  19.         //1.添加元素
  20.         Person p1 = new Person("7乔纳森-乔斯达",20);
  21.         Person p2 = new Person("5乔瑟夫-乔斯达",19);
  22.         Person p3 = new Person("3东方仗助",16);
  23.         Person p4 = new Person("4东方仗助",16);
  26.         persons.add(p1);
  27.         persons.add(p2);
  28.         persons.add(p3);
  29.         persons.add(p4);
  31.         System.out.println(persons.toString());
  33.     }
  35. }

测试

TreeSet案例

  1. /**
  2.  * 要求：使用TreeSet集合实现字符串按照长度进行排序
  3.  * Comparator实现定制比较
  4.  *
  5.  */
  6. public class Demo7 {
  7.     public static void main(String[] args) {
  8.         //创建集合并指定比较规则
  9.         TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
  10.             @Override
  11.             public int compare(String o1, String o2) {
  13.                 int n1 = o1.length() - o2.length();
  14.                 int n2 = o1.compareTo(o2);
  16.                 return n1==0?n2:n1;
  17.             }
  18.         });
  19.         //添加数据
  20.         treeSet.add("hello");
  21.         treeSet.add("hello,world");
  22.         treeSet.add("dalian");
  23.         treeSet.add("kunkun");
  24.         treeSet.add("ikun");
  25.         treeSet.add("cat");
  26.         treeSet.add("beijing");
  28.         System.out.println(treeSet.toString());
  30.     }
  31. }

测试

Map体系集合

Map接口的特点：

  1. 用于存储任意键值对(Key-Value)

  2. 键：无序、无下标、不允许重复（唯一）

  3. 值：无序、无下标、允许重复

Map父接口

  • 特点：存储一对数据(Key-Value),无序、无下标，键不可重复，值可重复。

  • 方法：

    • V put(K key,V value) //将对象存入到集合中，关联键值。key重复则覆盖原值。
    • Object get(Object key)//根据键获取对应的值。
    • Set keySet() //返回所有key。
    • Collectionvalues()//返回包含所有值的Collection集合。
    • Set<Map.Entry<K,V>>//键值匹配的Set集合。

Map接口使用

  1. /**
  2.  * Map接口的使用
  3.  * 特点：（1）存储键值对（2）键不能重复，值可以重复（3）无序
  4.  */
  5. public class Demo1 {
  6.     public static void main(String[] args) {
  7.         //创建Map集合
  9.         Map<String, String> map = new HashMap<>();
  10.         //1.添加元素
  11.         map.put("tom","汤姆");
  12.         map.put("jack","杰克");
  13.         map.put("rose","露丝");
  15.         //map.put("rose","ooo");value会被替换
  17.         System.out.println("元素个数："+map.size());
  18.         System.out.println(map.toString());
  20.         //2.删除
  21. //        map.remove("tom");
  22. //        System.out.println("删除后元素个数："+map.size());
  24.         //3.遍历
  25.         //3.1使用keySet()
  26.         System.out.println("-------keySet()遍历---------");
  27.         //Set<String> keySet = map.keySet();
  28.         for(String key:map.keySet()){
  29.             System.out.println(key+"---"+map.get(key));
  30.         }
  31.         //3.2使用entrySet()
  32.         System.out.println("-------entrySet()遍历---------");
  33.         //Set<Map.Entry<String, String>> entries = map.entrySet();
  34.         for (Map.Entry<String, String> entry: map.entrySet()) {
  35.             System.out.println(entry.getKey()+"---"+entry.getValue());
  37.         }
  39.         //4.判断
  40.         System.out.println(map.containsKey("jack"));
  41.         System.out.println(map.containsValue("杰克"));
  44.     }
  45. }

测试

keySet()与entrySet()

  • HashMap【重点】

    • jdk1.2版本，线程不安全，运行效率快
    • 允许使用null作为key或value

  • Hashtable【了解】

    • jdk1.0版本，线程安全，运行效率慢
    • 不允许使用null作为key或value

  • Properties

    • Hashtable的子类
    • 要求key和value都是String
    • 通常用于配置文件的读取

  • TreeMap

    • 实现了SortedMap接口（是Map的子接口），可以对key自动排序

Student类：

  1. public class Student {
  2.     private String name;
  3.     private int stuNo;
  5.     public Student(String name, int stuNo) {
  6.         this.name = name;
  7.         this.stuNo = stuNo;
  8.     }
  10.     public Student() {
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getStuNo() {
  22.         return stuNo;
  23.     }
  25.     public void setStuNo(int stuNo) {
  26.         this.stuNo = stuNo;
  27.     }
  29.     @Override
  30.     public String toString() {
  31.         return "Student{" +
  32.                 "name='" + name + '\'' +
  33.                 ", stuNo=" + stuNo +
  34.                 '}';
  35.     }
  37.     @Override
  38.     public boolean equals(Object o) {
  39.         if (this == o) return true;
  40.         if (o == null || getClass() != o.getClass()) return false;
  41.         Student student = (Student) o;
  42.         return stuNo == student.stuNo && Objects.equals(name, student.name);
  43.     }
  45.     @Override
  46.     public int hashCode() {
  47.         return Objects.hash(name, stuNo);
  48.     }
  49. }
  1. /**
  2.  * HashMap集合的使用
  3.  * 存储结构：哈希表(数组+链表+红黑树)
  4.  * 存储过程：
  5.  *  （1）根据hashcode计算保存位置，如果位置为空，则直接保存，如果不为空，执行第二步
  6.  *  （2）再执行equals方法，如果equals方法为true，则认为是重复，否则形成链表
  7.  */
  9. public class Demo2 {
  10.     public static void main(String[] args) {
  11.         //创建集合
  12.         HashMap<Student,String> students = new HashMap<>();
  13.         //1.添加元素
  14.         Student s1 = new Student("张三",503);
  15.         Student s2 = new Student("李四",509);
  16.         Student s3 = new Student("王五",505);
  17.         students.put(s1,"3班");
  18.         students.put(s2,"7班");
  19.         students.put(s3,"8班");
  20.         //students.put(s3,"9班");键重复不能添加进去，但是值会覆盖
  21.         students.put(new Student("张三",503),"3班");
  22.         //会添加进去，new会在堆中新创建一个对象，如果要让它添加不进去，要在Student中重写hashcode和equals方法
  24.         System.out.println("元素个数："+students.size());
  25.         System.out.println(students.toString());
  26.         
  27.         //2.删除
  28. //        students.remove(s1);
  29. //        System.out.println("删除之后："+students.size());
  31.         //3.遍历
  32.         
  33.         //keySet()
  34.         System.out.println("-------keySet()遍历---------");
  35.         for (Student key: students.keySet()) {
  36.             System.out.println(key.toString()+"========="+students.get(key));
  37.         }
  38.         System.out.println("-------entrySet()遍历---------");
  39.         for (Map.Entry<Student,String> entry: students.entrySet()) {
  40.             System.out.println(entry.getKey()+"========="+entry.getValue());
  41.         }
  42.         
  43.         //4.判断
  44.         System.out.println(students.containsKey(s1));
  45.         
  46.         
  49.     }
  50. }

测试

  1. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;       // aka 16  HashMap初始容量大小
  3. static final int MAXIMUM_CAPACITY = 1 << 30;              // HashMap数组的最大容量
  4.  
  5. static final float DEFAULT_LOAD_FACTOR = 0.75f;           //默认加载因子为0.75（到75%时扩容）
  7. static final int TREEIFY_THRESHOLD = 8;                  //链表长度大于8时，调整成红黑树
  8.  
  9. static final int UNTREEIFY_THRESHOLD = 6;                //链表长度小于6时，调整成链表
  11. static final int MIN_TREEIFY_CAPACITY = 64;             //链表长度大于8,并且集合元素个数大于等于64时，调整成红黑树
  13. transient Node<K,V>[] table;                            //哈希表中的数组
  15. transient int size;                                     //元素个数

构造函数

  1.  public HashMap() {
  2.         this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
  3.     }
  4.     
  5.  //刚创建HashMap之后没有添加元素 table=null，size=0  目的是节省空间

put方法（这个源码不太容易理解，大家尝试理解前每个方法的前几行就可以，有能力的可以深入研究）

  1. //put方法  
  2. public V put(K key, V value) {
  3.         return putVal(hash(key), key, value, false, true);
  4.     }
  6. //putVal方法
  7.   final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
  8.                    boolean evict) {
  9.         Node<K,V>[] tab; Node<K,V> p; int n, i;
  10.         if ((tab = table) == null || (n = tab.length) == 0)
  11.             n = (tab = resize()).length;
  12.         if ((p = tab[i = (n - 1) & hash]) == null)
  13.             tab[i] = newNode(hash, key, value, null);
  14.         else {
  15.             Node<K,V> e; K k;
  16.             if (p.hash == hash &&
  17.                 ((k = p.key) == key || (key != null && key.equals(k))))
  18.                 e = p;
  19.             else if (p instanceof TreeNode)
  20.                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
  21.             else {
  22.                 for (int binCount = 0; ; ++binCount) {
  23.                     if ((e = p.next) == null) {
  24.                         p.next = newNode(hash, key, value, null);
  25.                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
  26.                             treeifyBin(tab, hash);
  27.                         break;
  28.                     }
  29.                     if (e.hash == hash &&
  30.                         ((k = e.key) == key || (key != null && key.equals(k))))
  31.                         break;
  32.                     p = e;
  33.                 }
  34.             }
  35.             if (e != null) { // existing mapping for key
  36.                 V oldValue = e.value;
  37.                 if (!onlyIfAbsent || oldValue == null)
  38.                     e.value = value;
  39.                 afterNodeAccess(e);
  40.                 return oldValue;
  41.             }
  42.         }
  43.         ++modCount;
  44.         if (++size > threshold)
  45.             resize();
  46.         afterNodeInsertion(evict);
  47.         return null;
  48.     }
  50. // resize()方法
  51. final Node<K,V>[] resize() {
  52.         Node<K,V>[] oldTab = table;
  53.         int oldCap = (oldTab == null) ? 0 : oldTab.length;
  54.         int oldThr = threshold;
  55.         int newCap, newThr = 0;
  56.         if (oldCap > 0) {
  57.             if (oldCap >= MAXIMUM_CAPACITY) {
  58.                 threshold = Integer.MAX_VALUE;
  59.                 return oldTab;
  60.             }
  61.             else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
  62.                      oldCap >= DEFAULT_INITIAL_CAPACITY)
  63.                 newThr = oldThr << 1; // double threshold
  64.         }
  65.         else if (oldThr > 0) // initial capacity was placed in threshold
  66.             newCap = oldThr;
  67.         else {               // zero initial threshold signifies using defaults
  68.             newCap = DEFAULT_INITIAL_CAPACITY;
  69.             newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
  70.         }
  71.         if (newThr == 0) {
  72.             float ft = (float)newCap * loadFactor;
  73.             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
  74.                       (int)ft : Integer.MAX_VALUE);
  75.         }
  76.         threshold = newThr;
  77.         @SuppressWarnings({"rawtypes","unchecked"})
  78.         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
  79.         table = newTab;
  80.         if (oldTab != null) {
  81.             for (int j = 0; j < oldCap; ++j) {
  82.                 Node<K,V> e;
  83.                 if ((e = oldTab[j]) != null) {
  84.                     oldTab[j] = null;
  85.                     if (e.next == null)
  86.                         newTab[e.hash & (newCap - 1)] = e;
  87.                     else if (e instanceof TreeNode)
  88.                         ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
  89.                     else { // preserve order
  90.                         Node<K,V> loHead = null, loTail = null;
  91.                         Node<K,V> hiHead = null, hiTail = null;
  92.                         Node<K,V> next;
  93.                         do {
  94.                             next = e.next;
  95.                             if ((e.hash & oldCap) == 0) {
  96.                                 if (loTail == null)
  97.                                     loHead = e;
  98.                                 else
  99.                                     loTail.next = e;
  100.                                 loTail = e;
  101.                             }
  102.                             else {
  103.                                 if (hiTail == null)
  104.                                     hiHead = e;
  105.                                 else
  106.                                     hiTail.next = e;
  107.                                 hiTail = e;
  108.                             }
  109.                         } while ((e = next) != null);
  110.                         if (loTail != null) {
  111.                             loTail.next = null;
  112.                             newTab[j] = loHead;
  113.                         }
  114.                         if (hiTail != null) {
  115.                             hiTail.next = null;
  116.                             newTab[j + oldCap] = hiHead;
  117.                         }
  118.                     }
  119.                 }
  120.             }
  121.         }
  122.         return newTab;
  123.     }

HashMap源码简单总结

  1. HashMap刚创建时，table是null,为了节省空间，当添加第一个元素时，table容量调整为16
  2. 当元素个数大于阈值(16*0.75=12)时，会进行扩容，扩容后大小为原来的2倍，目的是减少调整元素的个数
  3. jdk1.8,当每个链表长度大于8，并且数组元素个数大于等于64时，会调整为红黑树，日的提高执行效率
  4. jdk1.8当链表长度小于6时，调整成链表
  5. jdk1.8以前，链表是头插入，jdk1.8以后是尾插入

  • 概念：集合工具类，定义了除存取以外的集合常用方法

  • 方法：

代码实现

  1. /**
  2.  * Collections工具类的使用
  3.  *
  4.  */
  5. public class Demo4 {
  6.     public static void main(String[] args) {
  7.         List<Integer> list = new ArrayList<>();
  8.         list.add(20);
  9.         list.add(77);
  10.         list.add(23);
  11.         list.add(89);
  12.         list.add(12);
  14.         //sort排序
  15.         System.out.println("排序前："+list.toString());
  16.         Collections.sort(list);//升默认序
  17.         System.out.println("排序后："+list.toString());
  20.         //binarySearch二分查找， 找到为下标，没找到为负数
  21.         int i = Collections.binarySearch(list, 12);
  22.         System.out.println(i);
  24.         //copy复制
  25.         List<Integer> dest = new ArrayList<>();
  26.         for (int j = 0; j < list.size(); j++) {
  27.             dest.add(0);
  28.         }
  29.         Collections.copy(dest,list);
  30.         System.out.println(dest.toString());
  33.         //reverse反转
  34.         Collections.reverse(list);
  35.         System.out.println("反转之后："+list);
  37.         //shuffle  打乱
  38.         Collections.shuffle(list);
  39.         System.out.println("打乱之后："+list);
  42.         //补充：list 转成数组
  43.         System.out.println("=======list 转成数组========");
  44.         Integer[] integers = list.toArray(new Integer[0]);
  45.         System.out.println(integers.length);
  46.         System.out.println(Arrays.toString(integers));
  49.         //数组转成集合
  50.         System.out.println("=======数组转成集合========");
  51.         String[] names = {"小明","小红","小王"};
  52.         //集合是一个受限集合，不能添加和删除
  53.         List<String> list1 = Arrays.asList(names);
  54.         System.out.println(list1);
  56.         //把基本类型数组转成集合时，需要修改为包装类
  57.         Integer[] nums = {100,200,300,400,500};
  58.         List<Integer> integerList = Arrays.asList(nums);
  59.         System.out.println(integerList);
  62.     }
  63. }

测试

最后，我们再看一下这张图回顾一下Java集合框架的重点和常用知识

  • 集合的概念：
    • 对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
  • List集合：
    • 有序、有下标、元素可以重复。(ArrayList、LinkedList、Vector)
  • Set集合：
    • 无序、无下标、元素不可重复。(HashSet、TreeSet)
  • Map集合：
    • 存储一对数据，无序、无下标，键不可重复，值可重复。(HashMap、HashTable、TreeMap)
  • Collections:
    • 集合工具类，定义了除了存取以外的集合常用方法。

到这里关于Java集合框架的知识就结束啦°꒰๑’ꀾ’๑꒱°，希望大家都有所收获，觉得文章还可以的话可以点个推荐支持博主啊

版权声明：本文为鹤鸣呦呦、、原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/qjds/p/16552897.html