包括Queue接口及LinkedList实现、Queue常用方法、Deque接口及LinkedList实现、Deque常用方法、Map集合常用方法、HashMap基本原理、重写equals和hashCode方法、HashMap应用、HashMap性能调优、Map遍历(迭代)。
1)队列Queue是常用的数据结构,可以将队列看成特殊的线性表,队列限制了对线性表的访问方式:只能从线性表的一端添加(offer)元素,从另外一端取出(poll)元素
2)队列也可以放一组元素,但是存取元素必须遵循:先进先出原则
3)JDK提供了Queue接口,同时使得LinkedList实现了该接口(选择LinkedList实现Queue经常要进行插入和删除的操作,而LinkedList在这方面效率最高)
Queue queue = new LinkedList();
Queue常用方法
方法 | 功能 |
---|---|
boolean offer(E e) | 入队操作,向队尾追加一个新元素,如果添加成功则返回true |
E poll() | 出队操作,从队首获取元素,获取后该元素就从队列中被删除了 |
E peek() | 引用队首元素,但是不做出队操作 |
import java.util.LinkedList;
import java.util.Queue;
/**
* java.util.Queue
* 队列
* 队列也可以放一组元素,但是存取元素必须遵循:先进先出原则
*/
public class QueueDemo {
public static void main(String[] args) {
/**
* LinkedList也实现了队列接口,因为它可以保存一组元素,并且首尾删快。正好符合队列的特点
*/
Queue<String> queue = new LinkedList<String>();
/*
boolean offer(E e)
入队操作,向队尾追加一个新元素
*/
queue.offer("one");
queue.offer("two");
queue.offer("three");
queue.offer("four");
queue.offer("five");
queue.offer("six");
System.out.println(queue); //[one, two, three, four, five, six]
/*
E poll()
出队操作,从队首获取元素,获取后该元素就从队列中被删除了
*/
String str = queue.poll();
System.out.println(str); //one
System.out.println(queue); //[two, three, four, five, six]
/*
E peek()
引用队首元素,但是不做出队操作
*/
str = queue.peek();
System.out.println(str); //two
System.out.println(queue); //[two, three, four, five, six]
System.out.println("遍历开始");
for(int i=queue.size();i>0;i--){ //倒着写,queue.size()会随着每次poll取数而改变
str = queue.poll();
System.out.print ("元素:"+str+" "); //元素:two 元素:three 元素:four 元素:five 元素:six
}
System.out.println(); //换行
/*
while(queue.size()>0){
str = queue.poll();
System.out.println("元素:"+str);
}
*/
System.out.println("遍历结束");
System.out.println(queue); //[]
}
}
1)Deque是Queue的子接口,定义了所谓“双端队列”即从队列的两端分别可以入队(offer)和出队(poll)
2)如果将Deque限制为只能从一端入队和出队,则可实现“栈”(Stack)的数据结构,对于栈而言,入栈称为为push,出栈称之为pop
3)存储一组元素,但是存取元素必须遵循先进后出的原则
4)通常为了实现后退这类功能时会使用栈(word文档中的回退和前进)
Queue常用方法
方法 | 功能 |
---|---|
void push(E e) | 入栈操作,最后入栈的元素在栈顶(第一个元素位置) |
E pop() | 出栈操作 |
import java.util.Deque;
import java.util.LinkedList;
/**
* 栈
* 存储一组元素,但是存取元素必须遵循先进后出的原则
* 通常为了实现后退这类功能时会使用栈(word文档中的回退和前进)
*/
public class StackDemo {
public static void main(String[] args) {
/*
java.util.Deque
双端队列,两端都可以进出队
当子调用从一端进出队操作时,就形成了栈结构
因此,双端队列为栈提供了两个方法:push,pop
*/
Deque<String> stack = new LinkedList<String>();
/*
void push(E e)
入栈操作,最后入栈的元素在栈顶(第一个元素位置)
*/
stack.push("one");
stack.push("two");
stack.push("three");
stack.push("four");
System.out.println(stack); //[four, three, two, one]
/*
出栈操作
E pop()
*/
String str = stack.pop();
System.out.println(str); //four
System.out.println(stack); //[three, two, one]
str = stack.peek();
System.out.println(str); //three
System.out.println(stack); //[three, two, one]
while (stack.size()>0){
str = stack.pop();
System.out.print(str+" "); //three two one
}
}
}
(1)Map看起来像是一个多行两列的表格。以key-value对的形式存放元素
(2)key可以看成是value的索引,在Map中key不允许重复(重复是依靠key的equals判断)
(3)常用的实现类为:HashMap
Map集合的常用方法
方法 | 功能 |
---|---|
V put(K k,V v) | 将给定的key-value对存入Map。由于Map要求key不允许重复,所以使用Map已有的key存入一个新的value时的操作是替换value。那么返回值为该key原来对应的value。若是一个新的key,则返回值为null |
V get(K k) | 根据给定的key获取对应的value,若当前Map中没有给定的key,则返回值为null |
V remove(K k) | 删除给定的key所对应的key-value对,返回值为被删除的key-value对中的value |
import java.util.HashMap;
import java.util.Map;
/**
* java.util.Map
* Map看起来像是一个多行两列的表格。以key-value对的形式存放元素
* 在Map中key不允许重复(重复是依靠key的equals判断)
* 常用的实现类为:HashMap
*/
public class MapDemo {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
/*
V put(K k,V v)
将给定的key-value对存入Map
由于Map要求key不允许重复,所以使用Map已有的key存入一个新的value时的操作是替换value
那么返回值为该key原来对应的value。若是一个新的key,则返回值为null
*/
Integer value = map.put("语文",90);
System.out.println(value); //null
map.put("语文",45);
map.put("数学",23);
map.put("英语",75);
map.put("物理",45);
map.put("化学",45);
System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=45, 英语=75}
value = map.put("语文",90);
System.out.println(value); //45
System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=90, 英语=75}
/*
V get(K k)
根据给定的key获取对应的value,若当前Map中没有给定的key,则返回值为null
*/
value = map.get("数学");
System.out.println("数学:"+value); //数学:23
value = map.get("体育");
System.out.println("体育:"+value); //体育:null
/*
V remove(K k)
删除给定的key所对应的key-value对
返回值为被删除的key-value对中的value
*/
value = map.remove("数学");
System.out.println(value); //23
System.out.println(map); //{物理=45, 化学=45, 语文=90, 英语=75}
}
}
import java.util.Objects;
/**
* 当一个类的实例作为HashMap的key时,它的equals方法与hashcode方法的重写直接影响着散列表(HashMap)的查询性能
* 在API文档中Object对这两个方法的重写做了说明:
* 当我们重写一个类的equals方法时,就应当连着重写hashcode方法
* 这两个方法重写应当遵循:
* 1:一致性,当两个对象equals比较为true时,hashcode方法返回的数字必须相等
* 反过来虽然不是必须的,也应当遵循,否则在HashMap中会形成链表影响性能
* 所以两个对象hashcode值相同,equals比较也应当为true
* 2:稳定性:hashcode方法多次调用后返回的数字应当相同,不应是一个变化的值
* 除非参与equals比较的属性值发生了改变
*/
public class Key {
private int x;
private int y;
public Key(int x, int y){
super();
this.x = x;
this.y = y;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Key keyDemo = (Key) o;
return x == keyDemo.x && y == keyDemo.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
}
(1)Map集合是面向查询优化的数据结构,在大数据量情况下有优良的查询性能
(2)用于根据Key检索value的业务场景:
用户登录数据缓冲:用户名是Key,用户对象是value,在登录验证时根据用户名快速查询用户信息
登录会话状态保持:在网站编程中,用户会话状态保持经常采用Map存储,可以快速在数以万计的信息中快速确认用户是否已经登录
(1)Capacity:容量,hash表里bucket(桶)的数量,也就是散列数组大小
(2)Intital capacity:初始容量,创建hash表时,初始bucket的数量,默认构建容量是16,也可以使用特定容量
(3)Load factor:加载因子,默认值0.75(就是75%),当向散列表增加数据时如果size/capacity的值大于Load factor则发生扩容并且重新散列(rehash)
性能优化:加载因子较小时,散列查栈性能会提高,同时也浪费了散列桶空间容量。0.75是性能和空间相对平衡结果。在创建散列表时指定合理容量,减少rehash提高性能
(1)遍历所有的key
(2)遍历所有的key-value对
(3)遍历所有的value(相对不常用
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 遍历Map三种方式:遍历所有的key、遍历所有的key-value对、遍历所有的value(相对不常用)
*/
public class MapDemo01 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("语文",45);
map.put("数学",23);
map.put("英语",75);
map.put("物理",45);
map.put("化学",45);
System.out.println(map); //{物理=45, 数学=23, 化学=45, 语文=45, 英语=75}
/*
遍历所有的key
Set keySet()
该方法会将当前Map中所有的key存入一个Set集合后返回
那么遍历该集合就等于遍历了所有的key
*/
Set<String> keySet = map.keySet();
for(String key:keySet){
System.out.print("key:"+key+" "); //key:物理 key:数学 key:化学 key:语文 key:英语
}
System.out.println();
/*
遍历每一组键值对
Map中每一组键值对都是由Map的内部类:
java.util.Map.Entry的一个实例表示的。
Entry有两个方法:getKey、getValue,可以分别获取这一组键值对中的key与value
Set entrySet
该方法会将Map中每一组键值对(Entry实例)存入一个Set集合后返回
*/
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
for (Map.Entry<String,Integer> e:entrySet){
String key = e.getKey();
Integer value = e.getValue();
System.out.print(key+":"+value+" "); //物理:45 数学:23 化学:45 语文:45 英语:75
}
System.out.println();
/*
遍历所有的value
Collection values()
该方法会将当前Map中所有的value存入一个集合后返回
*/
Collection<Integer> values = map.values();
for(Integer value : values){
System.out.print("value:"+value+" "); //value:45 value:23 value:45 value:45 value:75
}
}
}