Java集合框架超详细小结

• 一：collection集合
• 1.3collection集合常用方法
• 二：迭代器iterator
• 2.1iterator接口
• 2.2iterator的实现原理：
• 四：java常见数据结构
• 五：list集合体系
• 六：set系列集合
• 6.2set集合存储元素不重复的原理
• 6.3hashset存储自定义类型元素
• 6.4linkedhashset集合
• 七：collections工具类
• 八：map集合
• 8.2map集合常见子类
• 8.4map的遍历

一：collection集合

呼~，历过好几天的奋战终于把集合框架肝完了，b站某马老师讲的是真的非常详细而且动听，原理给你分析得明明白白的，此前也找了许多关于集合这一大章节的视频，发现更多的是针对于使用，原理讲的并不是很多，这就导致我在练习或者回顾时还是一知半解。以下是我结合视频以及个人的一些理解和体会做的笔记总结。路漫漫其修远兮，吾将上下而求索，希望这篇总结对你有些许帮助，嘻嘻！

1.1集合概述:

集合：java中提供的一种容器，可以用来存储多个数据。java集合大致可以分为set，list，queue和map四种体系。

数组和集合的区别：

• 数组的长度是固定的。集合的长度是可变的。
• 数组存储的是同一类型的数据，可以存储基本数据类型值。容器能存储对象，而且存储对象的类型可以不一致。在开发中当对象多的时候，使用容器进行存储。

1.2集合架构

单列集合体系结构：

collection接口是所有单列集合的父接口，因此在单列集合中定义的list和set通用的一些方法，这些方法可以操作所有的单列集合。方法如下：

1.3collection集合常用方法

• public boolean add(e e)； 向集合中添加元素
• public boolean remove(e e); 删除集合中的某个元素
• public void clear(); 清空集合中所有的元素
• public boolean contains(); 判断集合中是否含有xxx元素
• publicboolean isempty(); 判断集合是否为空
• publicint size(); 计算集合的长度
• public object[] toarray(); 将集合转成一个数组

【参考代码】

 package collection;
 ​
 import java.util.arraylist;
 import java.util.collection;
 ​
 /*
 collection集合常用方法
 boolean add(e e)；                    向集合中添加元素
 boolean remove(e e);                  删除集合中的某个元素
 void clear();                       清空集合中所有的元素
 boolean contains();                       判断集合中是否含有xxx元素
 boolean isempty();                    判断集合是否为空
 int size();                            计算集合的长度
 object[] toarray();                       将集合转成一个数组
  */
 public class test {
     public static void main(string[] args) {
         //创建集合对象 , 可以多态使用
         collection<string>col = new arraylist<>();
 //      collection<string>col = new hashset<>();    下面的功能照样能实现：共性方法
         col.add("小明"); // 添加元素
         col.add("小红");
         col.add("小蓝");
         col.add("小绿");
         system.out.println(col); //[小明, 小红, 小蓝, 小绿]
 ​
         //boolean remove(e e);      删除集合中的某个元素
 //        boolean ans = col.remove("小明");
 //        system.out.println(ans);//true
 //        system.out.println(col);//[小红, 小蓝, 小绿]
 ​
         //void clear();             清空集合中所有的元素
 //        col.clear();
 //        system.out.println(col);//[]
 ​
         //boolean contains();        判断集合中是否含有xxx元素
 //        boolean result = col.contains("小明");
 //        system.out.println(result);//true
 ​
         //boolean isempty();          判断集合是否为空
 //        boolean result = col.isempty();
 //        system.out.println(result);// 不为空false
 ​
         //int size();             计算集合的长度
 //        int len = col.size();
 //        system.out.println(len);// 4
 ​
         //object[] toarray();        将集合转成一个数组
         object[] arr = col.toarray();
         // 遍历数组
 //        for (int i = 0; i < arr.length; i++) {
 //            system.out.println(arr[i]);
 //        }
     }
 }

二：迭代器iterator

引入：由于集合有多种，每种集合存储跟读取的方式都不一样，好比衣柜、水瓶、药瓶，你存和取的方式肯定不一样。如果每种集合都定义一种遍历方式那将十分的繁琐。

迭代器(iterator)：它不是一个容器而是接口，它是一种用于访问容器的方法，可用于迭代 list、set和map等容器。

迭代：即collection集合的通用获取方式。再获取元素之前先要判断集合中是否有元素，如果有就将这个元素去取出来，继续再判断，直到集合所有元素被取出来为止。即：一个一个的往外拿。

作用：帮我们遍历或者拿到容器里边的数据。

2.1iterator接口

迭代器常用操作：

1. next() 下一个
2. hasnext() 判断是否存在下一个元素
3. remove() 删除元素

迭代器的使用步骤：

1. 使用集合中的的方法iterator()获取迭代器的实现类对象，使用iterator接口接收（多态）
2. 使用tterator接口中的方法hashnext()判断还有没有下一个元素
3. 使用tterator接口中的方法next()取出集合的下一个元素

