Java集合类库

前言

文章内容输出来源：拉勾教育JAVA就业训练营
总目录跳转链接：总目录
如有侵权请联系本人
邮箱:xiaogueika@tom.com

---

---

一、集合的概述

上面是我自己归类的~下面是偷来的图 /滑稽 下面比较全面，看不懂的话就看我上面的图

1 集合的由来

• 当需要在Java程序中记录单个数据内容时，则声明一个变量。
• 当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
• 当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
• 当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。
• 当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

2 集合的框架结构

• Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。
• 其中Collection集合中存取元素的基本单位是：单个元素。
• 其中Map集合中存取元素的基本单位是：单对元素。
  

二、Collection集合（重点）

1 基本概念

• java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法
  既可用于操作List集合，也可用于操作Queue集合和Set集合。
  Collection集合API

2 常用的方法（练熟、记住）

方法声明	功能介绍
boolean add(E e);	向集合中添加对象
boolean addAll(Collection<? extends E> c)	用于将参数指定集合c中的所有元素添加到当前集合中
boolean contains(Object o);	判断是否包含指定对象
boolean containsAll(Collection<?> c)	判断是否包含参数指定的所有对象
boolean retainAll(Collection<?> c)	保留当前集合中存在且参数集合中存在的所有对象
boolean remove(Object o);	从集合中删除对象
boolean removeAll(Collection<?> c)	从集合中删除参数指定的所有对象
void clear();	清空集合
int size();	返回包含对象的个数
boolean isEmpty();	判断是否为空
boolean equals(Object o)	判断是否相等
int hashCode()	获取当前集合的哈希码值
Object[] toArray()	将集合转换为数组
Iterator iterator()	获取当前集合的迭代器

PS： 数组转换为集合

方法声明	功能介绍
Arrays.asList(T… a)	将数组转换为集合

三、Iterator接口（重点）

1 基本概念

• java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。
• java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象。
• Iterator接口API

2 常用的方法

方法声明	功能介绍
boolean hasNext()	判断集合中是否有可以迭代/访问的元素
E next()	用于取出一个元素并指向下一个元素
void remove()	用于删除访问到的最后一个元素

3 Iterator接口案例题目：

如何使用迭代器实现toString方法的打印效果？

        //3.使用送代器来模拟toString方法的打印效果
        StringBuffer sb1 = new StringBuffer();
        sb1.append("[");
        Iterator iterator2 = c1.iterator();
        while (iterator2.hasNext()){
            //当获硬的元素是最后一个元素时，则拼接元素加中括号
            Object obj = iterator2.next();
            //否则拼接元素加逗号加空格
            if(iterator2.hasNext()){
                sb1.append(obj).append(",").append(" ");
            } else {
                sb1.append(obj).append("]");
            }
        }
        System.out.println("c1 = " + sb1);

四、foreach循环（只能遍历，不能修改）

1 基本概念

• Java5推出了增强型for循环语句，可以应用数组和集合的遍历。
• 是经典迭代的“简化版“。

2 语法格式

for(元素类型 变量名 : 数组/集合名称) {
	循环体;
}

3 执行流程

• 不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止。

五、List集合（重中之重）

1 基本概念

• java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。（有序）
  该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
• 其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
  初始长度为10。如果长度不够，新的容量会是原容量的1.5倍
• 其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。
• 可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
• 其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。（被Deque取代了）
• 其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低，以后开发中基本不用。（过时了，被ArrayList取代了）
  初始长度为10。如果长度不够，新的容量会是原容量的2倍
• List集合API

2 常用的方法

方法声明	功能介绍
void add(int index, E element)	向集合中指定位置添加元素
boolean addAll(int index, Collection<? extends E> c)	向集合中添加所有元素
E get(int index)	从集合中获取指定位置元素
int indexOf(Object o)	查找参数指定的对象
int lastIndexOf(Object o)	反向查找参数指定的对象
E set(int index, E element)	修改指定位置的元素
E remove(int index)	删除指定位置的元素
List subList(int fromIndex, int toIndex)	用于获取子List(同用一块内存）

• 案例题目

准备一个Stack集合，将数据11、22、33、44、55依次入栈并打印，然后查看栈顶元素并打印， 然后将栈中所有数据依次出栈并打印。
再准备一个Stack对象，将数据从第一个栈中取出来放入第二个栈中，然后再从第二个栈中取出并 打印。

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        //1.准备一个Stack类型的对象并打印
        Stack s1 = new Stack();
        Stack s2 = new Stack();
        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);
        System.out.println("----------------------------");
        //2.将数据11、22、33、44、55次入徒并打印
        for (int i = 0; i < 5; i++) {
            Object obj = s1.push((i+1)*11);
            System.out.println("入栈的元素是:" + obj);
            //System.out.println("栈中的元素有：" + s1);
        }
        System.out.println("----------------------------");
        //3.查看徒顶元素值并打印
        Object obj2 = s1.peek();
        System.out.println("获取到的栈顶元素是：" + obj2);
        System.out.println("----------------------------");
        //4.对楼中所有元素次出徒并打印
        int len =s1.size();
        for (int i = 0; i < len; i++) {
            Object to =s1.pop();
            System.out.println("出栈的元素是：" + to);
            s2.push(to);
        }
        System.out.println("----------------------------");
        //5.最终打印楼中的所有元素
        //System.out.println("s1 = " + s1);
        for (int i = 0; i < len; i++) {
            Object to =s2.pop();
            System.out.println("出栈的元素是：" + to);
        }
    }
}

