Java基础系列(13)- 集合
1|0集合框架概述
1|1集合框架与数组的对比及概述
一方面,面向对象语言对事情的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用Array存储对象方面具有一些弊端
,而Java集合就像一种容器,可以动态地
把多个对象地引用放入容器中。
集合、数组都是对多个数据进行存储操作的结构,简称Java容器
。
说明;此时的存储,主要是指能存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)
数组在存储多个数据封面的特点:
-
一旦初始化以后,它的长度就确定了。
-
数组一旦定义好,它的数据类型也就确定了。我们就只能操作指定类型的数据了。
比如:
String[] arr;int[] arr1;Object[] arr2;
数组在存储多个数据方面的特点:
- 一旦初始化以后,其长度就不可修改。
- 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
- 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
- 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。
1|2集合框架涉及到的API
Java 集合可分为Collection
和Map
两种体系
Collection
接口:单列数据,定义了存取一组对象的方法的集合List
:元素有序、可重复的集合 -->“动态”数组。(ArrayList、LinkedList、Vector)Set
:元素无序、不可重复的集合。(HashSet、LinkedHashSet、TreeSet)
Map
接口:双列数据,保存具有映射关系“key-value对”的集合。(HashMap、LinkedHashMap、TreeMap、Hashtable、Properties)
Collection接口继承树
Map接口继承树
2|0Collection 接口方法
- Collection 接口是List、Set 和Queue 接口的父接口,该接口里定义的方法既可用于操作Set 集合,也可用于操作List 和Queue 集合。
- JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。
- 在Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成Object 类型处理;从JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
2|1Collection常用方法
-
添加
add(Objec tobj)
addAll(Collection coll)
-
获取有效元素的个数
int size()
-
清空集合
void clear()
-
是否是空集合
boolean isEmpty()
-
是否包含某个元素
boolean contains(Object obj)
:是通过元素的equals方法来判断是否是同一个对象boolean containsAll(Collection c)
:也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
-
删除
boolean remove(Object obj)
:通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素boolean removeAll(Collection coll)
:取当前集合的差集
-
取两个集合的交集
boolean retainAll(Collection c)
:把交集的结果存在当前集合中,不影响c
-
集合是否相等
boolean equals(Object obj)
-
转成对象数组
Object[] toArray()
-
获取集合对象的哈希值
hashCode()
-
遍历
iterator()
:返回迭代器对象,用于集合遍历
Person类
测试类
3|0Iterator迭代器接口
- Iterator对象称为迭代器(设计模式的一种),主要用于遍历Collection 集合中的元素。
- GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。
迭代器模式,就是为容器而生
。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。 - Collection接口继承了
java.lang.Iterable
接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。 Iterator 仅用于遍历集合
,Iterator本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。集合对象每次调用iterator()方法都得到一个全新的迭代器对象
,默认游标都在集合的第一个元素之前。
3|1使用Iterator遍历Collection
3|2迭代器Iterator的执行原理
3|3Iterator遍历集合的两种错误写法
3|4Iterator迭代器remove()的使用
注意:
- Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
如果还未调用next()或在上一次调用next方法之后已经调用了remove方法,再调用remove都会报IllegalStateException
。
3|5新特性foreach循环遍历集合或数组
- Java 5.0 提供了foreach循环迭代访问Collection和数组。
- 遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
4|0Collection子接口之一:List接口
- 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
- List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有:
ArrayList、LinkedList和Vector
。
Collection接口:单列集合,用来存储一个一个的对象
- List接口:存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组
ArrayList
:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[] elementData
存储LinkedList
:对于频繁的插入、删除操作,使用此类效率比ArrayList
高;底层使用双向链表
存储Vector
:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData
存储
面试题:比较ArrayList、LinkedList、Vector三者的异同?
同:三个类都是实现了List接口,存储数据的特点相同:存储有序的、可重复的数据
不同:见上
4|1ArrayList的源码分析
- ArrayList是List 接口的典型实现类、主要实现类
- 本质上,ArrayList是对象引用的一个”变长”数组
jdk 7情况下
默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
结论:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity
jdk 8中ArrayList的变化:
小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
4|2LinkedList的源码分析
- 对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率较高
- LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。
LinkedList的源码分析:
4|3Vector的源码分析(基本弃用)
- Vector 是一个古老的集合,JDK1.0就有了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。
- 在各种list中,最好把
ArrayList
作为缺省选择。当插入、删除频繁时,使用LinkedList;Vector
总是比ArrayList慢,所以尽量避免使用。
4|4List接口中的常用方法测试
List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法。
void add(intindex, 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位置的元素为eleList subList(int fromIndex, int toIndex)
:返回从fromIndex到toIndex位置的子集合
List面试题
2
5|0Collection子接口之二:Set接口
- Set接口是Collection的子接口,
set接口没有提供额外的方法
- Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
- Set 判断两个对象是否相同不是使用
==
运算符,而是根据equals()
方法
5|1Set接口实现类的对比
Collection接口:单列集合,用来存储一个一个的对象
- Set接口:存储无序的、不可重复的数据 -->高中讲的“集合”
-
HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
- LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历对于频繁的遍历操作,LinkedHashSet效率高于HashSet.
-
TreeSet:可以按照添加对象的指定属性,进行排序。
-
5|2Set的无序性与不可重复性的理解
5|3HashSet中元素的添加过程
HashSet
是Set 接口
的典型实现,大多数时候使用Set 集合时都使用这个实现类。HashSet
按Hash 算法
来存储集合中的元素,因此具有很好的存取、查找、删除性能。HashSet
具有以下特点:不能保证元素的排列顺序HashSet不是线程安全的
- 集合元素可以是
null
- 底层也是数组,初始容量为
16
,当如果使用率超过0.75,(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等) HashSet
集合判断两个元素相等的标准:两个对象通过hashCode()
方法比较相等,并且
两个对象的equals()
方法返回值也相等。- 对于存放在Set容器中的对象,对应的类一定要重写
equals()
和hashCode(Object obj)
方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”
。
- 我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,
- 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断数组此位置上是否已经有元素:
- 如果此位置上没有其他元素,则元素a添加成功。 --->情况1
- 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值:
- 如果hash值不相同,则元素a添加成功。--->情况2
- 如果hash值相同,进而需要调用元素a所在类的equals()方法:
- equals()返回true,元素a添加失败
- equals()返回false,则元素a添加成功。--->情况2
- 对于添加成功的情况2和情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中,指向原来的元素。
jdk 8 :原来的元素在数组中,指向元素a
总结:七上八下 - HashSet底层:数组+链表的结构。
5|4关于hashCode()和equals()的重写
重写hashCode() 方法的基本原则
- 在程序运行时,同一个对象多次调用
hashCode()
方法应该返回相同的值。 - 当两个对象的
equals()
方法比较返回true
时,这两个对象的hashCode()
方法的返回值也应相等。 - 对象中用作
equals()
方法比较的Field
,都应该用来计算hashCode
值。
重写equals() 方法的基本原则
- 当一个类有自己特有的
“逻辑相等”
概念,当改写equals()
的时候,总是要改写hashCode()
,根据一个类的equals
方法(改写后),两个截然不同的实例有可能在逻辑上是相等的,但是,根据Object.hashCode()
方法,它们仅仅是两个对象。 - 因此,违反了
“相等的对象必须具有相等的散列码”
。 - 结论:复写
equals
方法的时候一般都需要同时复写hashCode
方法。通常参与计算hashCode
的对象的属性也应该参与到equals()
中进行计算。
Eclipse/IDEA工具里hashCode()的重写
以Eclipse/IDEA为例,在自定义类中可以调用工具自动重写equals和hashCode。问题:为什么用Eclipse/IDEA复写hashCode方法,有31这个数字?
- 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(减少冲突)
- 并且31只占用5bits,相乘造成数据溢出的概率较小。
- 31可以由
i*31== (i<<5)-1
来表示,现在很多虚拟机里面都有做相关优化。(提高算法效率) - 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除!(减少冲突)
要求
向Set(主要指:HashSet、LinkedHashSet)中添加的数据,其所在的类一定要重写hashCode()和equals()
- 要求:重写的hashCode()和equals()尽可能保持一致性:相等的对象必须具有相等的散列码
- 重写两个方法的小技巧:对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。
5|5LinkedHashSet的使用
LinkedHashSet
是HashSet的子类LinkedHashSet
根据元素的hashCode值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存
的。LinkedHashSet
插入性能略低于HashSet,但在迭代访问Set 里的全部元素时有很好的性能。LinkedHashSet
不允许集合元素重复。
5|6TreeSet的自然排序
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采用自然排序。TreeSet
和后面要讲的TreeMap
采用红黑树的存储结构- 特点:有序,查询速度比
List
快 - 自然排序:
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:后边的时间、日期比前面的时间、日期大
- 向TreeSet中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。
- 因为只有相同类的两个实例才会比较大小,所以向TreeSet中添加的应该是同一个类的对象。
- 对于
TreeSet
集合而言,它判断两个对象是否相等的唯一标准
是:两个对象通过compareTo(Object obj)
方法比较返回值。 - 当需要把一个对象放入
TreeSet
中,重写该对象对应的equals()
方法时,应保证该方法与compareTo(Object obj)
方法有一致的结果:如果两个对象通过equals()
方法比较返回true,则通过compareTo(Object obj)
方法比较应返回0。否则,让人难以理解。
5|7TreeSet的定制排序
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。
5|8TreeSet的课后练习
定义一个Employee
类。该类包含:private 成员变量 name、age、birthday,其中birthday为MyDate
类的对象。
并为每一个属性定义 getter、setter方法;
并重写 toString 方法输出name、age、birthday
MyDate
类包含:private 成员变量 year、month、day;并为每一个属性定义 getter、setter方法
创建该类的5个对象,并把这些对象放入TreeSet集合中(下一章:TreeSet需使用泛型来定义)
分别按以下两种方式对集合中的元素进行排序,并遍历输出
1)使 Employee 实现 Comparable 接口,并按 name 排序
2)创建 TreeSet 时传入 Comparator 对象,按生日日期的先后排序
MyDate类
Employee类
测试类
6|0Map接口
6|1Map接口及其多个实现类的对比
Map的实现类的结构:
Map:双列数据,存储key-value对的数据 ---类似于高中的函数:y = f(x)
- HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value
- LinkedHashMap:保证在遍历map元素时,可以按照添加的顺序实现遍历。
- 原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。
- 对于频繁的遍历操作,此类执行效率高于HashMap。
- TreeMap:保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序
- 底层使用红黑树
- Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
- Properties:常用来处理配置文件。key和value都是String类型
HashMap的底层:数组+链表 (jdk7及之前)
数组+链表+红黑树 (jdk 8)
6|2Map中存储的key-value的特点
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
接口使用频率最高的实现类
Map结构的理解
- Map中的
key
:无序的、不可重复的,使用Set存储所有的key ---> key所在的类要重写equals()和hashCode()
(以HashMap为例) - Map中的
value
:无序的、可重复的,使用Collection
存储所有的value --->value所在的类要重写equals()
- 一个键值对:key-value构成了一个
Entry对象
。 - Map中的
entry
:无序的、不可重复的,使用Set
存储所有的entry
6|3Map实现类之一: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
。
6|4HashMap的底层实现原理
JDK 7及以前版本:HashMap是数组+链表结构(即为链地址法)
JDK 8版本发布以后:HashMap是数组+链表+红黑树实现。
HashMap源码中的重要常量
HashMap在JDK7中的底层实现原理
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
的hash
值和其他的entry
的hash
值。 - 如果彼此
hash
值不同,则直接添加成功。 - 如果
hash
值相同,继续比较二者是否equals
。如果返回值为true
,则使用entry1
的value
去替换equals
为true
的entry
的value
。 - 如果遍历一遍以后,发现所有的
equals
返回都为false
,则entry1
仍可添加成功。entry1
指向原有的entry
元素。
- 向
HashMap在JDK8中的底层实现原理
HashMap
的内部存储结构其实是数组+链表+红黑树
的结合。当实例化一个HashMap
时,会初始化initialCapacity
和loadFactor
,在put
第一对映射关系时,系统会创建一个长度为initialCapacity
的Node
数组,这个长度在哈希表中被称为容量(Capacity
),在这个数组中可以存放元素的位置我们称之为“桶”(bucket
),每个bucket
都有自己的索引,系统可以根据索引快速的查找bucket
中的元素- 每个
bucket
中存储一个元素,即一个Node
对象,但每一个Node
对象可以带一个引用变量next
,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node
链。也可能是一个一个TreeNode
对象,每一个TreeNode
对象可以有两个叶子结点left
和right
,因此,在一个桶中,就有可能生成一个TreeNode
树。而新添加的元素作为链表的last
,或树的叶子结点。
那么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
个,也会把红黑树再转为链表。
关于映射关系的key
是否可以修改?answer:不要修改
映射关系存储到HashMap
中会存储key
的hash
值,这样就不用在每次查找时重新计算每一个Entry
或Node(TreeNode)
的hash
值了,因此如果已经put
到Map
中的映射关系,再修改key
的属性,而这个属性又参与hashcode
值的计算,那么会导致匹配不上。
总结
jdk8 相较于jdk7在底层实现方面的不同:
- new HashMap():底层没有创建一个长度为16的数组
- jdk 8底层的数组是:Node[],而非Entry[]
- 首次调用put()方法时,底层创建长度为16的数组
- jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。
- 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)
- 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储。
6|5LinkedHashMap的底层实现原理(了解)
LinkedHashMap
是HashMap
的子类- 在
HashMap
存储结构的基础上,使用了一对双向链表来记录添加元素的顺序 - 与
LinkedHashSet
类似,LinkedHashMap
可以维护Map
的迭代顺序:迭代顺序与Key-Value
对的插入顺序一致 HashMap
中的内部类:Node
LinkedHashMap
中的内部类:Entry
6|6Map中的常用方法
6|7TreeMap两种添加方式的使用
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。
6|8Hashtable
Hashtable
是个古老的Map
实现类,JDK1.0就提供了。不同于HashMap
,Hashtable
是线程安全的。Hashtable
实现原理和HashMap
相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。- 与
HashMap
不同,Hashtable
不允许使用null
作为key
和value
- 与
HashMap
一样,Hashtable
也不能保证其中Key-Value
对的顺序 Hashtable
判断两个key
相等、两个value
相等的标准,与HashMap
一致。
6|9Properties处理属性文件
Properties
类是Hashtable
的子类,该对象用于处理属性文件- 由于属性文件里的
key
、value
都是字符串类型,所以Properties 里的key和value都是字符串类型
- 存取数据时,建议使用
setProperty(String key,Stringvalue)
方法和getProperty(String key)
方法
1、新建jdbc.properties文件
如果jdbc.properties文件中写入为中文;
防止jdbc.properties出现中文乱码,可根据如下解决:
7|0Collections工具类
- 操作数组的工具类:
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 处元素进行交换
7|1Collections工具类常用方法的测试
7|2Collectors.groupingBy用法
Collectors.groupingBy根据一个或多个属性对集合
中的项目进行分组
数据准备
分组
- 按照类目分组:
- 按照几个属性拼接分组:
- 根据不同条件分组
多级分组
要实现多级分组,我们可以使用一个由双参数版本的Collectors.groupingBy工厂方法创 建的收集器,它除了普通的分类函数之外,还可以接受collector类型的第二个参数。那么要进 行二级分组的话,我们可以把一个内层groupingBy
传递给外层groupingBy
,并定义一个为流 中项目分类的二级标准。
按子组收集数据
- 求总数
- 求和
- 把收集器的结果转换为另一种类型
- 联合其他收集器
8|0Stream的使用
Stream(流)是一个来自数据源的元素队列并支持聚合操作
- 元素是特定类型的对象,形成一个队列。 - Java中的Stream并不会存储元素,而是按需计算。
- 数据源,流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
- 聚合操作,类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等。
和以前的Collection操作不同, Stream操作还有两个基础的特征: - Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
- 内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。
8|1Stream操作的三个步骤
1.创建 Stream
集合接口有两个方法来生成流:
stream()
− 为集合创建串行流。parallelStream()
− 为集合创建并行流。
2.中间操作
一个中间操作链,对数据源的数据进行处理。比如fifter
、distinct
、limit
、skip
、map
、sorted
3.终止操作
一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用。
比如:match
、findFirst
、count
、max
、min
、forEach
、reduce
、collect
8|2创建 Stream
一般我们使用的场景是对列表或数组操作。通过Collection的方法stream()和parallelStream()获取。
8|3中间操作
fifter(Predicate<? super T> predicate)
根据过滤条件,保留符合条件的元素
distinct ()
去重
limit(long maxSize)
返回前maxSize个元素
skip(long n)
调过前n个
sorted()/sorted(Comparator<? super T> comparator)
map/flatMap
- map(Function<? super T, ? extends R> mapper)
- mapToInt(ToIntFunction<? super T> mapper)
- mapToDouble(ToDoubleFunction<? super T> mapper)
- mapToLong(ToLongFunction<? super T> mapper)
- flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
- flatMapToInt(Function<? super T, ? extends IntStream> mapper)
- flatMapToLong(Function<? super T, ? extends LongStream> mapper)
- flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)
- map() 接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
- flatMap()接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
创建一个对象product
8|4终止操作
终止操作会从流的流水线生成结果。
anyMatch(Predicate<? super T> predicate);
检查是否有至少一个能够满足条件
allMatch(Predicate<? super T> predicate)
检查是否所有满足条件
noneMatch
findFirst
返回第一个
findAny
返回任意一个
count()总数/min最小数/max最大数
forEach
reduce
-
T reduce(T identity, BinaryOperator accumulator)
可以将流中元素反复结合起来,得到一个值,返回 T -
Optional reduce(BinaryOperator accumulator);
将流中元素反复结合起来,得到一个值, 返回 Optional
将流中元素反复结合起来,得到一个值, 返回 Optional
collect
将流转化为其他形式,常用的List,Set、Map、Collection
__EOF__

本文链接:https://www.cnblogs.com/dongye95/p/15836047.html
关于博主:评论和私信会在第一时间回复。或者直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
声援博主:如果您觉得文章对您有帮助,可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力!
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
· 面试官:你是如何进行SQL调优的?