Java——集合(超详细超级全)

集合

Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
在这里主要讲一些我们平常很常用的一些接口和一些实现类。

Java 集合可分为 Collection 和 Map 两种体系:

Collection接口:单列数据,定义了存取一组对象的方法的集合

  1. List:元素有序、可重复的集合(动态数组)
  2. Set:元素无序、不可重复的集合(类似于高中所讲的集合)

Map接口:双列数据,保存具有映射关系“key-value对”的集合(高中时所讲的函数)

Collection接口的使用方法

Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。
JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Se和List)实现。
在 Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所对象都当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合以记住容器中对象的数据类型。

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方法来比较的。拿两个集合的元素挨个比较。
6、删除
boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll):移除这个集合中与当前集合中共有的元素。
7、取两个集合的交集
boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响 c
8、集合是否相等 (注意当前集合到底是有序的还是无序的,在于你使用的具体是Collection的哪个接口)
boolean equals(Object obj)
9、转成对象数组
Collection coll =new ArrayList();
Object[] array = coll.toArray();
10、遍历
iterator():返回迭代器对象,用于集合遍历

Iterator迭代器接口

使用 Iterator 接口遍历集合元素

  1. Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
  2. GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
  3. Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
  4. Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
  5. 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标(指针)都在集合的第一个元素之前。

API
1.遍历集合

原理:
Java——集合(超详细超级全)_第1张图片

我们想要调用集合中所有元素的时候可以用这样来操作:

//创建一个集合对象,然后添加元素,自己去动手实操一下


  Iterator iterator = coll.iterator(); //创建迭代器对象
  //然后通过while循环
  while(iterator.hasNext()){    /判断集合中是否还有元素
      System.out.println(itarator.next());   // 一个一个的输出出来
  }

2.移除集合中的元素

  Iterator iter = coll.iterator();//回到起点
  while(iter.hasNext()){
        Object obj = iter.next();
        if(obj.equals("Tom")){
        iter.remove();
        }
}

注意

  1. Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
  2. 注意我们使用迭代器对象时,他是指针下移的操作。如果我刚刚是用remove方法后,现在的指针应该是已经到了最后一个元素的位置。如果还想去遍历,则需要在重新设置迭代器对象。

使用 foreach 循环遍历集合元素

Java 5.0 提供了 foreach 循环迭代访问 集合和数组。
遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
遍历集合的底层调用Iterator完成操作。
foreach还可以用来遍历数组。
例如:
Java——集合(超详细超级全)_第2张图片

集合(Collection子接口——List接口)

List接口

鉴于Java中数组用来存储数据的局限性,我们通常使用List(动态数组)替代数组

List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector(现在基本没有人使用了)。

List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引(区别于set)来操作集合元素的方法。
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在集合中首次出现的位置,如果不存在返回 -1
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素,并返回此元素(重载了Ccllection的remove方法)
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置(左闭右开)的子集合,原来的list并没有变化。

ArrayList

ArrayList 源码分析

jdk7 :
ArrayList list = new ArrayList(); // 底层会直接创建了长度为10的 Object[] 数组 elementData
list.add(123);
···
···
list(11);// 当添加的元素个数超过了10,之后数组的容量就不够了,就会发生扩容,但这些不需要我们自己去动手,在底层直接会自动扩容,一般情况下是扩容1.5倍,同时将原数组的元素复制到新数组上。
结论:建议使用代参的构造器,ArrayList list = new ArrayList(int capacity); capacity在这里指的是数组的长度。

jdk8:
ArrayList list = new ArrayList(); // 底层是 Object[] 数组 elementData{},说明在我们创建对象的时候没有直接给定长度。
list.add(123); //但是当第一次执行add方法时,才会创建长度为10 的数组。
其余的扩容方法都与jdk7中一样。

小结:jdk7中的ArrayList 对象的创建模式相当于单例模式中的饿汉式,jdk8中的ArrayList 对象的创建模式相当于单例模式中的懒汉式,延迟了数组的创建,节省了内存。

LinkedList

新增方法:
void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getLast()
Object removeFirst()
Object removeLast()

LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。Node除了保存数据,还定义了两个变量:
prev变量记录前一个元素的位置
next变量记录下一个元素的位置

Java——集合(超详细超级全)_第3张图片

LinkedList源码分析

其实跟我前几天写的单链表差不过,只不过在节点类中多加了一个指针,能指向上一个节点,这样就能在底层构成双向链表。其实看图就很容易懂了,不懂可以翻翻我之前写的单链表的api。

面试题