六、Queue集合（重点）

1 基本概念

• java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。
• 该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)。
• 该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。
• Queue集合API

2 常用的方法

方法声明	功能介绍
boolean offer(E e)	将一个对象添加至队尾，若添加成功则返回true
E poll()	从队首删除并返回一个元素
E peek()	返回队首的元素（但并不删除）

• 案例题目

准备一个Queue集合，将数据11、22、33、44、55依次入队并打印，然后查看队首元素并打印， 然后将队列中所有数据依次出队并打印。

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static void main(String[] args) {
        //1.准备一个Queue集合并打印
        Queue queue = new LinkedList();
        System.out.println("队列中的元素有：" + queue);
        System.out.println("----------------------------");
        //2.将数据11、22、33、44、55依次不队并打印
        for (int i = 0; i < 5; i++) {
            boolean b1 = queue.offer((i+1)*11);
           // System.out.println("b1 = " + b1);
            System.out.println("队列中的元素有：" + queue);
        }
        System.out.println("----------------------------");
        //3.然后查看队首元素并打印
        System.out.println("对首元素是：" + queue.peek());
        System.out.println("----------------------------");
        //4.然后河队列中所有数据纸次出队并打印。
        int len = queue.size();
        for (int i = 0; i < len; i++) {
            System.out.println("出队的元素是" + queue.poll());
        }
        System.out.println("----------------------------");
        //5.查看队列中最终的元素
        System.out.println("队列中的元素有：" + queue);
    }
}

七、泛型机制（熟悉）

1 基本概念

• 通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
• 为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。
• 泛型只在编译时期有效，在运行时期不区分是什么类型。

2 底层原理

• 泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。
• 如：

   //其中i叫做形式参数，负责占位 
   //int i = 10; 
   //int i = 20; 
   public static void show(int i) { 
  	 ... 
   } 
   //其中10叫做实际参数，负责给形式参数初始化
   show(10);
   show(20);
   System.out.println("--------------------------------------")
    //其中E叫做形式参数，负责占位
   //E = String;
   //E = Integer;
   public interface List {
  	  ... 
   }
   //其中String叫做实际参数
   List lt1 = ...;
   List lt2 = ...;
  

3 自定义泛型接口

泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等。

4 自定义泛型类

• 泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等。
• 实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型。
• 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
• 子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

5 自定义泛型方法

• 泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化。

• 泛型方法的格式：
  [访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) {
方法体;
}

• 在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法

6 泛型在继承上的体现

• 如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！
  比如：String是Object的子类，但是List并不是List的子类。

7 通配符的使用

• 有时候我们希望传入的类型在一个指定的范围内，此时就可以使用泛型通配符了。
  如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传入。

• 泛型中有三种通配符形式：

  1. <?> 无限制通配符：表示我们可以传入任意类型的参数。
  2. <? extends E> 表示类型的上界是E，只能是E或者是E的子类。不支持元素的添加操作
  3. <? super E> 表示类型的下界是E，只能是E或者是E的父类。

八、Set集合（熟悉）

1 基本概念

• java.util.Set集合是Collection集合的子集合，与List集合平级。
• 该集合中元素没有先后放入次序，且不允许重复。
• 该集合的主要实现类是：HashSet类 和TreeSet类以及LinkedHashSet类。
• 其中HashSet类的底层是采用哈希表进行数据管理的。
• 其中TreeSet类的底层是采用红黑树进行数据管理的。
• 其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
• Set集合API

2 常用的方法

• 参考Collection集合中的方法即可！
• 案例题目

  准备一个Set集合指向HashSet对象，向该集合中添加元素"two"并打印，再向集合中添加元素"one"并打印，再向集合中添加元素"three"并打印，再向集合中添加"one"并打印。

3 元素放入HashSet集合的原理

