一、队列
队列(Queue)是常用的数据结构,可以将队列看成特殊的线性表,队列限制了对线性表的访问方式:只能从线性表的一端添加(offer)元素,从另一端取出(poll)元素。
队列遵循先进先出(FIFO First Input First Output)的原则。
JDK中提供了Queue接口,同时使得LinkedList实现了该接口(选择LinkedList实现Queue的原因在于Queue经常要进行添加和删除的操作,而LinkedList在这方面效率较高。)
Queue接口中主要方法如下:
boolean offer(E e); —— 将一个对象添加至队尾,如果添加成功则返回true。
E poll(); —— 从队首删除并返回一个元素。
E peek(); —— 返回队首的元素(但并不删除)。
package day05;
import java.util.LinkedList;
import java.util.Queue;
/**
* 队列
* 队列也可以存放一组元素,但是存取元素必须遵循:先进先出原则。
* @author xxx
*/
public class QueueDemo {
public static void main(String[] args) {
Queue<String> queue = new LinkedList<String>();
/*
*boolean offer(E e)
*入队操作,向队尾追加一个新元素。
*/
queue.offer("one");
queue.offer("two");
queue.offer("three");
queue.offer("four");
System.out.println(queue);
/*
* E poll()
* 出队操作,从队首获取元素,获取后该元素就从队列中被删除了。
*/
String str = queue.poll();
System.out.println(str);
System.out.println(queue);
/*
* E peek()
* 引用队首元素,但是不做出队操作
*/
str = queue.peek();
System.out.println(str);
System.out.println(queue);
/*
* 注意:queue.size()是会变的,随着取出的元素的个数越来越多,size的值会越来越小。
* 所以,这里要倒着遍历,正着的话则不会遍历完。
*/
/*for (int i = queue.size();i > 0;i--) {
str = queue.poll();
System.out.println("元素:"+str);
}*/
while (queue.size() > 0) {
str = queue.poll();
System.out.println("元素:"+str);
}
}
}
二、栈
Deque是Queue的子接口,定义了所谓“双端队列”,即从队列的两端分别可以入队(offer)和出队(poll),LinkedList实现了该接口。
如果将Deque限制为只能从一端入队和出队,则可实现“栈”(stack)的数据结构,对于栈而言,入栈称之为push,出栈称之为pop。
栈遵循先进后出(FILO First Input Last Output)的原则。
package day05;
import java.util.Deque;
import java.util.LinkedList;
/**
* 栈,存储一组元素,但是存取元素必须遵循先进后出原则。
* 通常为了实现后退这类功能时会使用栈。
* @author xxx
*
*/
public class StackDemo {
public static void main(String[] args) {
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);
/*
* 出栈操作
* E pop()
*/
String str = stack.pop();
System.out.println(str);
System.out.println(stack);
str = stack.peek();
System.out.println(str);
System.out.println(stack);
while (stack.size() > 0) {
str = stack.pop();
System.out.println(str);
}
System.out.println(stack);
}
}
三、查找表
Map接口定义的集合又称查找表,用于存储所谓“Key-Value”映射对。Key可以看成是Value的索引,作为Key的对象在集合中不可以重复。
根据内部数据结构的不同,Map接口有多种实现类,其中常用的有内部为hash表实现的HashMap和内部为排序二叉树实现的TreeMap。
2.1、Map的基本操作
package day05;
import java.util.HashMap;
import java.util.Map;
/**
* java.util.Map
* Map看起来像是一个多行两列的表格。以key-value对的形式存放元素。
* 在Map中key不允许重复(重复是依靠key的equals判断)
* 常用的实现类为:HashMap
* @author xxx
*
*/
public class MapDemo1 {
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("语文", 99);
System.out.println("old:"+value);
map.put("数学", 99);
map.put("英语", 90);
map.put("物理", 98);
map.put("化学", 96);
value = map.put("语文", 98);
System.out.println(map);
System.out.println("old:"+value);
/*
* V get(K k)
* 根据给定的key获取对应的value,若当前Map中没有
* 给定的key,则返回值为null。
*/
value = map.get("数学");
System.out.println("数学:"+value);
value = map.get("体育");
System.out.println("体育:"+value);
/*
* V remove(K k)
* 删除给定的key所对应的key-value对。
* 返回值为被删除的key-value对中的value值。
*/
System.out.println("删除数学");
value = map.remove("数学");
System.out.println(map);
System.out.println("old:"+value);
}
}
Map接口中定义了判断某个key是否在Map中存在的方法:boolean containsKey(Object key)
。若Map中包含给定的key则返回true,否则返回false。
2.2、Map的遍历
package day05;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 遍历Map
* 遍历Map有三种方式:
* 遍历所有的key
* 遍历所有的key-value对
* 遍历所有的value(相对不常用)
* @author xxx
*
*/
public class MapDemo2 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("语文", 99);
map.put("数学", 98);
map.put("英语", 96);
map.put("物理", 95);
map.put("化学", 92);
System.out.println(map);
/*
* 遍历所有的key
* Set<K> keyset()
* 该方法会将当前Map中所有的key存入一个Set集合后返回。那么遍历该集合就等于遍历
* 了所有的key
*/
Set<String> keySet = map.keySet();
for (String key:keySet) {
System.out.println("key:"+key);
}
/*
* 遍历每一组键值对
* Map中每一组键值对都是由Map的内部类:
* java.util.Map.Entry的一个实例表示的。
* Entry有两个方法:getKey,getValue,可以分别获取这一组键值对中的key与value。
*
* Set<Entry> entrySet
* 该方法会将Map中每一组键值对(Entry实例)
* 存入一个Set集合后返回。
*/
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String,Integer> e:entrySet) {
String key = e.getKey();
Integer value = e.getValue();
System.out.println(key+":"+value);
}
/*
* 遍历所有的value
* Collection values()
* 该方法会将当前Map中所有的value存入一个集合后返回。
*/
Collection<Integer> values = map.values();
for (Integer value:values) {
System.out.println("value:"+value);
}
}
}
2.3、equals方法和hashcode方法的重写
一般情况下,可以用Eclipse自动生成equals方法和hashcode方法的重写。
package day05;
/**
* 当一个类的实例作为HashMap的key时,它的equals方法与hashcode方法的重写
* 直接影响着散列表(HashMap)的查询性能。
* 在API文档中Object对这两个方法的重写做了说明:
* 当我们重写一个类的equals方法时,就应当连同重写hashcode方法。
* 这两个方法重写应当遵循:
* 1、一致性,当两个对象equals比较为true时,hashcode方法返回的数字必须相等。反过来虽然不是必须的,
* 但也应当遵循,否则在hashMap中会形成链表影响查询性能。所以两个对象hashcode值相同,equals比较
* 也应当为true。
* 2、稳定性:hashcode方法多次调用后返回的数字应当相同,不应是一个变化的值,除非参与equals比较的属性值发生了改变。
* @author xxx
*
*/
public class Key {
private int x;
private int y;
public Key(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Key other = (Key) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
}
2.4、装载因子及HashMap优化
- Capacity:容量,hash表里bucket(桶)的数量,也就是散列数组的大小。
- Initial capacity:初始容量,创建hash表时,初始bucket的数量,默认构建容量是16,也可以使用特定容量。
- Size:大小,当前散列表中存储数据的数量。
- Load factor:加载因子,默认值0.75(就是75%),当向散列表增加数据时如果size/capacity的值大于Load factor则发生扩容并且重新散列(rehash)。
- 性能优化:加载因子较小时,散列查找性能会提高,同时也浪费了散列桶空间容量。0.75是性能和空间相对平衡结果。在创建散列表时指定合理容量,减少rehash提高性能。