面试题:ArrayList、LinkedList和Vector的异同
相同:三个类都是实现了List接口,存储数据都是有序的,可重复的。
不同:
ArrayList:作为List接口的主要实现类,线程不安全,效率高。而在调用get和set方法时,使用ArrayList会比LinkedList更快捷。底层使用Object[] 存储。
LinkedList:线程不安全。对于频繁的插入和删除操作时,使用此类比ArrayList效率高。底层使用的是双向链表存储。
Vector:作为List接口的古老实现类,线程安全的,效率低。底层使用Object[] 存储。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。

面试题:

   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);
     }

输出的结果为:

1
2

因为我这个remove方法是根据索引删除的,所以删除的是 3 这个元素。如果想要删除2这个元素应该这么写

list.remove(new Integer(2));//这样才表示删除的是2 这个元素 ,而不是索引。

集合(Collection子接口——Set接口)

Set 接口概述

Set接口存储无序的,不可重复的数据(类似高中所学的集合)。
Set接口是Collection的子接口,set接口没有提供额外的方法。
Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。
Set接口的实现类 HashSet,LinkedHashSet 和TreeSet 。

以HashSet为例:
无序性:不等于随机性。(存放位置无序性)存储的数据在底层数组中并非按照数组的索引的顺序去添加的,而是根据数据的哈希值决定的。

不可重复性:保证添加的元素按照equals()判断时,不能返回true。即相同的元素只能添加一个。

euqals()和 = = 的区别

添加元素的过程:以HashSet为例:
Java——集合(超详细超级全)_第4张图片

我们想HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,此哈希值通过某种算法计算出HashSet底层数组中的存放位置(索引位置),然后在判断此位置上是否已经有元素:

  1. 如果此位置上没有其他元素,则元素 a添加成功。
  2. 如果此位置上有其他元素 b(或者是有以链表形式存在的多个元素),则比较元素a与元素b的哈希值 :
    如果哈希值不同,则元素a 添加成功。
    如果哈希值相同,则需要调用元素a所在类的equals()方法:
    equals()方法返回true,则元素a添加失败。
    equals()方法返回false,则元素a添加成功。

通过图片和之前所说的添加元素的方法,能看出来我们HsahSet在底层是一个数组加链表的方法存储数据。

jdk7:将元素a放到数组中,指向原来的元素。
jdk8:原来的元素在数组中,指向元素a。
总结: 七上八下

HashSet

HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。

HashSet 具有以下特点:

  1. 不能保证元素的排列顺序
  2. HashSet 不是线程安全的
  3. 集合元素可以是 null

HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码(哈希值)”。

HashSet扩容问题:
底层也是数组,初始容量为16,当如果使用率超过0.75,(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等)。

问题:
以Eclipse/IDEA为例,在自定义类中可以调用工具自动重写equals和hashCode。为什么用Eclipse/IDEA复写hashCode方法,有31这个数字?

  1. 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(减少冲突)
  2. 并且31只占用5bits,相乘造成数据溢出的概率较小。
  3. 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。(提高算法效率)
  4. 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除!(减少冲突)

LinkedHashSet

LinkedHashSet 是 HashSet 的子类。
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置,但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入顺序保存的。但是是无序的。(存放位置无序)
LinkedHashSet插入性能略低于 HashSet,但在迭代访问 Set 里的全
部元素时有很好的性能。
LinkedHashSet 不允许集合元素重复。

Java——集合(超详细超级全)_第5张图片

TreeSet

TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。也就是说TreeSet可以按照添加对象的指定属性,进行排序。所以在向TreeSet中添加数据时,要求是相同类的对象,因为只有相同类的对象才能比较。
TreeSet底层使用红黑树结构存储数据。所以不能存放相同数据。
TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet采用自然排序。

自然排序

自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列
如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现Comparable 接口。
向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。

对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值。不再是equals()方法。
实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
Comparable 的典型实现:
BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
Character:按字符的 unicode值来进行比较
Boolean:true 对应的包装类实例大于 false 对应的包装类实例
String:按字符串中字符的 unicode 值进行比较
Date、Time:后边的时间、日期比前面的时间、日期大

定制排序

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。

集合(Map接口)

Map接口概述
Map与Collection并列存在。用于保存具有映射关系的数据:key-value(双列数据)。
Map 中的 key 和 value 都可以是任何引用类型的数据。
Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法。
key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value。
Map接口的常用实现类:HashMap、Hashtable、TreeMap、LinkedHashMap和Properties。其中,HashMap是 Map 接口使用频率最高的实现类

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类型。

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集合

我想遍历map时不能使用迭代器了,因为迭代器是Collection接口下的,所以我们可以进行一些操作。
集合遍历

Map map = new HashMap();
//map.put(..,..)省略
System.out.println("map的所有key:");
Set keys = map.keySet();// HashSet
for (Object key : keys) {  //增强for循环遍历
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());
}

HashMap