【参考代码】

 package iterator;
 ​
 import javax.swing.text.html.parser.entity;
 import java.util.*;
 ​
 public class test {
     public static void main(string[] args) {
         //创建一个集合对象
         collection<string>col = new arraylist();
         //添加元素
         col.add("小明");
         col.add("小红");
         col.add("小蓝");
         col.add("小绿");
 ​
         /*
         1.使用集合的方法iterator()获取迭代器的实现类对象，使用iterator接口接收（多态）
         注意：
             iterator接口也是有泛型的，迭代器的泛型跟集合走，集合是什么泛型，迭代器就是什么泛型
          */
         // 多态 接口             实现类对象
         iterator<string>it = col.iterator();
 ​
         // 2.使用 iterator接口中的hashnext方法判断是否还有下一个元素
         while(it.hasnext());{
         // 3.使用 iterator接口中的next方法取出集合的下一个元素
         string str = it.next();
         system.out.println(str);        
         }
 ​
     }
 }

2.2iterator的实现原理：

2.3增强for()

增强for循环（for each循环）是jdk1.5之后的一个高循环，专门用来遍历数组和集合的，所有的数组跟单列集合都可以使用。它的内部原理就是一个迭代器iterator，所以在遍历过程中，不能对集合元素进行增删操作。

语法：

for(类型 变量 : 数组/集合){// 数组或者集合里的每一项赋值给这个变量
     // 循环体
 }

【参考代码】

         string[] student = {"小明","小红","小蓝"};
 //        // 传统遍历方式
 //        for (int i = 0; i < student.length; i++) {
 //            system.out.println(student[i]);
 //        }
 ​
         // 增强for
         for(string c : student){
             system.out.println(c);
         }
 ​
  --------------------------------
         list<integer>list = new arraylist<integer>();
         list.add(123);
         list.add(234);
         list.add(456);
         for(integer n : list){
             system.out.println(n);
         }

注：增强for必须有被遍历的目标。目标只能是数组或者collection，而它仅仅作为遍历操作实现

2.4迭代器注意事项

• 迭代器是一次性对象。我们不能重置迭代器，它不能被重用。
• 要再次遍历同一集合的元素，请通过调用集合的iterator()方法来创建一个新的iterator。

三：泛型

3.1泛型概述

在前面学习集合时，我们知道集合时可以存放任意对象的，只要把对象存储集合后，它们都会被向上转型提升为object类型。当我们要取出这些对象时必须进行类型强制转换，由object类型变为原来的类型。

3.2泛型的优缺点

不使用泛型：

- 好处：集合默认类型是object类，可以存储任意类型的数据
- 弊端：不安全，会引发异常，需要强转。

 public static void main(string[] args) {
         list list = new arraylist();
         list.add("小明");
         list.add("小红");
         for (int i = 0; i < list.size(); i++) {
         string s= (string)list.get(i) // 强转
             system.out.println(s);
         }
     }

使用泛型：

1. 好处：避免了类型强制转化的麻烦，存的什么类型，取出来的也是什么类型；代码运行之后才会抛出异常，写代码时不会报错
2. 弊端：泛型是什么类型只能存储什么类型的数据。

public static void main(string[] args) {
         list<string> list = new arraylist();// 规范了数据类型，只能放字符串!
         list.add("小明");
         list.add("小红");
         //stringlist.add(123);// 除了字符串以外的类型不能加，报错！
         for (int i = 0; i < list.size(); i++) {
             string s = list.get(i); // 不用再强转了
             system.out.println(s);
         }
     }

在上述的实例中，我们只能添加string类型的数据，否则编译器会报错。

3.3泛型的定义与使用

泛型类

定义格式：

修饰符 class 类名<泛型变量>{
 ​
 }
 // 注：泛型变量建议使用e、t、k、v

