Java集合
一、集合框架概述
集合可以看作是一种容器,用来存储对象信息。所有集合类都位于java.util包下,但支持多线程的集合类位于java.util.concurrent包下
1.数组与集合的区别
- 数组长度不可变化而且无法保存具有映射关系的数据;集合类用于保存数量不确定的数据,以及保存具有映射关系的数据
- 数组元素既可以是基本类型的值,也可以是对象;集合只能保存对象
2.集合框架体系
Java集合类很多,主要分为两大类(单列集合 , 双列集合):
-
接口Collection派生类(单列集合)
- List子接口
- Set子接口
- Queue子接口
-
接口Map派生类(双列集合)存放的 K-V
注:Map不是Collection的子接口
其继承关系具体如下图
二、Java集合常见接口及实现类
1.Collection接口实现类的特点
- public interface Collection
extends Iterable :Collection接口继承了Iterable接口 - collection实现子类可以存放多个元素,每个元素可以是Object
- 有些Collection的实现类,可以存放重复的元素,有些不可以
- 有些Collection的实现类是有序的(List),有些不是有序的(Set)
- Collection接口没有直接的实现子类,都是通过它的子接口来实现的
2.Collection接口常用方法
2.1 Collection 接口常用方法示例
- 以 ArrayList 实现类来演示
package com.hspedu.collection_;
import java.util.ArrayList;
import java.util.List;
public class CollectionMethod {
@SuppressWarnings({"all"})
public static void main(String[] args) {
List list = new ArrayList();
// add:添加单个元素
list.add("jack");
list.add(10);//list.add(new Integer(10))
list.add(true);
System.out.println("list=" + list);
// remove:删除指定元素
//list.remove(0);//删除第一个元素
list.remove(true);//指定删除某个元素
System.out.println("list=" + list);
// contains:查找元素是否存在
System.out.println(list.contains("jack"));//T
// size:获取元素个数
System.out.println(list.size());//2
// isEmpty:判断是否为空
System.out.println(list.isEmpty());//F
// clear:清空
list.clear();
System.out.println("list=" + list);
// addAll:添加多个元素
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2);
System.out.println("list=" + list);
// containsAll:查找多个元素是否都存在
System.out.println(list.containsAll(list2));//T
// removeAll:删除多个元素
list.add("聊斋");
list.removeAll(list2);
System.out.println("list=" + list);//[聊斋]
// 说明:以ArrayList实现类来演示.
}
}
2.2 Collection 接口遍历元素方式
-
使用 Iterator(迭代器)
-
public interface Iterator
` -
Iterator对象称为迭代器,主要用于遍历Collection集合中的元素
-
所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
-
Iterator接口的方法
注意:在调用iterator.next()方法之前必须要调用Iterator.hasNext()进行检测。若不调用,且下一条记录无效,直接调用iterator.next()会抛出NoSuchElementException异常。
-
迭代器使用案例
package com.hspedu.collection_; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionIterator { @SuppressWarnings({"all"}) public static void main(String[] args) { Collection col = new ArrayList(); col.add(new Book("三国演义", "罗贯中", 10.1)); col.add(new Book("小李飞刀", "古龙", 5.1)); col.add(new Book("红楼梦", "曹雪芹", 34.6)); //System.out.println("col=" + col); //现在希望能够遍历 col集合 //1. 先得到 col 对应的 迭代器 Iterator iterator = col.iterator(); //2. 使用while循环遍历 // while (iterator.hasNext()) {//判断是否还有数据 // //返回下一个元素,类型是Object // Object obj = iterator.next(); // System.out.println("obj=" + obj); // } //可以使用快捷键,快速生成 while => itit //显示所有的快捷键的的快捷键 ctrl + j while (iterator.hasNext()) { Object obj = iterator.next(); System.out.println("obj=" + obj); } //3. 当退出while循环后 , 这时iterator迭代器,指向最后的元素 // iterator.next();//NoSuchElementException //4. 如果希望再次遍历,需要重置我们的迭代器 iterator = col.iterator(); System.out.println("===第二次遍历==="); while (iterator.hasNext()) { Object obj = iterator.next(); System.out.println("obj=" + obj); } } } class Book { private String name; private String author; private double price; public Book(String name, String author, double price) { this.name = name; this.author = author; this.price = price; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAuthor() { return author; } public void setAuthor(String author) { this.author = author; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } @Override public String toString() { return "Book{" + "name='" + name + '\'' + ", author='" + author + '\'' + ", price=" + price + '}'; } }
-
-
增强for循环
-
增强for循环就是简化版的Iterator,本质是一样的。只能用于遍历集合或者数组
-
基本语法
for(元素类型 元素名:集合名或者数组名){
访问元素
}
-
示例:
package com.hspedu.collection_; import java.util.ArrayList; import java.util.Collection; public class CollectionFor { @SuppressWarnings({"all"}) public static void main(String[] args) { Collection col = new ArrayList(); col.add(new Book("三国演义", "罗贯中", 10.1)); col.add(new Book("小李飞刀", "古龙", 5.1)); col.add(new Book("红楼梦", "曹雪芹", 34.6)); //老韩解读 //1. 使用增强for, 在Collection集合 //2. 增强for, 底层仍然是迭代器 //3. 增强for可以理解成就是简化版本的 迭代器遍历 //4. 快捷键方式 I // for (Object book : col) { // System.out.println("book=" + book); // } for (Object o : col) { System.out.println("book=" + o); } //增强for,也可以直接在数组使用 // int[] nums = {1, 8, 10, 90}; // for (int i : nums) { // System.out.println("i=" + i); // } } }
-
3.List接口及其常用方法
3.1List接口基本介绍
-
List接口是Collection接口的子接口
-
List集合类元素有序(即添加顺序和取出顺序一致)、且元素可重复
-
List集合中的每个元素都有其对应的顺序索引,即支持索引
-
List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素
-
常用实现类有:ArrayList、LinkedList和Vector
-
示例:
package com.hspedu.list_; import java.util.ArrayList; import java.util.List; public class List_ { @SuppressWarnings({"all"}) public static void main(String[] args) { //1. List集合类中元素有序(即添加顺序和取出顺序一致)、且元素可重复 List list = new ArrayList(); list.add("jack"); list.add("tom"); list.add("mary"); list.add("hsp"); list.add("tom"); System.out.println("list=" + list);//list=[jack, tom, mary, hsp, tom] //2. List集合中的每个元素都有其对应的顺序索引,即支持索引 // 索引是从0开始的 System.out.println(list.get(3));//hsp } }
3.2List接口常用方法
-
-
示例:
package com.hspedu.list_; import java.util.ArrayList; import java.util.List; public class ListMethod { @SuppressWarnings({"all"}) public static void main(String[] args) { List list = new ArrayList(); list.add("张三丰"); list.add("贾宝玉"); // void add(int index, Object ele):在index位置插入ele元素 //在index = 1的位置插入一个对象 list.add(1, "韩顺平"); System.out.println("list=" + list); // boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来 List list2 = new ArrayList(); list2.add("jack"); list2.add("tom"); list.addAll(1, list2); System.out.println("list=" + list); // Object get(int index):获取指定index位置的元素 // int indexOf(Object obj):返回obj在集合中首次出现的位置 System.out.println(list.indexOf("tom"));//2 // int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置 list.add("韩顺平"); System.out.println("list=" + list); System.out.println(list.lastIndexOf("韩顺平")); // Object remove(int index):移除指定index位置的元素,并返回此元素 list.remove(0); System.out.println("list=" + list); // Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换. list.set(1, "玛丽"); System.out.println("list=" + list); // List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合 // 注意返回的子集合 fromIndex <= subList < toIndex List returnlist = list.subList(0, 2); System.out.println("returnlist=" + returnlist); } }
3.3List的三种遍历方式
-
不同于Collection接口,由于List集合元素有序可以通过索引直接访问所以可以用普通的for循环进行遍历
-
示例:
package com.hspedu.list_; import java.util.*; public class ListFor { @SuppressWarnings({"all"}) public static void main(String[] args) { //List 接口的实现子类 Vector LinkedList //List list = new ArrayList(); //List list = new Vector(); List list = new LinkedList(); list.add("jack"); list.add("tom"); list.add("鱼香肉丝"); list.add("北京烤鸭子"); //遍历 //1. 迭代器 Iterator iterator = list.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); System.out.println(obj); } System.out.println("=====增强for====="); //2. 增强for for (Object o : list) { System.out.println("o=" + o); } System.out.println("=====普通for===="); //3. 使用普通for for (int i = 0; i < list.size(); i++) { System.out.println("对象=" + list.get(i)); } } }
3.4List接口的实现类
-
ArrayList
ArrayList是一个动态数组,也是我们最常用的集合,是List类的典型实现。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量(10),该容量代表了数组的大小。随着容器中的元素不断增加,容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查,当快溢出时,就会进行扩容操作。
- 底层机制
- ArrayList基本等同于Vector,除了ArrayList是线程不安全的,在多线程情况下,不建议使用ArrayList
- ArrayList底层维护了一个Object类型的数组elementData; transient Object[] elementData;//transient 表示瞬间,暂时的,表示该属性不会被序列号
- 当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0,第一次添加,则扩容elementData为10,如需再次扩容,则扩容elementData为1.5倍
- 如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍
- 底层机制
-
Vector
与ArrayList相似,但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样
- 底层机制
- Vector底层也是一个对象数组,protected Object[] elementData
- Vector的扩容机制与ArrayList基本相同,只需把ArrayList扩容增大倍数改成2倍就是Vector的扩容机制
- 底层机制
-
LinkedList
LinkedList底层实现了双向链表和双端队列的特点,可以添加任意元素(元素可以重复),包括null,LinkedList没有实现同步,线程不安全
- 底层机制
-
LinkedList底层维护了一个双向链表
-
LinkedList中维护了两个属性first和last分别指向首节点和尾节点,每个节点(Node对象),里面又维护了prev、next、item三个属性,其中通过prev指向前一个,通过next指向后一个节点,最终实现双向链表
-
-
双向链表代码示例:
package com.hspedu.list_; public class LinkedList01 { public static void main(String[] args) { //模拟一个简单的双向链表 Node jack = new Node("jack"); Node tom = new Node("tom"); Node hsp = new Node("老韩"); //连接三个结点,形成双向链表 //jack -> tom -> hsp jack.next = tom; tom.next = hsp; //hsp -> tom -> jack hsp.pre = tom; tom.pre = jack; Node first = jack;//让first引用指向jack,就是双向链表的头结点 Node last = hsp; //让last引用指向hsp,就是双向链表的尾结点 //演示,从头到尾进行遍历 System.out.println("===从头到尾进行遍历==="); while (true) { if(first == null) { break; } //输出first 信息 System.out.println(first); first = first.next; } //演示,从尾到头的遍历 System.out.println("====从尾到头的遍历===="); while (true) { if(last == null) { break; } //输出last 信息 System.out.println(last); last = last.pre; } //演示链表的添加对象/数据,是多么的方便 //要求,是在 tom --------- 直接,插入一个对象 smith //1. 先创建一个 Node 结点,name 就是 smith Node smith = new Node("smith"); //下面就把 smith 加入到双向链表了 smith.next = hsp; smith.pre = tom; hsp.pre = smith; tom.next = smith; //让first 再次指向jack first = jack;//让first引用指向jack,就是双向链表的头结点 System.out.println("===从头到尾进行遍历==="); while (true) { if(first == null) { break; } //输出first 信息 System.out.println(first); first = first.next; } last = hsp; //让last 重新指向最后一个结点 //演示,从尾到头的遍历 System.out.println("====从尾到头的遍历===="); while (true) { if(last == null) { break; } //输出last 信息 System.out.println(last); last = last.pre; } } } //定义一个Node 类,Node 对象 表示双向链表的一个结点 class Node { public Object item; //真正存放数据 public Node next; //指向后一个结点 public Node pre; //指向前一个结点 public Node(Object name) { this.item = name; } public String toString() { return "Node name=" + item; } }
-
所以LinkedList的元素的添加和删除,不是通过数组完成的相对效率较高
-
- 底层机制
-
如何选择ArrayList和LinkedList
- 如果改查操作多,选择ArrayList
- 如果增删操作多,选择LinkedList
4.Set接口及其常用方法
4.1Set接口基本介绍
- Set接口是Collection接口的子接口
- Set集合类元素无序(添加和取出的顺序不一致),且没有索引
- Set集合类不允许重复元素,所以最多包含一个null
- Set接口的常用实现类:HashSet,TreeSet
4.2Set接口常用方法
-
方法使用示例:
package com.hspedu.set_; import java.util.HashSet; import java.util.Iterator; import java.util.Set; @SuppressWarnings({"all"}) public class SetMethod { public static void main(String[] args) { //1. 以Set 接口的实现类 HashSet 来讲解Set 接口的方法 //2. set 接口的实现类的对象(Set接口对象), 不能存放重复的元素, 可以添加一个null //3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致) //4. 注意:取出的顺序的顺序虽然不是添加的顺序,但它是固定的. Set set = new HashSet(); set.add("john"); set.add("lucy"); set.add("john");//重复 set.add("jack"); set.add("hsp"); set.add("mary"); set.add(null);// set.add(null);//再次添加null for(int i = 0; i <10;i ++) { System.out.println("set=" + set); } //遍历 //方式1: 使用迭代器 System.out.println("=====使用迭代器===="); Iterator iterator = set.iterator(); while (iterator.hasNext()) { Object obj = iterator.next(); System.out.println("obj=" + obj); } set.remove(null); //方式2: 增强for System.out.println("=====增强for===="); for (Object o : set) { System.out.println("o=" + o); } //set 接口对象,不能通过索引来获取 } }
4.3Set接口的实现类
4.3.1.HashSet
HashSet是Set集合最常用实现类,是其经典实现。HashSet是按照hash算法来存储元素的,因此具有很好的存取和查找性能。
-
HashSet具有如下特点
-
不能保证元素的顺序
-
集合元素值可以是null且不能有重复元素或者对象
-
HashSet不是线程同步的,如果多线程操作HashSet集合,则应通过代码来保证其同步
-
不能有重复元素或者对象示例:
package com.hspedu.set_; import java.util.HashSet; @SuppressWarnings({"all"}) public class HashSet01 { public static void main(String[] args) { HashSet set = new HashSet(); //说明 //1. 在执行add方法后,会返回一个boolean值 //2. 如果添加成功,返回 true, 否则返回false //3. 可以通过 remove 指定删除哪个对象 System.out.println(set.add("john"));//T System.out.println(set.add("lucy"));//T System.out.println(set.add("john"));//F System.out.println(set.add("jack"));//T System.out.println(set.add("Rose"));//T set.remove("john"); System.out.println("set=" + set);//3个 // set = new HashSet(); System.out.println("set=" + set);//0 //4 Hashset 不能添加相同的元素/数据? set.add("lucy");//添加成功 set.add("lucy");//加入不了 set.add(new Dog("tom"));//OK set.add(new Dog("tom"));//Ok System.out.println("set=" + set); //在加深一下. 非常经典的面试题. //看源码,做分析, 先给小伙伴留一个坑,以后讲完源码,你就了然 //去看他的源码,即 add 到底发生了什么?=> 底层机制. set.add(new String("hsp"));//ok set.add(new String("hsp"));//加入不了. System.out.println("set=" + set); } } class Dog { //定义了Dog类 private String name; public Dog(String name) { this.name = name; } @Override public String toString() { return "Dog{" + "name='" + name + '\'' + '}'; } }
-
-
底层机制
-
HashSet的底层是HashMap,HashMap的底层是(数组+链表+红黑树)
-
模拟数组链表示例:
package com.hspedu.set_; @SuppressWarnings({"all"}) public class HashSetStructure { public static void main(String[] args) { //模拟一个HashSet的底层 (HashMap 的底层结构) //1. 创建一个数组,数组的类型是 Node[] //2. 有些人,直接把 Node[] 数组称为 表 Node[] table = new Node[16]; //3. 创建结点 Node john = new Node("john", null); table[2] = john; Node jack = new Node("jack", null); john.next = jack;// 将jack 结点挂载到john Node rose = new Node("Rose", null); jack.next = rose;// 将rose 结点挂载到jack Node lucy = new Node("lucy", null); table[3] = lucy; // 把lucy 放到 table表的索引为3的位置. System.out.println("table=" + table); } } class Node { //结点, 存储数据, 可以指向下一个结点,从而形成链表 Object item; //存放数据 Node next; // 指向下一个结点 public Node(Object item, Node next) { this.item = item; this.next = next; } }
-
HashSet集合存储一个元素时,1)HashSet会调用该对象的hashCode()方法得到其hashCode值,2)然后根据hashCode值决定该对象的存储位置(即存放在哈希表中的位置号),3)如果该位置上没有其他元素,则直接存放;如果该位置上已经有其他元素,则需要进行equals判断,如果相等,则不再添加。如果不相等,则以链表的方式添加。
-
HashSet扩容机制
- HashSet底层是HashMap,第一次添加时,table数组扩容到16,临界值(threshold)是16*加载因子(loadFactor)是0.75=12
- 如果table数组使用到了临界值12,就会扩容到16*2=32,新的临界值就是32*0.75=24,依次类推
- 在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8),并且table的大小>=MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),否则仍然采用数组扩容机制
-
4.3.2LinkedHashSet
-
LinkedHashSet是HashSet的子类
-
LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序,这使得元素看起来是一插入顺序保存的
-
LinkedHashSet不允许添加重复元素
-
LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组+双向链表
-
在LinkedHashSet中维护了一个hash表和双向链表
-
每个节点都有before和after属性,这样可以形成双向链表
-
在添加一个元素时,先求hash属性,再求索引,确定该元素在table的位置,然后将添加的元素加入到双向链表(机制和HashSet一样)
-
示意图:
注意:LinkedHashSet和HashSet底层不同之处,HashSet是table数组每个元素引出一条链表,链表与链表之间不会联系;但LinkedHashSet每个节点之间都会链接
-
代码示例:
package com.hspedu.set_; import java.util.LinkedHashSet; import java.util.Set; @SuppressWarnings({"all"}) public class LinkedHashSetSource { public static void main(String[] args) { //分析一下LinkedHashSet的底层机制 Set set = new LinkedHashSet(); set.add(new String("AA")); set.add(456); set.add(456); set.add(new Customer("刘", 1001)); set.add(123); set.add("HSP"); System.out.println("set=" + set);//set=[AA, 456, com.hspedu.set_.Customer@5cad8086, 123, HSP] //老韩解读 //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致 //2. LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类) //3. LinkedHashSet 底层结构 (数组table+双向链表) //4. 添加第一次时,直接将 数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry //5. 数组是 HashMap$Node[] 存放的元素/数据是 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); } } */ } } class Customer { private String name; private int no; public Customer(String name, int no) { this.name = name; this.no = no; } }
-
4.3.3TreeSet
-
基本介绍
-
public class TreeSet
extends AbstractSet implements NavigableSet , Cloneable, java.io.Serializable -
TreeSet是基于TreeMap实现的
-
TreeSet中的元素支持2种排序方式:自然排序 (使用无参构造器)或者 根据创建TreeSet 时提供的 Comparator 进行排序。这取决于使用的构造方法
-
-
使用示例
package com.hspedu.set_; import java.util.Comparator; import java.util.TreeSet; @SuppressWarnings({"all"}) public class TreeSet_ { public static void main(String[] args) { /* 1. 构造器把传入的比较器对象,赋给了 TreeSet的底层的 TreeMap的属性this.comparator public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } 2. 在 调用 treeSet.add("tom"), 在底层会执行到 if (cpr != null) {//cpr 就是我们的匿名内部类(对象) do { parent = t; //动态绑定到我们的匿名内部类(对象)compare cmp = cpr.compare(key, t.key); if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else //如果相等,即返回0,这个Key就没有加入 return t.setValue(value); } while (t != null); } */ // TreeSet treeSet = new TreeSet(); TreeSet treeSet = new TreeSet(new Comparator() { @Override public int compare(Object o1, Object o2) { //下面 调用String的 compareTo方法进行字符串大小比较 //如果要求加入的元素,按照长度大小排序 //return ((String) o2).compareTo((String) o1); return ((String) o1).length() - ((String) o2).length(); } }); //添加数据. treeSet.add("jack"); treeSet.add("tom");//3 treeSet.add("sp"); treeSet.add("a"); treeSet.add("abc");//3 System.out.println("treeSet=" + treeSet); } }
5.Map接口及其常用方法
5.1Map接口基本介绍
-
Map与Collection并列存在。用于保存具有映射关系的数据:Key—Value
-
Map中的key不允许重复,value可以重复;当有相同的key时,新的value会把原来对应的value替换
-
Map中key,value可以为null
-
常用String类作为Map的key
-
key和value之间存在单项一对一关系,即通过指定的key总能找到对应的value
-
Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
注:Node是HashMap的一个静态内部类,实现了Entry接口。Entry接口是Map内部的一个接口;static class Node<K,V> implements Map.Entry<K,V>
5.2Map接口的常用方法
-
示例:
package com.hspedu.map_; import java.util.HashMap; import java.util.Map; @SuppressWarnings({"all"}) public class MapMethod { public static void main(String[] args) { //演示map接口常用方法 Map map = new HashMap(); map.put("邓超", new Book("", 100));//OK map.put("邓超", "孙俪");//替换 map.put("王宝强", "马蓉");//OK map.put("宋喆", "马蓉");//OK map.put("刘令博", null);//OK map.put(null, "刘亦菲");//OK map.put("鹿晗", "关晓彤");//OK map.put("hsp", "hsp的老婆"); System.out.println("map=" + map); // remove:根据键删除映射关系 map.remove(null); System.out.println("map=" + map); // get:根据键获取值 Object val = map.get("鹿晗"); System.out.println("val=" + val); // size:获取元素个数 System.out.println("k-v=" + map.size()); // isEmpty:判断个数是否为0 System.out.println(map.isEmpty());//F // clear:清除k-v //map.clear(); System.out.println("map=" + map); // containsKey:查找键是否存在 System.out.println("结果=" + map.containsKey("hsp"));//T } } class Book { private String name; private int num; public Book(String name, int num) { this.name = name; this.num = num; } }
5.3Map接口的遍历方法
Map为了方便程序员的遍历,其实现类会创建EntrySet集合,该集合存放的元素类型Entry;此外还创建了Values集合,用于存放value,KeySet集合用于存放key;k-v的真正存放的位置在Node
final class EntrySet extends AbstractSet<Map.Entry<K,V>>
final class Values extends AbstractCollection<V>
final class KeySet extends AbstractSet<K>
-
代码示例:
package com.hspedu.map_; import java.util.*; @SuppressWarnings({"all"}) public class MapFor { public static void main(String[] args) { Map map = new HashMap(); map.put("邓超", "孙俪"); map.put("王宝强", "马蓉"); map.put("宋喆", "马蓉"); map.put("刘令博", null); map.put(null, "刘亦菲"); map.put("鹿晗", "关晓彤"); //第一组: 先取出 所有的Key , 通过Key 取出对应的Value Set keyset = map.keySet(); //(1) 增强for System.out.println("-----第一种方式-------"); for (Object key : keyset) { System.out.println(key + "-" + map.get(key)); } //(2) 迭代器 System.out.println("----第二种方式--------"); Iterator iterator = keyset.iterator(); while (iterator.hasNext()) { Object key = iterator.next(); System.out.println(key + "-" + map.get(key)); } //第二组: 把所有的values取出 Collection values = map.values(); //这里可以使用所有的Collections使用的遍历方法 //(1) 增强for System.out.println("---取出所有的value 增强for----"); for (Object value : values) { System.out.println(value); } //(2) 迭代器 System.out.println("---取出所有的value 迭代器----"); Iterator iterator2 = values.iterator(); while (iterator2.hasNext()) { Object value = iterator2.next(); System.out.println(value); } //第三组: 通过EntrySet 来获取 k-v Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>> //(1) 增强for System.out.println("----使用EntrySet 的 for增强(第3种)----"); for (Object entry : entrySet) { //将entry 转成 Map.Entry Map.Entry m = (Map.Entry) entry; System.out.println(m.getKey() + "-" + m.getValue()); } //(2) 迭代器 System.out.println("----使用EntrySet 的 迭代器(第4种)----"); Iterator iterator3 = entrySet.iterator(); while (iterator3.hasNext()) { Object entry = iterator3.next(); //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue) //向下转型 Map.Entry Map.Entry m = (Map.Entry) entry; System.out.println(m.getKey() + "-" + m.getValue()); } } }
5.4Map接口的实现类
- HashMap
- HashMap的特点
- HashMap是Map接口使用频率最高的实现类
- key不能重复,但value可以重复,允许使用null键和null值;当key相同时,会覆盖原来的value
- 和HashSet一样,不保证映射的顺序,因为底层是以hash表的方式来存储的
- HashMap没有实现同步,因此线程是不安全,方法没有做同步互斥的操作,没有synchronized
- 底层机制(前面HashSet已介绍)
- HashTable
- HashTable的特点
- HashTable的键和值都不能为null,否则会抛出NullPointException
- HashTable的使用方法与HashMap基本一样
- HashTable是线程安全的(synchronized)
- HashTable的底层机制
-
HashTable扩容机制
- 第一次添加时,table数组扩容到11,临界值(threshold)是11*加载因子(loadFactor)是0.75=8
- 如果table数组使用到了临界值8(超过8),会按自己的机制进行扩容(与HashMap不同)
-
- Properties
-
Properties基本介绍
- Properties类继承HashTable类并且实现了Map接口,也是使用键值对来保存数据
- 使用特点与HashTable类似
- Properties还可以用于从xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改
-
基本使用示例
package com.hspedu.map_; import java.util.Properties; @SuppressWarnings({"all"}) public class Properties_ { public static void main(String[] args) { //1. Properties 继承 Hashtable //2. 可以通过 k-v 存放数据,当然key 和 value 不能为 null //增加 Properties properties = new Properties(); //properties.put(null, "abc");//抛出 空指针异常 //properties.put("abc", null); //抛出 空指针异常 properties.put("john", 100);//k-v properties.put("lucy", 100); properties.put("lic", 100); properties.put("lic", 88);//如果有相同的key , value被替换 System.out.println("properties=" + properties); //通过k 获取对应值 System.out.println(properties.get("lic"));//88 //删除 properties.remove("lic"); System.out.println("properties=" + properties); //修改 properties.put("john", "约翰"); System.out.println("properties=" + properties); } }
-
TreeMap
TreeMap底层是基于红黑树实现的,该映射根据其键的自然顺序进行排序,或根据创建映射时提供的Comparator进行排序,关键在于使用的构造方法的不同
-
特点
- TreeMap 是一个有序的key-value集合,它是通过红黑树实现的
- TreeMap中的元素支持2种排序方式:自然排序 (使用无参构造器)或者 根据创建TreeMap 时提供的 Comparator 进行排序。这取决于使用的构造方法
-
使用示例
package com.hspedu.map_; import java.util.Comparator; import java.util.TreeMap; @SuppressWarnings({"all"}) public class TreeMap_ { public static void main(String[] args) { /* 要求:按照传入的 k(String) 的大小进行排序 */ // TreeMap treeMap = new TreeMap(); TreeMap treeMap = new TreeMap(new Comparator() { @Override public int compare(Object o1, Object o2) { //按照传入的 k(String) 的大小进行排序 //按照K(String) 的长度大小排序 //return ((String) o2).compareTo((String) o1); return ((String) o2).length() - ((String) o1).length(); } }); treeMap.put("jack", "杰克"); treeMap.put("tom", "汤姆"); treeMap.put("kristina", "克瑞斯提诺"); treeMap.put("smith", "斯密斯"); treeMap.put("hsp", "韩顺平");//加入不了 System.out.println("treemap=" + treeMap); /* 1. 构造器. 把传入的实现了 Comparator接口的匿名内部类(对象),传给给TreeMap的comparator public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } 2. 调用put方法 2.1 第一次添加, 把k-v 封装到 Entry对象,放入root Entry<K,V> t = root; if (t == null) { compare(key, key); // type (and possibly null) check root = new Entry<>(key, value, null); size = 1; modCount++; return null; } 2.2 以后添加 Comparator<? super K> cpr = comparator; if (cpr != null) { do { //遍历所有的key , 给当前key找到适当位置 parent = t; cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare if (cmp < 0) t = t.left; else if (cmp > 0) t = t.right; else //如果遍历过程中,发现准备添加Key 和当前已有的Key 相等,就不添加 return t.setValue(value); } while (t != null); } */ } }
6.集合实现类的选择
7.Collections工具类
-
基本介绍
- Collections是一个操作List、Set和Map等集合的工具类
- Collections中提供了一系列静态方法对集合进行排序、查询和修改等操作
-
用法示例:
package com.hspedu.collections_; import java.util.*; /** * @author 韩顺平 * @version 1.0 */ @SuppressWarnings({"all"}) public class Collections_ { public static void main(String[] args) { //创建ArrayList 集合,用于测试. List list = new ArrayList(); list.add("tom"); list.add("smith"); list.add("king"); list.add("milan"); list.add("tom"); // reverse(List):反转 List 中元素的顺序 Collections.reverse(list); System.out.println("list=" + list); // shuffle(List):对 List 集合元素进行随机排序 // for (int i = 0; i < 5; i++) { // Collections.shuffle(list); // System.out.println("list=" + list); // } // sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序 Collections.sort(list); System.out.println("自然排序后"); System.out.println("list=" + list); // sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序 //我们希望按照 字符串的长度大小排序 Collections.sort(list, new Comparator() { @Override public int compare(Object o1, Object o2) { //可以加入校验代码. return ((String) o2).length() - ((String) o1).length(); } }); System.out.println("字符串长度大小排序=" + list); // swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换 //比如 Collections.swap(list, 0, 1); System.out.println("交换后的情况"); System.out.println("list=" + list); //Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素 System.out.println("自然顺序最大元素=" + Collections.max(list)); //Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素 //比如,我们要返回长度最大的元素 Object maxObject = Collections.max(list, new Comparator() { @Override public int compare(Object o1, Object o2) { return ((String)o1).length() - ((String)o2).length(); } }); System.out.println("长度最大的元素=" + maxObject); //Object min(Collection) //Object min(Collection,Comparator) //上面的两个方法,参考max即可 //int frequency(Collection,Object):返回指定集合中指定元素的出现次数 System.out.println("tom出现的次数=" + Collections.frequency(list, "tom")); //void copy(List dest,List src):将src中的内容复制到dest中 ArrayList dest = new ArrayList(); //为了完成一个完整拷贝,我们需要先给dest 赋值,大小和list.size()一样 for(int i = 0; i < list.size(); i++) { dest.add(""); } //拷贝 Collections.copy(dest, list); System.out.println("dest=" + dest); //boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换 List 对象的所有旧值 //如果list中,有tom 就替换成 汤姆 Collections.replaceAll(list, "tom", "汤姆"); System.out.println("list替换后=" + list); } }