HashMap是 Map 接口使用频率最高的实现类。
HashMap允许使用null键和null值,与HashSet一样,不保证映射的顺序。
HashMap所有的key构成的集合是Set:无序的、不可重复的。所以,key所在的类要重写:equals()和hashCode()。
HashMap所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类要重写:equals()。
HashMap一个key-value构成一个entry。所有的entry构成的集合是Set:无序的、不可重复的。
HashMap 判断两个 key 相等的标准是:两个 key 通过 equals() 方法返回 true,hashCode 值也相等。
HashMap 判断两个 value相等的标准是:两个 value 通过 equals() 方法返回 true。
Java——集合(超详细超级全)_第6张图片

HashMap的底层实现原理(高频面试)

jdk7:
HashMap map = new HashMap();
在实例化以后,底层创建了长度是16的一维数组Entry[] table。
…可能已经执行过多次put…
map.put(key1,value1);
首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。

  1. 如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1

  2. 如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据 的哈希值:

  3. 如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。----情况2

  4. 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals(key2)方法,比较:
    如果equals()返回false:此时key1-value1添加成功。----情况3
    如果equals()返回true:使用value1替换value2。

  • 补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。

    在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。
    Java——集合(超详细超级全)_第7张图片

jdk8:

jdk8 相较于jdk7在底层实现方面的不同:

  1. new HashMap():底层没有创建一个长度为16的数组

  2. jdk 8底层的数组是:Node[],而非Entry[]

  3. 首次调用put()方法时,底层创建长度为16的数组

  4. jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。

    4.1 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)

    4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储(方便查找)。
    Java——集合(超详细超级全)_第8张图片

HashMap源码中的重要常量:

  • DEFAULT_LOAD_FACTOR:HashMap的默认加载因子:0.75
  • threshold:扩容的临界值,=容量*填充因子:16 * 0.75 => 12(数组中元素大于12的时候可能就会发生扩容,但是当添加第12个元素的位置是null时,也不会发生扩容,只会继续生成链表,不是null的时候一定会扩容)
    为什么会提前扩容? 防止链表的长度太长
  • TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值,转化为红黑树:8
  • MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量:64
  • MAXIMUM_CAPACITY : HashMap的最大支持容量,2^30

table:存储元素的数组,总是2的n次幂
entrySet:存储具体元素的集
size:HashMap中存储的键值对的数量
modCount:HashMap扩容和结构改变的次数。
threshold:扩容的临界值,=容量*填充因子
loadFactor:填充因子

HashMap的扩容:
jdk7:
当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

jdk8:
当HashMap中的其中一个链的对象个数如果达到了8个,此时如果capacity没有达到64,那么HashMap会先扩容解决,如果已经达到了64,那么这个链会变成树,结点类型由Node变成TreeNode类型。当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表。

面试题

负载因子值的大小,对HashMap有什么影响:

  • 负载因子的大小决定了HashMap的数据密度。
  • 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,造成查询或插入时的比较次数增多,性能会下降。
  • 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。
  • 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数。

LinkedHashMap

LinkedHashMap 是 HashMap 的子类。
在HashMap存储结构的基础上,使用了一对双向链表来记录添加
元素的顺序。
与LinkedHashSet类似,LinkedHashMap 可以维护 Map 的迭代顺序:迭代顺序与 Key-Value 对的插入顺序一致。

HashMap中的内部类:Node
其中涉及到的泛型<>,过几天就会讲到。

static class Node implements Map.Entry {
               final int hash;
               final K key;
               V value;
               Node next;
}

LinkedHashMap中的内部类:Entry

static class Entry extends HashMap.Node {
              Entry before, after;
              Entry(int hash, K key, V value, Node next) {
                     super(hash, key, value, next);
               }
}

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。



public class TreeMapTest {

    //向TreeMap中添加key-value,要求key必须是由同一个类创建的对象
    //因为要按照key进行排序:自然排序 、定制排序
    //自然排序
    @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配!");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }


}

Hashtable

  • Hashtable是个古老的 Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。
  • Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
  • 与HashMap不同,Hashtable 不允许使用 null 作为 key 和 value
  • 与HashMap一样,Hashtable 也不能保证其中 Key-Value 对的顺序
  • Hashtable判断两个key相等、两个value相等的标准,与HashMap一致。

Properties

Properties 类是 Hashtable 的子类,该对象用于处理属性文件。
由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型。
存取数据时,建议使用setProperty(String key,String value)方法和
getProperty(String key)方法。

大家主要还是主要关注HashMap,其他的需要了解知道是干什么用的就好了,实际场景中用的还是HashMap。

Collections工具类

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 处元素进行交换。

查找、替换

  • 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 对象的所有旧值

Collections常用方法:同步控制

Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题。

Java——集合(超详细超级全)_第9张图片

你可能感兴趣的:(Java,java,集合,hashmap,hash)