例如：

 public class box<t> {
  
   private t t;
  
   public void add(t t) {
     this.t = t;
   }
  
   public t get() {
     return t;
   }

参考示例：

注：在创建对象时确定泛型的类型

泛型方法

定义格式：

 修饰符 <泛型变量> 返回值的类型 方法名称(形参列表){
     //方法体
 }

注：含有泛型的方法，在调用的时候确定泛型的数据类型

传递什么类型的参数，泛型就是什么类型

参考示例：

泛型接口

定义格式：

 public interface 接口名<泛型类型> {
     
 }

使用方式1：定义接口的实现类，实现接口，并且指定接口的泛型

使用方式2：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。

就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。

下图接口同上图接口

3.4泛型的通配符

当使用泛型类或接口时，传递数据中，泛型类型不确定，可以通过通配符表示<?>表示。但一旦使用泛型的通配符后，只能使用object类中的共性方法，集合中元素自身方法无法使用。

通配符的基本使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用 ? ，？表示未知通配符

此时只能接收数据，不能往集合中存储数据。

【参考代码】

 package fanxing;
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.arraylist;
 import java.util.iterator;
 /*
     泛型的通配符：
         ？：代表数据类型
     使用方式：
         不能在创建对象时使用
         只能作为方法的传递参数使用
  */
 public class generic {
     public static void main(string[] args) {
 ​
         arraylist<integer>list01 = new arraylist<>();
         list01.add(123);
         list01.add(456);
 ​
         arraylist<string>list02 = new arraylist<>();
         list02.add("小明");
         list02.add("小红");
 // ......还有很多其它类型
         printarray(list01);
         printarray(list02);
         /*
             定义一个方法，能遍历所有类型的arraylist集合
             这时候我们不知道arraylist集合使用的是什么类型，可以使用泛型的通配符：？来代表数据类型
             注意：泛型没有继承的概念
          */
     }
 ​
     public static void printarray(arraylist<?>list){
         // 使用迭代器遍历集合
        iterator<?> it = list.iterator();
        while(it.hasnext()){
            object obj = it.next();//it.next()取出的元素是object类。object类 可以接收任意的数据类型
            system.out.println(obj);
        }
 ​
     }
 }

通配符高级使用-----受限泛型

之前设置泛型的时候，实际上是可以可以任意设置的，只要是类就可以设置。但在java的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式：类型名称<? extends e >对象名称 代表的泛型只能是e类型的子类/本身
• 意义：只能接收该类型及其子集

泛型的下限：

• 格式：类型名称<? super e >对象名称 代表的泛型只能是e类型的父类/本身
• 意义：只能接收该类型及其父类

比如：object类、string类、number类、integer类，其中number类是integer的父类。

四：java常见数据结构

集合是基于数据结构做出来的，不同的集合底层采用不同的数据结构。不同的数据结构，功能和作用是不一样的。

数据结构是指数据以什么方式组织在一起。不同的数据结构，增删查的性能是不一样的。

4.1栈

栈：stack，又称堆栈，它是运算受限的线性表，只能在栈的受限一端进行插入和删除操作。

特点：先进后出

4.2队列

队列：queue，简称队，它同栈由于也是运算受限的线性表，只能在表的一端进行插入操作，而在表的另一端进行删除操作。

特点：先进先出

4.3数组

数组：array，是个有序的元素序列，数组在内存中开辟一段连续的空间。

特点：

查询快：随机存取，通过索引可以快速访问元素

增删慢：静态分配内存，数组的长度是固定，存在空间闲置或者溢出现象；不适合进行插入和删除操作，需要移动大量元素。

4.4链表

链表：linked list，由一系列结点node组成，结点可以在运行时动态产生。每个节点包含两个部分：数据域(data)和指向下一个节点的指针域(next)。链表包括单链表和双向链表。

单链表：链表中只有一条链子，不能保证元素的顺序（存储和取出的顺序可能不一致）

双向链表：链表中只有两条链子，有一条链子专门记录元素的顺序，是一个有序的集合。

特点：

查询慢：链表的地址不是连续的，每次查询都要从头到尾进行遍历。

增删快：动态分派内存，增/删一个节点对于链表整体结构没有影响，增删操作效率高。

4.5红黑树

红黑树：r-b tree，全称是red-black tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(red)或黑(black)，它是一种弱平衡二叉树（weak avl）。

特点：

（1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（nil）是黑色。 [注意：这里叶子节点，是指为空(nil或null)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

注：以上数据结构可以结合所学过c语言数据结构

五：list集合体系

5.1list概述

list集合体系：添加元素，是有序，可重复，有索引的，大小可变。实际开发中常用的是arraylist集合。list集合体系包括以下几种：

• arraylist——添加元素，是有序，可重复，有索引的。
• linkedlist——添加元素，是有序，可重复，有索引的。
• vector——查询快，增删慢；运行效率慢、线程安全

list集合继承了collection集合的全部功能，同时因为list集合系列有索引，所以多了很多按照索引操作元素的方法：

 add(int index, e element) 根据索引添加元素
 get(int index) 根据索引获取元素
 remove(int index) 根据索引删除元素
 set(int index, e element) 根据索引修改该位置上的元素
 contains(e element)判断容器是否含有xxx东西
 clear() 清空集合中的元素
 size()计算集合的大小

【参考代码】

 package collection;
 ​
 import java.util.arraylist;
 import java.util.linkedlist;
 import java.util.list;
 ​
 public class testlist {
     public static void main(string[] args) {
         list<string>list = new arraylist();
         // 换成linkedist 下面的操作都能一样实现
 ​
         list.add("小明");
         list.add("小红");
         list.add("小蓝");
         list.add("小绿");
         list.add("小明");
 ​
 ​
 //        // 在某个索引位置往集合中添加元素
 //        list.add(2,"哈哈哈哈");
 //        system.out.println(list);
 ​
 //        // 删除集合中某个元素
 //        list.remove("小蓝");
 ​
 ​
 //        // 根据索引获取元素
 //        system.out.println(list.get(0));
 ​
 //        // 修改索引位置处的元素
 //        list.set(0,"小明很明白!");
 //        system.out.println(list.get(0));//小明很明白!
 ​
 //        // 计算列表的大小(长度)：
 //        system.out.println(list.size());
 ​
 //        //判断列表中是否有xxx false
 //        system.out.println(list.contains("小蓝"));
 ​
     }
 }

5.2list遍历方式

for循环

 // 遍历列表
 for (int i = 0; i < list.size(); i++) {
     string str = list.get(i);
     system.out.println(str);
 ​
 }

迭代器

 iterator<string>it = list.iterator(); // 创建一个list的迭代器
 ​
 while(it.hasnext()){// 判断有没有下一个元素
     string s = it.next(); 
     system.out.println(s);
 }

增强for

 list<string>list = new arraylist<>();
 ​
     for(string s : list){
         system.out.println(s);
     }

lambda表达式(了解)

 list.foreach(s -> {
       system.out.println(s);    
 });

5.3arraylist集合

arraylist集合存储的结构是数组结构，元素增删慢，查询快。最常用。

5.4linkedlist集合

linkedlist集合存储的结构是链表结构，方便元素的添加、删除操作。linkedlist是一个双向链表

linkedlist的特点：

底层是一个链表结构：查询慢，增删快

里边含有大量操作首尾元素的方法

注：使用linkedlist集合特有的方法，不能使用多态，命名要注意了！

实际开发中对一个集合的添加、删除操作经常涉及首尾操作，linkedlist提供了很多操作首尾元素方法

 public void addfirst(e e); 将指定的元素插到列表开头。
 public void addlat(e e); 将指定的元素插到列表结尾。 此方法等效于add()方法
 public void push(e e); 将元素推入此列表所示的堆栈。 此方法等效于addfirst()方法
 ​
 public e getfirst(); 返回此列表的第一个元素
 public e getlast(); 返回此列表的最后一个元素
 ​
 public e removefirst(); 移除并返回此列表的第一个元素
 public e removelast(); 移除并返回此列表的最后一个元素
 public e pop(e e); 入此列表所示的堆栈中弹出一个元素。
 ​
 public boolean isempty(); 如果列表为空 返回true

【参考代码】

 package collection;
 /*
 public void addfirst(e e); 将指定的元素插到列表开头。
 public void addlast(e e); 将指定的元素插到列表结尾。
 public void push(e e); 将元素推入此列表所示的堆栈。
 ​
 public e getfrist(); 返回此列表的第一个元素
 public e getlast(); 返回此列表的最后一个元素
 ​
 public e removefrist(); 移除并返回此列表的第一个元素
 public e removelast(); 移除并返回此列表的最后一个元素
 public e pop(e e); 入此列表所示的堆栈中弹出一个元素。
 ​
 public boolean isempty(); 如果列表为空 返回true
  */
 ​
 import java.util.linkedlist;
 import java.util.list;
 ​
 public class testlinkedlist {
     public static void main(string[] args) {
     show01();
     show02();
     show03();
     }
 ​
     /*
     public void addfirst(e e); 将指定的元素插到列表开头。
     public void addlast(e e); 将指定的元素插到列表结尾。
     public void push(e e); 将元素推入此列表所示的堆栈
      */
     public static void show01(){
 //        注：linkedlist特有的方法不能使用多态！
 //        list<string> list = new linkedlist<>(); 是不对的
         linkedlist<string>list = new linkedlist<>();
 ​
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
         system.out.println(list);//[a, b, c]
 ​
         list.addfirst("hhh");
         //public void push(e e); 将元素推入此列表所示的堆栈。 等效于addfirst()
         list.push("hhh");
         system.out.println(list);
 ​
         //public void lastfrist(e e); 将指定的元素插到列表结尾。 等效于add()
         list.addlast("com");
         system.out.println(list);
 ​
     }
     /*
     public e getfrist(); 返回此列表的第一个元素
     public e getlast(); 返回此列表的最后一个元素
      */
     public static void show02(){
         linkedlist<string>list = new linkedlist<>();
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
 //        list.clear(); // 清空集合中所有元素
         if(! list.isempty()){
             system.out.println(list.getfirst());//a
             system.out.println(list.getlast());//c
         }
     }
     /*
     public e removefrist(); 移除并返回此列表的第一个元素
     public e removelast(); 移除并返回此列表的最后一个元素
     public e pop(e e); 入此列表所示的堆栈中弹出一个元素。
      */
     public static void show03(){
         linkedlist<string>list = new linkedlist<>();
         // add()添加元素
         list.add("a");
         list.add("b");
         list.add("c");
         system.out.println(list.pop());
         //public e pop(e e); 入此列表所示的堆栈中弹出一个元素。 等效于 removefirst()
         //system.out.println(list.pop());   
         system.out.println(list.removefirst());//a
         system.out.println(list.removelast());//c
         system.out.println(list);//[b]
     }
 }

注：使用linkedlist集合特有的方法，不能使用多态。

5.5vector集合(了解)

数组结构实现，查询快，增删慢；

jdk1.0版本，运行效率慢、线程安全

【参考代码】

 package collection;
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.enumeration;
 import java.util.iterator;
 import java.util.vector;
 ​
 /*
     vector集合的使用
         存储结构：数组
  */
 public class vectortest {
     public static void main(string[] args) {
         // 创建集合
         vector<string>vector = new vector<>();
         // 添加元素
         vector.add("小明");
         vector.add("小红");
         vector.add("小蓝");
         system.out.println("元素个数"+ vector.size());
         // 判断
         system.out.println(vector.contains("小明"));
         system.out.println(vector.isempty());
         //删除
         vector.remove("小红");
         system.out.println(vector);
         //清空 clear(); vector.clear();
         // 遍历
         iterator<string> it = vector.iterator();
         while (it.hasnext()){
             string str = it.next();
             system.out.println(str);
         }
         //vector独有的遍历  使用枚举器
 //        enumeration<string>en = vector.elements();
 //        while (en.hasmoreelements()){
 //            string s = en.nextelement();
 //            system.out.println(s);
 //        }
     }
 }

六：set系列集合

6.1概述

set系列集合：添加的元素，是无序的，不重复的，无索引的(索引的操作不能用)。

——hashset：添加的元素，是无序的，不重复的，无索引的。

——linkedhashset：添加的元素，是有序的，不重复的，无索引的。

——treeset：不重复，无索引，按照大小默认升序排序！！(可排序集合)

遍历方式：由于set集合五索引，故没有for循环遍历，只有三种遍历。

6.2set集合存储元素不重复的原理

注：存储的字符串，integer等类型的数据，它们是java已经定义好了类，它们都重写了hashcode方法和equals方法，保证了元素的唯一性！

hashset 保证元素唯一性的原理

我们使用 set 集合都是需要去掉重复元素的, 如果在存储的时候逐个 equals() 比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用 equals() 方法的次数。

当 hashset 调用 add() 方法存储对象的时候, 先调用对象的 hashcode() 方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象，如果没有哈希值相同的对象就直接存入集合。如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行 equals() 比较,比较结果为 false 就存入, true 则不存。存储元素必需要重写hashcode方法和equals方法

6.3hashset存储自定义类型元素

给hashset中存放自定义的类型时，必需要重写hashcode方法和equals方法，建立自己的比较方式，才能保证hashset集合中对象的唯一性！

【参考代码】

person类：

 package collection;
 ​
 import java.util.objects;
 ​
 public class person {
     private string name;
     private int age;
 ​
     public person(string name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     // 用于打印
     @override
     public string tostring() {
         return "person{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
     // 重写hashcode方法和equals方法
     @override
     public boolean equals(object o) {
         if (this == o) return true;
         if (o == null || getclass() != o.getclass()) return false;
         person person = (person) o;
         return age == person.age && objects.equals(name, person.name);
     }
 ​
     @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;
     }
 }

 // 主控制台
 package collection;
 ​
 import java.util.hashset;
 import java.util.set;
 /*
     hashset存储自定义类型的元素
 ​
     set集合保证元素唯一性：
         存储的元素(string integer,...student,person...) 必须重写hashcode方法和equals方法
     要求：
         同名且同年龄视为同一个人噢
  */
 public class testhaxhset {
     public static void main(string[] args) {
         // 创建hashset集合存储person
         set<person>set = new hashset<>();
        //集合类存放对象的！
         // 创建对象(人)
 /*
        // 在没有重写hashcode方法和equals方法前，它们的哈希值都是不一样的,equals也为false 故没有重复
         person p1 = new person("小明",18);
         person p2 = new person("小明",19);
         person p3 = new person("小明",18);
         system.out.println(p1.hashcode());// 460141958
         system.out.println(p2.hashcode());// 1163157884
         system.out.println(p3.hashcode());// 1956725890
         system.out.println(p1.equals(p2));// false
         set.add(p1);
         set.add(p2);
         set.add(p3);
         system.out.println(set);// [person{name='小明', age=18}, person{name='小明', age=19}, person{name='小明', age=18}]
 */
         // 重写hashcode方法和equals方法之后set对象就唯一性了
         person p1 = new person("小明",18);
         person p2 = new person("小明",19);
         person p3 = new person("小明",18);
         set.add(p1);
         set.add(p2);
         set.add(p3);
         system.out.println(set);// [person{name='小明', age=19}, person{name='小明', age=18}]
 ​
     }
 }

6.4linkedhashset集合

我们知道hashset保证元素的唯一性，但存放进去的元素是无序的，那我们要保证有序，该怎么办好呢？

在hashset下面的一个子类java.util.linkedhashset。它是链表和哈希表组合的一个数据结构。

linkedhashset集合的特点：

底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表（记录元素的存储顺序），保证元素有序

具有可预知迭代顺序的 set 接口的哈希表和链接列表实现，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。

hashset与linkedhashset的区别：

【参考代码】

 package collection;
 ​
 import java.util.hashset;
 import java.util.linkedhashset;
 import java.util.set;
 ​
 public class testhashset {
     public static void main(string[] args) {
         set<string>set = new hashset<>();
         set.add("kkk");
         set.add("abc");
         set.add("abc");
         set.add("afterglow");
         system.out.println(set);//[afterglow, abc, kkk] 无序，不重复
 ​
         set<string>linkset = new linkedhashset<>();
         linkset.add("kkk");
         linkset.add("abc");
         linkset.add("abc");
         linkset.add("afterglow");
         system.out.println(linkset);//[kkk, abc, afterglow] 有序，不重复
     }
 ​
 }

6.5可变参数

使用前提：

如果我们定义一个方法需要接收多个参数，并且多个参数类型一致，我们可以对其做如下格式的简化：

修饰符 返回值类型 方法名(参数类型... 形参名){ }

这个写法完全等价于：

修饰符 返回值类型 方法名(参数类型[] 形参名){ } ,

后者在调用时必须传递数组，而前者可以直接传递数据类型。

可变参数原理：

可变参数底层是一个数组，根据参数个数不同，会创建不同长度的数组来存储这些参数。传递参数的个数，可以是0~n个

【参考代码】

 package collection;
 ​
 public class kebiancanshu {
     public static void main(string[] args) {
         int i =add(1,2,3,4);
         system.out.println(i);
     }
 ​
 //    // 两个数的和
 //    public static int add(int a, int b){
 //        return a + b;
 //    }
 //    // 三个数的和,要是多个一直往下写，很麻烦!
 //    public static int add(int a, int b, int c){
 //        return a + b +c;
 //    }
 ​
     /*    
         求0~n个整数的和
         数据类型已经确定：int
         参数个数不确定，可以使用可变参数
 ​
      */
     public static int add(int...arr){
 //        system.out.println(arr);// [i@1b6d3586 底层是一个数组
 //        system.out.println(arr.length);// 可变数组的长度，却决于你添加的个数
         int sum = 0;
         for (int i : arr){
            sum += i;
         }
         return sum;
     }
 }

注意事项：

• 一个方法的参数列表，只能有一个可变参数
• 如果方法的参数有多个，那么可变参数必须写在参数列表的末尾!

【示例代码】

     /*
     可变参数注意事项：
         一个方法的参数列表，只能有一个可变参数
         如果方法的参数有多个，那么可变参数必须写在参数列表的末尾!
      */
     //一个方法的参数列表，只能有一个可变参数
 //    public static void method01(int...a,string...b){ 报错!
 //         }
     
     //如果方法的参数有多个，那么可变参数必须写在参数列表的末尾!
     public static void method02(string b, double c, int...a){
         
     }

七：collections工具类

7.1常用方法：

• java.utils.collections 是集合工具类，用于对集合进行操作。常用功能如下：
• max() / min() ：求集合的最大 / 小值
• public static <t> boolenan addall(collect<t> c , t. . . elements) ：往集合中添加一些元素
• public static void shuffle(list<?> list) ：打乱集合顺序
• public static void sort(list<t> list) ：将集合按照默认规则（升序）进行排序
• public static void sort(list<t> list , comparator<? super t >) ;将集合按照指定的规则进行排序

【参考代码】

 public class test {
     public static void main(string[] args) {
         list<integer>list = new arraylist<integer>();
         list.add(120);
         list.add(20);
         list.add(220);
 ​
         // 求最值
         integer max = collections.max(list);
         system.out.println(max);
         integer min = collections.min(list);
         system.out.println(min);
         // 排序
         collections.sort(list);
         system.out.println(list);
         // 打乱顺序
         collections.shuffle(list); // 斗地主发牌
         system.out.println(list);
         // 不定参数添加
         collections.addall(list,456,789);
         system.out.println(list);//[220, 20, 120, 456, 789]
         
     }
 }

sort(list < t > list)使用

注意：

sort(list<t> list)使用前提：

排序的集合里边存储的元素，必须实现comparable接口，重写接口中的方法compareto定义排序的规则。在java中integer、string等等数据类型已经帮我们实现comparable接口并重写接口中的方法compareto了。如果要对自己定义的类进行排序，我们就要自己实现接口并重写compareto然后进行自定义排序规则。

comparable接口的排序规则：

自己(this) - 参数：升序，反之降序

【示例参考】：比较自定义类型

输出结果：

[student{name='小明', age=18}, student{name='小红', age=20}, student{name='小蓝', age=19}] [student{name='小明', age=18}, student{name='小蓝', age=19}, student{name='小红', age=20}]

1. sort(list< t > list , comparator<? super t >)
2. sort(list< t > list , comparator<? super t >)的使用：
3. comparator：相当于找一个第三放的裁判，按照comparator比较器里面重写的compare方法对元素进行排序比较

comparator的比较规则：

o1 - o2 升序

【参考代码】

 public class testcomparator {
     public static void main(string[] args) {
         list<integer> list = new arraylist<>();
         list.add(2);
         list.add(1);
         list.add(3);
 ​
         collections.sort(list, new comparator<integer>() {
             @override
             public int compare(integer o1, integer o2) {
                 return o1 - o2;// 升序
 //                return o2 - o1;// 降序
             }
         });
 ​
         system.out.println(list);// [1, 2, 3]
     }
 }

【示例参考】：比较自定义类型

comparator和comparable的区别

• comparable：自己（this）和别人（参数）比较，自己需要实现comparable接口，重写比较规则compareto方法
• comparator：相当于找一个第三放的裁判，按照comparator比较器里面重写的compare方法对元素进行排序比较

八：map集合

8.1概述

map集合的特点

1. map是一个双列集合，其中每个元素表示一个键值对作为<key，value> ;
2. map集合中的元素，key和value的数据类型可以相同，也可以不同
3. map集合中的元素，key不允许出现重复，value可以重复
4. map集合中的元素，key和value是一一对应的（映射）

注：映射由map<k，v>接口的实例表示，它不是继承自collection接口。

8.2map集合常见子类

map系列集合，常用子类的包括：

——hashmap

——linkedhashmap

【hashmap集合】

java.util.hashmap<k , v >集合implements map<k , v>接口.

hashmap集合的特点：

hashmap底层是哈希表：查询速度特别快

jdk1.8之前：数组 + 单项链表

jdk1.8之后：数组 + 单项链表/红黑树(链表长度超过8)：提高查询速

hashmap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

【linkedhashmap集合】

java.util.linkedhashmap<k , v >集合extends hashmap<k , v>集合。

linkedhashmap集合的特点：

linkedhashmap底层是哈希表 + 链表(保证迭代的顺序)

hashmap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

8.3map接口中的常用方法

map接口中定义了很多方法，常见如下：

• public v put(k key , v value)：把指定的键(key)和指定的值(value)添加到map集合中
• public v remove(object key)：把指定的key所对应的value从map集合中删除，返回被删元素的值
• public v get(object key)：在集合中获取指定key对应value的元素
• boolean containskey(object key)：判断集合中是否含有xxxkey
• boolean containsvalue(object key)：判断集合中是否含有xxxvalue
• public set<k> keyset()：把map中所有的key打包成（存储到）set集合返回
• public set< map.entry<k,v> > entryset()：获取map中所有key和value对象的集合（entry）存储在集合set中

【参考代码】

 package map;
 ​
 import java.util.hashmap;
 import java.util.map;
 ​
 public class test {
     public static void main(string[] args) {
         // 创建map集合对象，多态
         map<integer,string>map = new hashmap();
         map.put(11,"小明");
         map.put(22,"小红");
         map.put(33,"小蓝");
         map.put(44,"小绿");
         system.out.println(map);// {33=小蓝, 22=小红, 11=小明, 44=小绿} hashmap无序的
 ​
         map.remove(44);// 删除
         system.out.println(map);// {33=小蓝, 22=小红, 11=小明}
 ​
         system.out.println(map.size()); //大小 3
 ​
         system.out.println(map.containskey(33)); //true
         system.out.println(map.containsvalue("小蓝")); //true
 ​
         map.put(22,"小芳"); // {33=小蓝, 22=小芳, 11=小明} 若出现重复的key原来的数据会被顶替
         system.out.println(map);
 //        map.put(55,"小明");
 //        system.out.println(map);//是否被顶替却决于key，key映射value，而不是value映射key {33=小蓝, 22=小芳, 55=小明, 11=小明}
 ​
         system.out.println(map.keyset()); // [33, 22, 11] 把map中的key打包成set集合的形式
 ​
         system.out.println(map.get(33));// 小蓝  通过key查询value
     }
 }
 ​

8.4map的遍历

方法一:通过键找值的方式

• 使用map集合中的方法keyset()，把map集合里所有的key取出来，存放到一个set集合中
• 遍历set集合，获取map集合中的每一个key
• 通过map集合中的get(key)方法，找到value

【参考代码】

 package map;
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.hashmap;
 import java.util.iterator;
 import java.util.map;
 import java.util.set;
 ​
 public class test {
     public static void main(string[] args) {
         // 创建map集合对象
         map<string,integer>map = new hashmap<>();
         map.put("小明",18);
         map.put("小红",18);
         map.put("小蓝",19);
         map.put("小绿",20);
 ​
         //1. 使用map集合中的方法keyset()，把map集合里所有的key取出来，存放到一个set集合中\
         set<string> set = map.keyset();
         
         //2.遍历set集合，获取map集合中的每一个key
         /* 使用while遍历 */
         iterator <string> it = set.iterator();
         while (it.hasnext()){
             string key = it.next();
             
             //3.通过map集合中的get(key)方法，找到value
             integer value = map.get(key);
             system.out.println(key+"="+value);
         }
         system.out.println("-----------------------");
         /* 使用增强for遍历 */
         for(string key : set){
             //3.通过map集合中的get(key)方法，找到value
             integer value = map.get(key);
             
             system.out.println(key+"="+value);
         }
 ​
     }
 }

【总结】：

while——迭代器遍历：

     set<string> set = map.keyset();
     iterator <string> it = set.iterator();
     
     while (it.hasnext()){
         string key = it.next();
         integer value = map.get(key);
         system.out.println(key+"="+value);
     }

增强for遍历：

     set<string> set = map.keyset();
     
     for(string key : set){
         //3.通过map集合中的get(key)方法，找到value
         integer value = map.get(key);
         system.out.println(key+"="+value);
     }

方法二：键值对的方式遍历（更加面向对象）

把键值对当成一个整体遍历，增强for无法遍历，这个整体不是类型，因此java提供了方法：

map集合通过代码set<map.entry<k,v>> ，将键值对元素转成了一个实体类型，此时得到的是一个entry对象，类型是：map.entry<k,v>

• 通过map集合中的entryset()方法，把map集合中的多个entry对象取出来，存储到一个set集合中
• 此时键值对元素的类型就确定了，类型是键值对实体类型：map.entry<k,v>
• 接下来就可以用增强for遍历了

【参考代码】

 package map;
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.hashmap;
 import java.util.iterator;
 import java.util.map;
 import java.util.set;
 ​
 public class test {
     public static void main(string[] args) {
         // 创建map集合对象
         map<string,integer>map = new hashmap<>();
         map.put("小明",18);
         map.put("小红",18);
         map.put("小蓝",19);
         map.put("小绿",20);
 ​
         //1.通过map集合中的entryset()方法，把map集合中的多个entry对象取出来，存储到一个set集合中
         set<map.entry<string,integer>> set = map.entryset();
 ​
         //遍历set集合，获取每一个entry对象
         //使用迭代器遍历set集合
         iterator <map.entry<string,integer>> it = set.iterator();
         while (it.hasnext()){
             map.entry<string,integer>entry = it.next();
             // 使用entry对象中的getkey()和getvalue()方法获取键和值
             string key = entry.getkey();
             integer value = entry.getvalue();
             system.out.println(key+"="+value);
         }
         system.out.println("-----------");
 ​
         //增强for
         for(map.entry<string,integer> entry : set){
             // 使用entry对象中的getkey()和getvalue()方法获取键和值
             string key = entry.getkey();
             integer value = entry.getvalue();
             system.out.println(key+"="+value);
         }
     }
 }

【总结】：

while——迭代器遍历：

         set<map.entry<string,integer>> set = map.entryset();
 ​
         //遍历set集合，获取每一个entry对象
         //使用迭代器遍历set集合
         iterator <map.entry<string,integer>> it = set.iterator();
         while (it.hasnext()){
             map.entry<string,integer>entry = it.next();
             
             // 使用entry对象中的getkey()和getvalue()方法获取键和值
             string key = entry.getkey();
             integer value = entry.getvalue();
             system.out.println(key+"="+value);
         }

增强for遍历：

      //增强for
         for(map.entry<string,integer> entry : set){
             // 使用entry对象中的getkey()和getvalue()方法获取键和值
             string key = entry.getkey();
             integer value = entry.getvalue();
             system.out.println(key+"="+value);
         }

entry：表示一个key和value，它提供了获取对应key和value的方法：

public k getkey()：获取entry中的key

public v getvalue()：获取entry中的value

方法二图解：

8.5hashmap存储自定义类型键值

练习：每位学生(姓名，年龄)都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中，学生作为键，地址为值。

注：学生姓名、年龄相同则视为同一人

 package map;
 /*
     hashmap存储自定义类型键值：
     map集合保证key是唯一的：
         作为key元素，必须重写hashmap方法和equals方法，以保证key唯一
  */
 ​
 import java.util.hashmap;
 import java.util.set;
 ​
 public class hashmapsaveperson {
     public static void main(string[] args) {
         show01();
         /*
             上海-->hashmapsaveperson{name='小蓝', age=18}
             深圳-->hashmapsaveperson{name='小绿', age=18}
             北京-->hashmapsaveperson{name='小红', age=18}
             
             key唯一
          */
     }
     
         /*
            hashmap存储自定义类型键值：
              key:string类型
                string类重写hashcode方法和equals方法，可以保证key唯一
             value:person类型
                value可以重复（同名同年龄视为重复）
          */
 ​
 ​
     public static void show01(){
 ​
         // 创造hashmap集合
         hashmap<string,person> map = new hashmap<>();
         //往集合中添加元素
         map.put("深圳",new person("小明",18));
         map.put("上海",new person("小蓝",18));
         map.put("北京",new person("小红",18));
         map.put("深圳",new person("小绿",18));
         // 使用keyset()增强for遍历map集合
         set<string> set = map.keyset();
         for(string key:set){
             person value = map.get(key);
             system.out.println(key+"-->"+value);
             // 因为字符串类（java帮我们的）重写了hashcode方法和equals方法，所以键（key）是不能重复的
         }
         
     }
     
 }

person类：

下面这个是我们自己定义的key的类型，person类，上面例子的是string类：

 package map;
 /*
     hashmap存储自定义类型键值：
     map集合保证key是唯一的：
         作为key元素，必须重写hashmap方法和equals方法，以保证key唯一
  */
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.hashmap;
 import java.util.iterator;
 import java.util.map;
 import java.util.set;
 ​
 public class hashmapsaveperson {
     public static void main(string[] args) {
         
         show02();
     }
           /*
            hashmap存储自定义类型键值：
              key:person类型
                person就必须类重写hashcode方法和equals方法，来保证key唯一
             value:string类型
                value可以重复（同名同年龄视为重复）
          */
 ​
     public static void show02(){
         // 创造hashmap集合
         hashmap<person,string> map02 = new hashmap<>();
         // 往集合中添加元素
         map02.put(new person("张三",18),"法外狂徒");
         map02.put(new person("黄老板",18),"英国");
         map02.put(new person("陈奕迅",18),"中国");
         map02.put(new person("张三",18),"法外狂徒");
 ​
        // 使用迭代器遍历set集合中的entry对象
         set<map.entry<person,string>> set = map02.entryset();
         iterator<map.entry<person,string>> it = set.iterator();
         while(it.hasnext()){
 ​
             map.entry<person,string> entry = it.next();
 ​
             person key = entry.getkey();
             string value = entry.getvalue();
             system.out.println(key+"--->"+value);
         }
     }
 ​
 }

这里再介绍一下本例中entry对象遍历的图解，再次加深印象：

8.6linkedhashmap集合

我们知道hashmap保证key唯一，并且查询速度快，可是成对元素存放进去是没有顺序的(存和取的顺序可能不一致)，那我们要如何保证顺序呢？

在hashmap下面有个linkedhashmap（继承关系），它是链表（记录元素的顺序）和哈希表组合的一个数据存储结构，是个有序的集合

【参考代码】

 package map;
 ​
 import javax.swing.text.html.htmldocument;
 import java.util.*;
 ​
 public class test {
     public static void main(string[] args) {
 ​
         hashmap<string,string> map = new linkedhashmap<>();
         map.put("a","a");
         map.put("c","c");
         map.put("b","b");
         map.put("d","d");
         system.out.println(map);//{a=a, c=c, b=b, d=d}
     }
 }
 ​

输出结果：（存储和取出的顺序是一样的）

{a=a, c=c, b=b, d=d}

总结

看到这里，相信各位小伙伴们对java集合这一章节的知识有了进一步的理解，尤其是一些在之前学习时可能没有注意到的知识或者原理，没关系，这次都帮你总结在一起了。最后，感谢看到这里的你！愿你韶华不负，青春无悔！

注: 由于自己刚刚开始学习java不久，语言文字描述、技术等各方面还不是很好，如果文章有任何错误和建议，请各位大佬尽情评论留言！如果这篇文章对你有些许帮助，希望可爱亲切的您点个赞推荐一手，非常感谢啦

到此这篇关于java集合框架超详细小结的文章就介绍到这了,更多相关java集合框架内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！