面向对象编程
JDBC
Java
发展历程
JAVA
环境搭建
基础程序设计
Eclipse
使用
IDEA
使用
泛型
元注解
装箱
/
拆箱
枚举
可变参数
Lambda
表达式
Stream API
Date/Time API
Java
新特性
Oracle/MySQL
集合
IO/NIO
类库
多线程
异常处理
反射
网络
应用程序开发
设计模式
接 口
三大特性
类的结构
类
/
对象
数据
结构
排序
算法
数组
流程控制
运算符
数据类型
关键字
目录
Collection
接口方法
Iterator
迭代器接口
Collection
子接口一:
List
1
2
3
4
Java
集合框架概述
Collection
子接口二:
Set
Map
接口
5
6
Collections
工具类
7
11-1 Java
集合框述
11.1 Java
集合框架概述
一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象
的操作,就要对对象进行存储。另一方面,使用
Array
存储对象方面具有
一些弊
端
,而
Java
集合就像一种容器,可以
动态地
把多个对象的引用放入容器中。
数组在内存存储方面的特点:
数组初始化以后,长度就确定了。
数组声明的类型,就决定了进行元素初始化时的类型
数组在存储数据方面的弊端:
数组初始化以后,长度就不可变了,不便于扩展
数组中提供的属性和方法少,不便于进行添加、删除、插入等操作,且效率不高。
同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。
---->
存储数据的特点单一
Java
集合类可以用于存储数量不等的多个
对象
,还可用于保存具有映射关系的
关联数组。
集合的使用场景
Android
客户端
服务器端
数据库
将
Java
对象或
Java
对象构
成的
List
转换为
JSON
对象
或
JSON
数组
将
JSON
对象或
JSON
数组
转换为
Java
对象或
Java
对
象构成的
List
11.1 Java
集合框架概述:集合的使用场景
11.1 Java
集合框架概述
Java
集合可分为
Collection
和
Map
两种体系
Collection
接口:
单列数据,定义了存取一组对象的方法的集合
List
:
元素有序、可重复的集合
Set
:
元素无序、不可重复的集合
Map
接口:
双列数据,保存具有映射关系“
key-value
对”的集合
Collection
List
Set
Vector
ArrayList
LinkedList
HashSet
SortedSet
LinkedHashSet
Comparable
Comparator
Collections
Iterator
ListIterator
迭代器
对象排序接口
容器工具类
获取
JDK
提供的集合
API
位于
java.util
包内
TreeSet
获取
11.1 Java
集合框架概述:
Collection
接口继承树
Map
Hashtable
HashMap
SortedMap
Properties
LinkedHashMap
TreeMap
y = f(x);
y = x*2 + 3;
Collections
容器工具类
11.1 Java
集合框架概述:
Map
接口继承树
Comparable
Comparator
对象排序接口
11-2 Collection
接口方法
11.2 Collection
接口方法
Collection
接口
Collection
接口是
List
、
Set
和
Queue
接口的父接口,该接口里定义的方法
既可用于操作
Set
集合,也可用于操作
List
和
Queue
集合。
JDK
不提供此接口的任何直接实现,而是提供更具体的子接口
(
如:
Set
和
List)
实现。
在
Java5
之前,
Java
集合会丢失容器中所有对象的数据类型,把所有对象都
当成
Object
类型处理;从
JDK 5.0
增加了
泛型
以后,
Java
集合可以记住容
器中对象的数据类型。
11.2 Collection
接口方法
1
、添加
add(Object obj)
addAll(Collection coll)
2
、获取有效元素的个数
int size()
3
、清空集合
void clear()
4
、是否是空集合
boolean isEmpty()
5
、是否包含某个元素
boolean contains(Object obj)
:
是通过元素的
equals
方法来判断是否
是同一个对象
boolean containsAll(Collection c)
:
也是调用元素的
equals
方法来比
较的。拿两个集合的元素挨个比较。
11.2 Collection
接口方法
6
、删除
boolean remove(Object obj)
:
通过元素的
equals
方法判断是否是
要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll)
:
取当前集合的差集
7
、取两个集合的交集
boolean retainAll(Collection c)
:
把交集的结果存在当前集合中,不
影响
c
8
、集合是否相等
boolean equals(Object obj)
9
、转成对象数组
Object[] toArray()
10
、获取集合对象的哈希值
hashCode()
11
、遍历
iterator()
:
返回迭代器对象,用于集合遍历
11-3 Iterator
迭代器接口
11.3 Iterator
迭代器接口
使用
Iterator
接口遍历集合元素
Iterator
对象称为迭代器
(
设计模式的一种
)
,主要用于遍历
Collection
集合中的元素。
GOF
给迭代器模式的定义为:提供一种方法访问一个容器
(container)
对象中各个元
素,而又不需暴露该对象的内部细节。
迭代器模式,就是为容器而生。
类似于“公
交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection
接口继承了
java.lang.Iterable
接口,该接口有一个
iterator()
方法,那么所
有实现了
Collection
接口的集合类都有一个
iterator()
方法,用以返回一个实现了
Iterator
接口的对象。
Iterator
仅用于遍历集合
,
Iterator
本身并不提供承装对象的能力。如果需要创建
Iterator
对象,则必须有一个被迭代的集合。
集合对象每次调用
iterator()
方法都得到一个全新的迭代器对象
,默认游标都在集合
的第一个元素之前。
11.3 Iterator
迭代器接口
Iterator
接口的方法
在调用
it.next()
方法之前必须要调用
it.hasNext()
进行检测。若不调用,且
下一条记录无效,直接调用
it.next()
会抛出
NoSuchElementException
异常。
123
new
String(“AA”)
new Date()
1
2
new
Customer()
Iterator iterator = coll.iterator();
iterator
//hasNext():
判断是否还有下一个元素
while(iterator.hasNext()){
//next():
①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
iterator.next()
迭代器的执行原理
11.3 Iterator
迭代器接口
11.3 Iterator
迭代器接口
Iterator
接口
remove()
方法
Iterator
iter
=
coll
.iterator();
//
回到起点
while
(
iter
.hasNext()){
Object
obj
=
iter
.next();
if
(
obj
.equals(
"Tom"
)){
iter
.remove();
}
}
注意:
Iterator
可以删除集合的元素,但是是遍历过程中通过迭代器对象的
remove
方
法,不是集合对象的
remove
方法。
如果还未调用
next()
或在上一次调用
next
方法之后已经调用了
remove
方法,
再调用
remove
都会报
IllegalStateException
。
使用
foreach
循环遍历集合元素
Java 5.0
提供了
foreach
循环迭代访问
Collection
和数组。
遍历操作不需获取
Collection
或数组的长度,无需使用索引访问元素。
遍历集合的底层调用
Iterator
完成操作。
foreach
还可以用来遍历数组。
要遍历的
元素类型
要遍历的
结构名称
遍历后自定
义元素名称
11.3 Iterator
迭代器接口
11.3 Iterator
迭代器接口
练习:判断输出结果为何?
public class
ForTest {
public static void
main(String[]
args
) {
String[]
str
=
new
String[5];
for
(String
myStr
:
str
) {
myStr
=
"atguigu"
;
System.
out
.println(
myStr
);
}
for
(
int
i
= 0;
i
<
str
.
length
;
i
++) {
System.
out
.println(
str
[
i
]);
}
}
}
11-4 Collection
子接口之一:
List
接口
11.4 Collection
子接口之一:
List
接口
List
接口概述
鉴于
Java
中数组用来存储数据的局限性,我们通常使用
List
替代数组
List
集合类中
元素有序、且可重复
,集合中的每个元素都有其对应的顺序索引。
List
容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据
序号存取容器中的元素。
JDK API
中
List
接口的实现类常用的有:
ArrayList
、
LinkedList
和
Vector
。
11.4 Collection
子接口之一:
List
接口
List
接口方法
List
除了从
Collection
集合继承的方法外,
List
集合里添加了一些根据索引来
操作集合元素的方法。
void add(int index, Object ele):
在
index
位置插入
ele
元素
boolean addAll(int index, Collection eles):
从
index
位置开始将
eles
中
的所有元素添加进来
Object get(int index):
获取指定
index
位置的元素
int indexOf(Object obj):
返回
obj
在集合中首次出现的位置
int lastIndexOf(Object obj):
返回
obj
在当前集合中末次出现的位置
Object remove(int index):
移除指定
index
位置的元素,并返回此元素
Object set(int index, Object ele):
设置指定
index
位置的元素为
ele
List subList(int fromIndex, int toIndex):
返回从
fromIndex
到
toIndex
位置的子集合
11.4 Collection
子接口之一:
List
接口
List
实现类之一:
ArrayList
ArrayList
是
List
接口的典型实现类、主要实现类
本质上,
ArrayList
是对象引用的一个
”
变长
”
数组
ArrayList
的
JDK1.8
之前与之后的实现区别?
JDK1.7
:
ArrayList
像饿汉式,直接创建一个初始容量为
10
的数组
JDK1.8
:
ArrayList
像懒汉式,一开始创建一个长度为
0
的数组,当添加第一个元
素时再创建一个始容量为
10
的数组
Arrays.asList(…)
方法返回的
List
集合,既不是
ArrayList
实例,也不是
Vector
实例。
Arrays.asList(…)
返回值是一个固定长度的
List
集合
11.4 Collection
子接口之一:
List
接口
【面试题】
@Test
public void
testListRemove() {
List
list
=
new
ArrayList();
list
.add(1);
list
.add(2);
list
.add(3);
updateList(
list
);
System.
out
.println(
list
);
//
}
private static void
updateList(List
list
) {
list.remove(2);
}
11.4 Collection
子接口之一:
List
接口
List
实现类之二:
LinkedList
对于
频繁的插入或删除元素
的操作,建议
使用
LinkedList
类,效率较高
新增方法:
void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getLast()
Object removeFirst()
Object removeLast()
11.4 Collection
子接口之一:
List
接口
List
实现类之二:
LinkedList
LinkedList
:
双向链表
,内部没有声明数组,而是定义了
Node
类型的
first
和
last
,
用于记录首末元素。同时,定义内部类
Node
,作为
LinkedList
中保存数据的基
本结构。
Node
除了保存数据,还定义了两个变量:
prev
变量记录前一个元素的位置
next
变量记录下一个元素的位置
private static class
Node<
E
> {
E
item
;
Node<
E
>
next
;
Node<
E
>
prev
;
Node(Node<
E
> prev,
E
element, Node<
E
> next) {
this
.
item
= element;
this
.
next
= next;
this
.
prev
= prev;
}
}
11.4 Collection
子接口之一:
List
接口
List
实现类之三:
Vector
Vector
是一个古老的集合,
JDK1.0
就有了。大多数操作与
ArrayList
相同,区别之处在于
Vector
是线程安全的。
在各种
list
中,最好把
ArrayList
作为缺省选择。当插入、删除频繁时,
使用
LinkedList
;
Vector
总是比
ArrayList
慢,所以尽量避免使用。
新增方法:
void addElement(Object obj)
void insertElementAt(Object obj,int index)
void setElementAt(Object obj,int index)
void removeElement(Object obj)
void removeAllElements()
11.4 Collection
子接口之一:
List
接口
面试题:
请问
ArrayList/LinkedList/Vector
的异同?谈谈你的理解?
ArrayList
底层
是什么?扩容机制?
Vector
和
ArrayList
的最大区别
?
ArrayList
和
LinkedList
的异同
二者都线程不安全,相对线程安全的
Vector
,执行效率高。
此外,
ArrayList
是实现了基于动态数组的数据结构,
LinkedList
基于链表的数据结构。对于
随机访问
get
和
set
,
ArrayList
觉得优于
LinkedList
,因为
LinkedList
要移动指针。对于新增
和删除操作
add(
特指插入
)
和
remove
,
LinkedList
比较占优势,因为
ArrayList
要移动数据。
ArrayList
和
Vector
的区别
Vector
和
ArrayList
几乎是完全相同的
,
唯一的区别在于
Vector
是同步类
(synchronized)
,属于
强同步类。因此开销就比
ArrayList
要大,访问要慢。正常情况下
,
大多数的
Java
程序员使用
ArrayList
而不是
Vector,
因为同步完全可以由程序员自己来控制。
Vector
每次扩容请求其大
小的
2
倍空间,而
ArrayList
是
1.5
倍。
Vector
还有一个子类
Stack
。
11-5 Collection
子接口之二:
Set
接口
11.5 Collection
子接口之二:
Set
接口
Set
接口概述
Set
接口是
Collection
的子接口,
set
接口没有提供额外的方法
Set
集合不允许包含相同的元素,如果试把两个相同的元素加入同一个
Set
集合中,则添加操作失败。
Set
判断两个对象是否相同不是使用
==
运算符,而是根据
equals()
方法
11.5 Collection
子接口之二:
Set
接口
Set
实现类之一:
HashSet
HashSet
是
Set
接口的典型实现,大多数时候使用
Set
集合时都使用这个实现类。
HashSet
按
Hash
算法来存储集合中的元素,因此具有很好的存取、查找、删除
性能。
HashSet
具有以下特点:
不能保证元素的排列顺序
HashSet
不是线程安全的
集合元素可以是
null
HashSet
集合判断两个元素相等的标准
:
两个对象通过
hashCode()
方法比较相
等,并且两个对象的
equals()
方法返回值也相等。
对于存放在
Set
容器中的对象,
对应的类一定要重写
equals()
和
hashCode(Object
obj)
方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
11.5 Collection
子接口之二:
Set
接口
Set
实现类之一:
HashSet
向
HashSet
中添加元素的过程:
当向
HashSet
集合中存入一个元素时,
HashSet
会调用该对象的
hashCode()
方法
来得到该对象的
hashCode
值,然后根据
hashCode
值,通过某种散列函数决定该对象
在
HashSet
底层数组中
的存储位置。(这个散列函数会与底层数组的长度相计算得到在
数组中的下标,并且这种散列函数计算还尽可能保证能均匀存储元素,越是散列分布,
该散列函数设计的越好)
如果两个元素的
hashCode()
值相等,会再继续调用
equals
方法,如果
equals
方法结果
为
true
,添加失败;如果为
false
,那么会保存该元素,但是该数组的位置已经有元素了,
那么会通过
链表的方式
继续链接。
如果两个元素的
equals()
方法返回
true
,但它们的
hashCode()
返回值不相
等,
hashSet
将会把它们存储在不同的位置,但依然可以添加成功。
11.5 Collection
子接口之二:
Set
接口
Set
实现类之一:
HashSet
底层也是数组,初始容量为
16
,当如果使用率超过
0.75
,(
16*0.75=12
)
就会扩大容量为原来的
2
倍。(
16
扩容为
32
,依次为
64,128....
等)
11.5 Collection
子接口之二:
Set
接口
重写
hashCode()
方法的基本原则
在程序运行时,同一个对象多次调用
hashCode()
方法应该返回相同的值。
当两个对象的
equals()
方法比较返回
true
时,这两个对象的
hashCode()
方法的返回值也应相等。
对象中用作
equals()
方法比较的
Field
,都应该用来计算
hashCode
值。
11.5 Collection
子接口之二:
Set
接口
重写
equals()
方法的基本原则
以自定义的
Customer
类为例,何时需要重写
equals()
?
当一个类有自己特有的“逻辑相等”概念
,
当改写
equals()
的时候,总是
要改写
hashCode()
,根据一个类的
equals
方法(改写后),两个截然不
同的实例有可能在逻辑上是相等的,但是,根据
Object.hashCode()
方法,
它们仅仅是两个对象。
因此,违反了
“相等的对象必须具有相等的散列码”。
结论:复写
equals
方法的时候一般都需要同时复写
hashCode
方法。
通
常参与计算
hashCode
的对象的属性也应该参与到
equals()
中进行计算。
11.5 Collection
子接口之二:
Set
接口
Eclipse/IDEA
工具里
hashCode()
的重写
以
Eclipse/IDEA
为例,在自定义类中可以调用工具自动重写
equals
和
hashCode
。
问题:
为什么用
Eclipse/IDEA
复写
hashCode
方法,有
31
这个数字?
选择系数的时候要选择尽量大的系数。因为如果计算出来的
hash
地址越大,所谓的
“冲突”就越少,查找起来效率也会提高。(减少冲突)
并且
31
只占用
5bits,
相乘造成数据溢出的概率较小。
31
可以 由
i*31== (i<<5)-1
来表示
,
现在很多虚拟机里面都有做相关优化。(提高算法效
率)
31
是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结
果只能被素数本身和被乘数还有
1
来整除!
(
减少冲突
)
11.5 Collection
子接口之二:
Set
接口
Set
实现类之二:
LinkedHashSet
LinkedHashSet
是
HashSet
的子类
LinkedHashSet
根据元素的
hashCode
值来决定元素的存储位置,
但它同时使用双向链表维护元素的次序,这使得元素看起来是以
插入
顺序保存
的。
LinkedHashSet
插入性能略低于
HashSet
,
但在迭代访问
Set
里的全
部元素时有很好的性能。
LinkedHashSet
不允许集合元素重复。
null
AA
456
刘德华
LinkedHashSet
底层结构
Set
set
=
new
LinkedHashSet();
set
.add(
new
String(
"AA"
));
set
.add(456);
set
.add(456);
set
.add(
new
Customer(
"
刘德华
"
, 1001));
11.5 Collection
子接口之二:
Set
接口
11.5 Collection
子接口之二:
Set
接口
Set
实现类之三:
TreeSet
TreeSet
是
SortedSet
接口的实现类,
TreeSet
可以确保集合元素处于排序状态。
TreeSet
底层使用
红黑树
结构存储数据
新增的方法如下:
(
了解
)
Comparator comparator()
Object first()
Object last()
Object lower(Object e)
Object higher(Object e)
SortedSet subSet(fromElement, toElement)
SortedSet headSet(toElement)
SortedSet tailSet(fromElement)
TreeSet
两种排序方法:
自然排序
和
定制排序
。默认情况下,
TreeSet
采用自然排序。
11.5 Collection
子接口之二:
Set
接口
TreeSet
和后面要讲的
TreeMap
采用红黑树的存储结构
特点:有序,查询速度比
List
快
再具体就不说了,可以参看
http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html
,
对红黑树的讲解写得不错。
11.5 Collection
子接口之二:
Set
接口
排 序
—
自然排序
自然排序
:
TreeSet
会调用集合元素的
compareTo(Object obj)
方法来比较元
素之间的大小关系,然后将集合元素按升序
(
默认情况
)
排列
如果试图把一个对象添加到
TreeSet
时,则该对象的类必须实现
Comparable
接口。
实现
Comparable
的类必须实现
compareTo(Object obj)
方法,两个对象即通过
compareTo(Object obj)
方法的返回值来比较大小。
Comparable
的典型实现:
BigDecimal
、
BigInteger
以及所有的数值型对应的包装类:按它们对应的数值大小
进行比较
Character
:按字符的
unicode
值来进行比较
Boolean
:
true
对应的包装类实例大于
false
对应的包装类实例
String
:按字符串中字符的
unicode
值进行比较
Date
、
Time
:后边的时间、日期比前面的时间、日期大
11.5 Collection
子接口之二:
Set
接口
排 序
—
自然排序
向
TreeSet
中添加元素时,只有第一个元素无须比较
compareTo()
方法,后面添
加的所有元素都会调用
compareTo()
方法进行比较。
因为只有相同类的两个实例才会比较大小,所以向
TreeSet
中添加的应该是同
一个类的对象。
对于
TreeSet
集合而言,它
判断两个对象是否相等的唯一标准
是:两个对象通
过
compareTo(Object obj)
方法比较返回值。
当需要把一个对象放入
TreeSet
中,重写该对象对应的
equals()
方法时,应保
证该方法与
compareTo(Object obj)
方法有一致的结果:如果两个对象通过
equals()
方法比较返回
true
,则通过
compareTo(Object obj)
方法比较应返回
0
。
否则,让人难以理解。
11.5 Collection
子接口之二:
Set
接口
排 序
—
定制排序
TreeSet
的自然排序要求元素所属的类实现
Comparable
接口,如果元素所属的类没
有实现
Comparable
接口,或不希望按照升序
(
默认情况
)
的方式排列元素或希望按照
其它属性大小进行排序,则考虑使用定制排序。定制排序,通过
Comparator
接口来
实现。需要重写
compare(T o1,T o2)
方法。
利用
int compare(T o1,T o2)
方法,比较
o1
和
o2
的大小:如果方法返回正整数,则表
示
o1
大于
o2
;如果返回
0
,表示相等;返回负整数,表示
o1
小于
o2
。
要实现定制排序,需要将实现
Comparator
接口的实例作为形参传递给
TreeSet
的构
造器。
此时,
仍然只能向
TreeSet
中添加类型相同的对象
。否则发生
ClassCastException
异
常。
使用定制排序
判断两个元素相等的标准
是:通过
Comparator
比较两个元素返回了
0
。
11.5 Collection
子接口之二:
Set
接口
【面试题】
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set);
set.add(new Person(1001,"CC"));
System.out.println(set);
set.add(new Person(1001,"AA"));
System.out.println(set);
其中
Person
类中重写了
hashCode()
和
equal()
方法
11.5 Collection
子接口之二:
Set
接口
练习:在
List
内去除重复数字值,要求尽量简单
public static
List duplicateList(List
list
) {
HashSet
set
=
new
HashSet();
set
.addAll(
list
);
return new
ArrayList(
set
);
}
public static void
main(String[]
args
) {
List
list
=
new
ArrayList();
list
.add(
new
Integer(1));
list
.add(
new
Integer(2));
list
.add(
new
Integer(2));
list
.add(
new
Integer(4));
list
.add(
new
Integer(4));
List
list2
= duplicateList(
list
);
for
(Object
integer
:
list2
) {
System.
out
.println(
integer
);
}
}
11-6 Map
接口
Map
接口继承树
Map
Hashtable
HashMap
SortedMap
Properties
LinkedHashMap
TreeMap
11.6 Map
接口
Map
接口概述
Map
与
Collection
并列存在。用于保存具有
映射关系
的数据
:key-value
Map
中的
key
和
value
都可以是任何引用类型的数据
Map
中的
key
用
Set
来存放,
不允许重复
,即同一个
Map
对象所对应
的类,须重写
hashCode()
和
equals()
方法
常用
String
类作为
Map
的“键”
key
和
value
之间存在单向一对一关系,即通过指定的
key
总能找到
唯一的、确定的
value
Map
接口的常用实现类:
HashMap
、
TreeMap
、
LinkedHashMap
和
Properties
。其中,
HashMap
是
Map
接口使用频率最高的实现类
y=f(x)
(x1,y1) (x2,y2),…
11.6 Map
接口
AA
BB
CC
DD
90
90
56
78
KeySet
Values
4
个
Entry
Set
Collection
Set
11.6 Map
接口
11.6 Map
接口:常用方法
添加、删除、修改操作:
Object put(Object key,Object value)
:将指定
key-value
添加到
(
或修改
)
当前
map
对象中
void putAll(Map m):
将
m
中的所有
key-value
对存放到当前
map
中
Object remove(Object key)
:移除指定
key
的
key-value
对,并返回
value
void clear()
:清空当前
map
中的所有数据
元素查询的操作:
Object get(Object key)
:获取指定
key
对应的
value
boolean containsKey(Object key)
:是否包含指定的
key
boolean containsValue(Object value)
:是否包含指定的
value
int size()
:返回
map
中
key-value
对的个数
boolean isEmpty()
:判断当前
map
是否为空
boolean equals(Object obj)
:判断当前
map
和参数对象
obj
是否相等
元视图操作的方法:
Set keySet()
:返回所有
key
构成的
Set
集合
Collection values()
:返回所有
value
构成的
Collection
集合
Set entrySet()
:返回所有
key-value
对构成的
Set
集合
11.6 Map
接口
Map
map
=
new
HashMap();
//map.put(..,..)
省略
System.
out
.println(
"map
的所有
key:"
);
Set
keys
=
map
.keySet();
// HashSet
for
(Object
key
:
keys
) {
System.
out
.println(
key
+
"->"
+
map
.get(
key
));
}
System.
out
.println(
"map
的所有的
value
:
"
);
Collection
values
=
map
.values();
Iterator
iter
=
values
.iterator();
while
(
iter
.hasNext()) {
System.
out
.println(
iter
.next());
}
System.
out
.println(
"map
所有的映射关系:
"
);
//
映射关系的类型是
Map.Entry
类型,它是
Map
接口的内部接口
Set
mappings
=
map
.entrySet();
for
(Object
mapping
:
mappings
) {
Map.Entry
entry
= (Map.Entry)
mapping
;
System.
out
.println(
"key
是:
"
+
entry
.getKey() +
"
,
value
是:
"
+
entry
.getValue());
}
11.6 Map
接口
Map
实现类之一:
HashMap
HashMap
是
Map
接口
使用频率最高
的实现类。
允许使用
null
键和
null
值,与
HashSet
一样,不保证映射的顺序。
所有的
key
构成的集合是
Set:
无序的、不可重复的。所以,
key
所在的类要重写:
equals()
和
hashCode()
所有的
value
构成的集合是
Collection:
无序的、可以重复的。所以,
value
所在的类
要重写:
equals()
一个
key-value
构成一个
entry
所有的
entry
构成的集合是
Set:
无序的、不可重复的
HashMap
判断两个
key
相等的标准
是:两个
key
通过
equals()
方法返回
true
,
hashCode
值也相等。
HashMap
判断两个
value
相等的标准
是:两个
value
通过
equals()
方法返回
true
。
11.6 Map
接口
HashMap
的存储结构
JDK 7
及以前版本:
HashMap
是数组
+
链表结构
(
即为链地址法
)
JDK 8
版本发布以后:
HashMap
是数组
+
链表
+
红黑树实现。
Entry[] table
此图为
jdk7
情况
11.6 Map
接口
HashMap
的存储结构
JDK 7
及以前版本:
HashMap
是数组
+
链表结构
(
即为链地址法
)
JDK 8
版本发布以后:
HashMap
是数组
+
链表
+
红黑树实现。
此图为
jdk8
情况
11.6 Map
接口
HashMap
源码中的重要常量
DEFAULT_INITIAL_CAPACITY :
HashMap
的默认容量,
16
MAXIMUM_CAPACITY
:
HashMap
的最大支持容量,
2^30
DEFAULT_LOAD_FACTOR
:
HashMap
的默认加载因子
TREEIFY_THRESHOLD
:
Bucket
中链表长度大于该默认值,转化为红黑树
UNTREEIFY_THRESHOLD
:
Bucket
中红黑树存储的
Node
小于该默认值,转化为链表
MIN_TREEIFY_CAPACITY
:
桶中的
Node
被树化时最小的
hash
表容量。(当桶中
Node
的
数量大到需要变红黑树时,若
hash
表容量小于
MIN_TREEIFY_CAPACITY
时,此时应执行
resize
扩容操作这个
MIN_TREEIFY_CAPACITY
的值至少是
TREEIFY_THRESHOLD
的
4
倍。)
table
:
存储元素的数组,总是
2
的
n
次幂
entrySet
:
存储具体元素的集
size
:
HashMap
中存储的键值对的数量
modCount
:
HashMap
扩容和结构改变的次数。
threshold
:
扩容的临界值,
=
容量
*
填充因子
loadFactor
:
填充因子
HashMap
的存储结构:
JDK 1.8
之前
HashMap
的内部存储结构其实是
数组和链表的结合
。当实例化一个
HashMap
时,
系统会创建一个长度为
Capacity
的
Entry
数组,这个长度在哈希表中被称为容量
(Capacity)
,在这个数组中可以存放元素的位置我们称之为“桶”
(bucket)
,每个
bucket
都有自己的索引,系统可以根据索引快速的查找
bucket
中的元素。
每个
bucket
中存储一个元素,即一个
Entry
对象,但每一个
Entry
对象可以带一个引
用变量,用于指向下一个元素,因此,在一个桶中,就有可能生成一个
Entry
链。
而且
新添加的元素作为链表的
head
。
添加元素的过程:
向
HashMap
中添加
entry1(key
,
value)
,需要首先计算
entry1
中
key
的哈希值
(
根据
key
所在类的
hashCode()
计算得到
)
,此哈希值经过处理以后,得到在底层
Entry[]
数
组中要存储的位置
i
。如果位置
i
上没有元素,则
entry1
直接添加成功。如果位置
i
上
已经存在
entry2(
或还有链表存在的
entry3
,
entry4)
,则需要通过循环的方法,依次
比较
entry1
中
key
和其他的
entry
。如果彼此
hash
值不同,则直接添加成功。如果
hash
值不同,继续比较二者是否
equals
。如果返回值为
true
,则使用
entry1
的
value
去替换
equals
为
true
的
entry
的
value
。如果遍历一遍以后,发现所有的
equals
返回都
为
false,
则
entry1
仍可添加成功。
entry1
指向原有的
entry
元素。
HashMap
的存储结构:
JDK 1.8
之前
HashMap
的扩容
当
HashMap
中的元素越来越多的时候,
hash
冲突的几率也就越来越高,因为数组的
长度是固定的。所以为了提高查询的效率,就要对
HashMap
的数组进行扩容,而在
HashMap
数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算
其在新数组中的位置,并放进去,这就是
resize
。
那么
HashMap
什么时候进行扩容呢?
当
HashMap
中的元素个数超过数组大小
(
数组总大小
length,
不是数组中个数
size)*loadFactor
时 , 就 会 进 行 数 组 扩 容 ,
loadFactor
的默认 值
(
DEFAULT_LOAD_FACTOR
)
为
0.75
,这是一个折中的取值。也就是说,默认情况
下,数组大小
(
DEFAULT_INITIAL_CAPACITY
)
为
16
,那么当
HashMap
中元素个数
超过
16*0.75=12
(这个值就是代码中的
threshold
值,也叫做临界值)的时候,就把
数组的大小扩展为
2*16=32
,即扩大一倍,然后重新计算每个元素在数组中的位置,
而这是一个非常消耗性能的操作,
所以如果我们已经预知
HashMap
中元素的个数,
那么预设元素的个数能够有效的提高
HashMap
的性能。
HashMap
的存储结构:
JDK 1.8
HashMap
的内部存储结构其实是
数组
+
链表
+
树的结合
。当实例化一个
HashMap
时,会初始化
initialCapacity
和
loadFactor
,在
put
第一对映射关系
时,系统会创建一个长度为
initialCapacity
的
Node
数组,这个长度在哈希表
中被称为容量
(Capacity)
,在这个数组中可以存放元素的位置我们称之为
“桶”
(bucket)
,每个
bucket
都有自己的索引,系统可以根据索引快速的查
找
bucket
中的元素。
每个
bucket
中存储一个元素,即一个
Node
对象
,但每一个
Node
对象可以带
一个引用变量
next
,用于指向下一个元素,因此,
在一个桶中,就有可能
生成一个
Node
链。也可能是一个一个
TreeNode
对象
,每一个
TreeNode
对象
可以有两个叶子结点
left
和
right
,因此,在一个桶中,就有可能生成一个
TreeNode
树。而新添加的元素作为链表的
last
,或树的叶子结点。
HashMap
的存储结构:
JDK 1.8
那么
HashMap
什么时候进行扩容和树形化呢?
当
HashMap
中的元素个数超过数组大小
(
数组总大小
length,
不是数组中个数
size)*loadFactor
时 , 就会进行数组扩容 ,
loadFactor
的默认 值
(
DEFAULT_LOAD_FACTOR
)
为
0.75
,这是一个折中的取值。也就是说,默认
情况下,数组大小
(
DEFAULT_INITIAL_CAPACITY
)
为
16
,那么当
HashMap
中
元素个数超过
16*0.75=12
(这个值就是代码中的
threshold
值,也叫做临界值)
的时候,就把数组的大小扩展为
2*16=32
,即扩大一倍,然后重新计算每个元
素在数组中的位置,而这是一个非常消耗性能的操作,所以如果我们已经预知
HashMap
中元素的个数,那么预设元素的个数能够有效的提高
HashMap
的性能。
当
HashMap
中的其中一个链的对象个数如果达到了
8
个,此时如果
capacity
没有
达到
64
,那么
HashMap
会先扩容解决,如果已经达到了
64
,那么这个链会变成
树,结点类型由
Node
变成
TreeNode
类型。当然,如果当映射关系被移除后,
下次
resize
方法时判断树的结点个数低于
6
个,也会把树再转为链表。
HashMap
的存储结构:
JDK 1.8
关于映射关系的
key
是否可以修改?
answer
:不要修改
映射关系存储到
HashMap
中会存储
key
的
hash
值,这样就不用在每次查找时重新计算
每一个
Entry
或
Node
(
TreeNode
)的
hash
值了,因此如果已经
put
到
Map
中的映射关
系,再修改
key
的属性,而这个属性又参与
hashcode
值的计算,那么会导致匹配不上。
总结:
JDK1.8
相较于之前的变化:
1.HashMap map = new HashMap();//
默认情况下,先不创建长度为
16
的数组
2.
当首次调用
map.put()
时,再创建长度为
16
的数组
3.
数组为
Node
类型,在
jdk7
中称为
Entry
类型
4.
形成链表结构时,新添加的
key-value
对在链表的尾部(七上八下)
5.
当数组指定索引位置的链表长度
>8
时,且
map
中的数组的长度
> 64
时,此索引位置
上的所有
key-value
对使用红黑树进行存储。
11.6 Map
接口
面试题:
谈谈你对
HashMap
中
put/get
方法的认识?如果了解再谈谈
HashMap
的扩容机制?默认大小是多少?什么是负载因子
(
或填充比
)
?什么是吞吐临界值
(
或阈值、
threshold)
?
11.6 Map
接口
面试题:负载因子值的大小,对
HashMap
有什么影响
负载因子的大小决定了
HashMap
的数据密度。
负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长
,
造成查询或插入时的比较次数增多,性能会下降。
负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的
几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性
能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建
议初始化预设大一点的空间。
按照其他语言的参考及研究经验,会考虑将负载因子设置为
0.7~0.75
,此
时平均检索长度接近于常数。
11.6 Map
接口
Map
实现类之二:
LinkedHashMap
LinkedHashMap
是
HashMap
的子类
在
HashMap
存储结构的基础上,使用了一对双向链表来记录添加
元素的顺序
与
LinkedHashSet
类似,
LinkedHashMap
可以维护
Map
的迭代
顺序:迭代顺序与
Key-Value
对的插入顺序一致
11.6 Map
接口
HashMap
中的内部类:
Node
static class
Node<
K
,
V
>
implements
Map.Entry<
K
,
V
> {
final int
hash
;
final
K
key
;
V
value
;
Node<
K
,
V
>
next
;
}
LinkedHashMap
中的内部类:
Entry
static class
Entry<
K
,
V
>
extends
HashMap.Node<
K
,
V
> {
Entry<
K
,
V
>
before
,
after
;
Entry(
int
hash,
K
key,
V
value, Node<
K
,
V
> next) {
super
(hash, key, value, next);
}
}
11.6 Map
接口
Map
实现类之三:
TreeMap
TreeMap
存储
Key-Value
对时,需要根据
key-value
对进行排序。
TreeMap
可以保证所有的
Key-Value
对处于
有序
状态。
TreeSet
底层使用
红黑树
结构存储数据
TreeMap
的
Key
的排序:
自然排序
:
TreeMap
的所有的
Key
必须实现
Comparable
接口,而且所有
的
Key
应该是同一个类的对象,否则将会抛出
ClasssCastException
定制排序
:创建
TreeMap
时,传入一个
Comparator
对象,该对象负责对
TreeMap
中的所有
key
进行排序。此时不需要
Map
的
Key
实现
Comparable
接口
TreeMap
判断
两个
key
相等的标准
:两个
key
通过
compareTo()
方法或
者
compare()
方法返回
0
。
11.6 Map
接口
Map
实现类之四:
Hashtable
Hashtable
是个古老的
Map
实现类,
JDK1.0
就提供了。不同于
HashMap
,
Hashtable
是线程安全的。
Hashtable
实现原理和
HashMap
相同,功能相同。底层都使用哈希表结构,查询
速度快,很多情况下可以互用。
与
HashMap
不同,
Hashtable
不允许使用
null
作为
key
和
value
与
HashMap
一样,
Hashtable
也不能保证其中
Key-Value
对的顺序
Hashtable
判断两个
key
相等、两个
value
相等的标准,与
HashMap
一致。
11.6 Map
接口
Map
实现类之五:
Properties
Properties
类是
Hashtable
的子类,该对象用于处理属性文件
由于属性文件里的
key
、
value
都是字符串类型,所以
Properties
里的
key
和
value
都是字符串类型
存取数据时,建议使用
setProperty(String key,String value)
方法和
getProperty(String key)
方法
Properties
pros
=
new
Properties();
pros
.load(
new
FileInputStream(
"jdbc.properties"
));
String
user
=
pros
.getProperty(
"user"
);
System.
out
.println(
user
);
11-7 Collections
工具类
11.7 Collections
工具类
操作数组的工具类:
Arrays
Collections
是一个操作
Set
、
List
和
Map
等集合的工具类
Collections
中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,
还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作
:
(均为
static
方法)
reverse(List)
:
反转
List
中元素的顺序
shuffle(List)
:
对
List
集合元素进行随机排序
sort(List)
:
根据元素的自然顺序对指定
List
集合元素按升序排序
sort(List
,
Comparator)
:
根据指定的
Comparator
产生的顺序对
List
集合元素进行排序
swap(List
,
int
,
int)
:
将指定
list
集合中的
i
处元素和
j
处元素进行交换
11.7 Collections
工具类
Collections
常用方法
查找、替换
Object max(Collection)
:
根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection
,
Comparator)
:
根据
Comparator
指定的顺序,返回
给定集合中的最大元素
Object min(Collection)
Object min(Collection
,
Comparator)
int frequency(Collection
,
Object)
:
返回指定集合中指定元素的出现次数
void copy(List dest,List src)
:将
src
中的内容复制到
dest
中
boolean replaceAll(List list
,
Object oldVal
,
Object newVal)
:
使用新值替换
List
对象的所有旧值
11.7 Collections
工具类
Collections
常用方法:同步控制
Collections
类中提供了多个
synchronizedXxx()
方法,该方法可使将指定集
合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全
问题
补充:
Enumeration
Enumeration
接口是
Iterator
迭代器的
“
古老版本
”
Enumeration stringEnum = new StringTokenizer("a-b*c-d-e-g", "-");
while(stringEnum.hasMoreElements()){
Object obj = stringEnum.nextElement();
System.out.println(obj);
}
练 习
1.
请从键盘随机输入
10
个整数保存到
List
中,并按倒序、从大
到小的顺序显示出来
2.
请把学生名与考试分数录入到集合中,并按分数显示前三名
成绩学员的名字。
TreeSet(Student(name,score,id));
练 习
练 习
4.
对一个
Java
源文件中的关键字进行计数。
提示:
Java
源文件中的每一个单词,需要确定该单词是否是一个关键字。为
了高效处理这个问题,将所有的关键字保存在一个
HashSet
中。用
contains()
来测试。
File file = new File("Test.java");
Scanner scanner = new Scanner(file);
while(scanner.hasNext()){
String word = scanner.next();
System.out.println(word);
}