• 使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。
• 若该位置没有元素，则将该元素直接放入即可。
• 若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
• 若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。
• 若相等则添加元素失败，否则将元素直接放入即可。
• 思考：为什么要求重写equals方法后要重写hashCode方法呢？
• 解析：
  当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元
  素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元
  素比较即可，从而提高效率并避免重复元素的出现。
  

4 TreeSet集合的概念

• 二叉树主要指每个节点最多只有两个子节点的树形结构。
• 满足以下3个特征的二叉树叫做有序二叉树。

1. 左子树中的任意节点元素都小于根节点元素值；
2. 右子树中的任意节点元素都大于根节点元素值；
3. 左子树和右子树的内部也遵守上述规则；

• 由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使
• 用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
• 比较元素大小的规则有两种方式：
  1. 使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
  2. 使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
  3. 自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；
     

PS：比较器写法（T : 比较的引用对象类型/类名）

//第一种
//匿名内部类: 接口/父类类型 引用变量名 = new 接口/父类类型(){方法的重写}
Comparator<T> comparator = new Comparator<T>() {
	@Override
	public int compare(T t1, T t2) {//t1表示新增加的对象,t2表示集合中已有的对象
		return t1.比较内容 - t2.比较内容;
	}
};
//第二种
//从Java8开始支Lambda表达式：（参数列表）->{方法}
Comparator<T> comparator =(T t1 ,T t2) ->{return t1.比较内容 - t2.比较内容;};

九、Map集合（重点）

1 基本概念

• java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
  K - 此映射所维护的键(Key)的类型，相当于目录。
  V - 映射值(Value)的类型，相当于内容。
• 该集合中key是不允许重复的，而且一个key只能对应一个value。
• 该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
• 其中HashMap类的底层是采用哈希表进行数据管理的。
• 其中TreeMap类的底层是采用红黑树进行数据管理的。
• 其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
• 其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
• 其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。
• Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。
• 经常用于根据key检索value的业务场景。
• Map集合API

2 常用的方法

方法声明	功能介绍
V put(K key, V value)	将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对应的Value， 返回值为该Key原来所对应的Value，若没有则返回null
V get(Object key)	返回与参数Key所对应的Value对象，如果不存在则返回null
boolean containsKey(Object key);	判断集合中是否包含指定的Key
boolean containsValue(Object value);	判断集合中是否包含指定的Value
V remove(Object key)	根据参数指定的key进行删除
Set keySet()	返回此映射中包含的键的Set视图
Collection values()	返回此映射中包含的值的Set视图
Set<Map.Entry<K,V>> entrySet()	返回此映射中包含的映射的Set视图

3 元素放入HashMap集合的原理

• 使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置。
• 若该位置没有元素，则将该键值对直接放入即可。
• 若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
• 若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较。
• 若相等则将对应的value修改，否则将键值对直接放入即可。

4 相关的常量

• DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。
• DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75。
• threshold：扩容的临界值，该数值为：容量*填充因子，也就是12。
• TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8。
• MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64。

十、Collections

1 基本概念

• java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。
• Collections工具类API

2 常用的方法

方法声明	功能介绍
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)	根据元素的自然顺序返回给定集合的最大元素
static T max(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引发的顺序返回给定集合的最大元素
static <T extends Object & Comparable<?super T>> T min(Collection<? extends T> coll)	根据元素的自然顺序返回给定集合的最小元素
static T min(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引发的顺序返回给定集合的最小元素
static void copy(List<? super T> dest, List<? extends T> src)	将一个列表中的所有元素复制到另一个列表中

方法声明	功能介绍
static void reverse(List<?> list)	反转指定列表中元素的顺序
static void shuffle(List<?> list)	使用默认的随机源随机置换指定的列表
static <T extends Comparable<? super T>> void sort(List list)	根据其元素的自然顺序将指定列表按升序排序
static void sort(List list, Comparator<? super T> c)	根据指定比较器指定的顺序对指定列表进行排序
static void swap(List<?> list, int i, int j)	交换指定列表中指定位置的元素

归纳总结

1. 集合的概述
   集合的由来、图（重点）

2. Collection集合（重点）
   常用的方法
3. Iterator接口（重点）
   概念、遍历集合、常用的方法
4. foreach结构（重点）
   Java5新增的内容，是迭代器的简化版
5. List集合（重点）
   概念、常用实现类、常用的方法
6. Queue集合（重点）
   概念、常用实现类、常用的方法
7. 泛型机制（熟悉）
   概念和本质、自定义泛型接口、类、方法，继承方面的体现，通配符
8. Set集合（熟悉）
   概念、主要实现类、常用的方法、两种方式指定排序的规则(自然排序，比较器)
9. Map集合（重点）
   概念、主要实现类、常用的方法
10. Collections类（熟悉）
    概念和常用的方法