前言
文章内容输出来源:拉勾教育JAVA就业训练营
总目录跳转链接:总目录
如有侵权请联系本人
邮箱:[email protected]
Java集合类库
一、集合的概述
上面是我自己归类的~下面是偷来的图 /滑稽 下面比较全面,看不懂的话就看我上面的图
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类也可以传入。 -
泛型中有三种通配符形式:
- <?> 无限制通配符:表示我们可以传入任意类型的参数。
- <? extends E> 表示类型的上界是E,只能是E或者是E的子类。不支持元素的添加操作
- <? 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个特征的二叉树叫做有序二叉树。
- 左子树中的任意节点元素都小于根节点元素值;
- 右子树中的任意节点元素都大于根节点元素值;
- 左子树和右子树的内部也遵守上述规则;
- 由于
TreeSet
集合的底层采用红黑树进行数据的管理,当有新元素插入到TreeSet
集合时,需要使 - 用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
- 比较元素大小的规则有两种方式:
- 使用元素的自然排序规则进行比较并排序,让元素类型实现
java.lang.Comparable
接口; - 使用比较器规则进行比较并排序,构造
TreeSet
集合时传入java.util.Comparator
接口; - 自然排序的规则比较单一,而比较器的规则比较多元化,而且比较器优先于自然排序;
- 使用元素的自然排序规则进行比较并排序,让元素类型实现
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) | 交换指定列表中指定位置的元素 |
归纳总结
- 集合的概述
集合的由来、图(重点)
Collection
集合(重点)
常用的方法Iterator
接口(重点)
概念、遍历集合、常用的方法foreach
结构(重点)
Java5新增的内容,是迭代器的简化版List
集合(重点)
概念、常用实现类、常用的方法Queue
集合(重点)
概念、常用实现类、常用的方法- 泛型机制(熟悉)
概念和本质、自定义泛型接口、类、方法,继承方面的体现,通配符 Set
集合(熟悉)
概念、主要实现类、常用的方法、两种方式指定排序的规则(自然排序,比较器)Map
集合(重点)
概念、主要实现类、常用的方法Collections
类(熟悉)
概念和常用的方法