一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象 的操作,就要对对象进行存储。另一方面,使用Array
存储对象方面具有
一些弊
端
,而
Java
集合就像一种容器,可以
动态地
把多个对象的引用放入容器中。
数组在内存存储方面的特点:
数组初始化以后,长度就确定了。
数组声明的类型,就决定了进行元素初始化时的类型
数组在存储数据方面的弊端:
数组初始化以后,长度就不可变了,不便于扩展
数组中提供的属性和方法少,不便于进行添加、删除、插入等操作,且效率不高。
同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。
---->
存储数据的特点单一
Java
集合类可以用于存储数量不等的多个
对象
,还可用于保存具有映射关系的
关联数组。
Java 集合可分为 Collection 和 Map 两种体系
Collection接口:单列数据,定义了存取一组对象的方法的集合
List:元素有序、可重复的集合
Set:元素无序、不可重复的集合
Map接口:双列数据,保存具有映射关系“key-value对”的集合
Collection 接口
Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法
既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。
JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)
实现。
在 Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都
当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合可以记住容
器中对象的数据类型。
Collection
接口方法
Iterator迭代器接口
使用
Iterator
接口遍历集合元素
Iterator
对象称为迭代器
(
设计模式的一种
)
,主要用于遍历
Collection
集合中的元素。
GOF
给迭代器模式的定义为:提供一种方法访问一个容器
(container)
对象中各个元
素,而又不需暴露该对象的内部细节。
迭代器模式,就是为容器而生。
类似于“公 交车上的售票员”、“火车上的乘务员”、“空姐”。 Collection
接口继承了
java.lang.Iterable
接口,该接口有一个
iterator()
方法,那么所 有实现了Collection
接口的集合类都有一个
iterator()
方法,用以返回一个实现了 Iterator接口的对象。
Iterator
仅用于遍历集合
,
Iterator
本身并不提供承装对象的能力。如果需要创建
Iterator
对象,则必须有一个被迭代的集合。
集合对象每次调用
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]);
} }
}
输出结果:
atguigu
atguigu
atguigu
atguigu
atguigu
null
null
null
null
null
Collection子接口之一:List接口
下面来看一个踩坑题吧
public class list{
public static void main(String[] args) {
List aList=new ArrayList();
aList.add(1);
aList.add(2);
aList.add(3);
aList.remove(2);
System.out.println(aList);
}
}
输出结果:[1, 2]
public class list{
public static void main(String[] args) {
List aList=new ArrayList();
aList.add(1);
aList.add(2);
aList.add(3);
aList.remove(2);
aList.remove(2);
System.out.println(aList);
}
}
错误:
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 2
at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64)
at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckIndex(Preconditions.java:70)
at java.base/jdk.internal.util.Preconditions.checkIndex(Preconditions.java:266)
at java.base/java.util.Objects.checkIndex(Objects.java:359)
at java.base/java.util.ArrayList.remove(ArrayList.java:504)
at list.main(list.java:313)
那么要如何删去2呢?很简单包装类:
public class list{
public static void main(String[] args) {
List aList=new ArrayList();
aList.add(1);
aList.add(2);
aList.add(3);
aList.remove(2);
aList.remove(new Integer(2));
System.out.println(aList);
}
}
输出结果:[1]
Set接口
Set接口是Collection的子接口,set接口没有提供额外的方法
Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个 Set 集合中,则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法
向
HashSet
中添加元素的过程:
当向
HashSet
集合中存入一个元素时,
HashSet
会调用该对象的
hashCode()
方法
来得到该对象的
hashCode
值,然后根据
hashCode
值,通过某种散列函数决定该对象
在
HashSet
底层数组中
的存储位置。(这个散列函数会与底层数组的长度相计算得到在
数组中的下标,并且这种散列函数计算还尽可能保证能均匀存储元素,越是散列分布,
该散列函数设计的越好)
如果两个元素的
hashCode()
值相等,会再继续调用
equals
方法,如果
equals
方法结果
为
true
,添加失败;如果为
false
,那么会保存该元素,但是该数组的位置已经有元素了,
那么会通过
链表的方式
继续链接。
如果两个元素的
equals()
方法返回
true
,但它们的
hashCode()
返回值不相 等,hashSet
将会把它们存储在不同的位置,但依然可以添加成功。
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
的扩容
当
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
什么时候进行扩容和树形化呢?
当
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
个,也会把树再转为链表
Collections工具类