Stack类

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
堆栈只定义了默认构造函数，用来创建一个空栈。

Stack()

除了由Vector定义的所有方法，自己也定义了一些方法：

boolean empty();
//测试堆栈是否为空。
Object peek();
//查看堆栈顶部的对象，但不从堆栈中移除它。
Object pop();
//移除堆栈顶部的对象，并作为此函数的值返回该对象。
Object push(Object element);
//把项压入堆栈顶部。
int search(Object element);
//返回对象在堆栈中的位置，以 1 为基数。

示例：

import java.util.Stack;
import java.util.Iterator;
import java.util.List;

/**
 * @desc Stack的测试程序。测试常用API的用法
 *
 * @author skywang
 */
public class StackTest {
    public static void main(String[] args) {
        Stack stack = new Stack();
        // 将1,2,3,4,5添加到栈中
        for(int i=1; i<6; i++) {
            stack.push(String.valueOf(i));
        }

        // 遍历并打印出该栈
        iteratorThroughRandomAccess(stack) ;

        // 查找“2”在栈中的位置，并输出
        int pos = stack.search("2");
        System.out.println("the postion of 2 is:"+pos);

        // pup栈顶元素之后，遍历栈
        stack.pop();
        iteratorThroughRandomAccess(stack) ;

        // peek栈顶元素之后，遍历栈
        String val = (String)stack.peek();
        System.out.println("peek:"+val);
        iteratorThroughRandomAccess(stack) ;

        // 通过Iterator去遍历Stack
        iteratorThroughIterator(stack) ;
    }

    /**
     * 通过快速访问遍历Stack
     */
    public static void iteratorThroughRandomAccess(List list) {
        String val = null;
        for (int i=0; i<list.size(); i++) {
            val = (String)list.get(i);
            System.out.print(val+" ");
        }
        System.out.println();
    }

    /**
     * 通过迭代器遍历Stack
     */
    public static void iteratorThroughIterator(List list) {

        String val = null;
        for(Iterator iter = list.iterator(); iter.hasNext(); ) {
            val = (String)iter.next();
            System.out.print(val+" ");
        }
        System.out.println();
    }
}

输出结果：

1 2 3 4 5 
the postion of 2 is:4
1 2 3 4 
peek:4
1 2 3 4 
1 2 3 4 

Map接口

Java 自带了各种 Map 类。其中通用Map，用于在应用程序中管理映射，通常在 java.util 程序包中实现HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap。

HashMap：

最常用的Map，它根据键的HashCode 值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖)；允许多条记录的值为 Null。是非同步的。

TreeMap：

能够把它保存的记录根据键(key)排序，默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。是非同步的。

Hashtable：

与 HashMap类似，不同的是:key和value的值均不允许为null；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢。

LinkedHashMap：

保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，是非同步的。

常用接口：

void clear();
//从此映射中移除所有映射关系（可选操作）。
boolean containsKey(Object k);
//如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object v);
//如果此映射将一个或多个键映射到指定值，则返回true。
Set entrySet();
//返回此映射中包含的映射关系的 Set 视图。
boolean equals(Object obj);
//比较指定的对象与此映射是否相等。
Object get(Object k);
//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int hashCode();
//返回此映射的哈希码值。
boolean isEmpty();
//如果此映射未包含键-值映射关系，则返回 true。
Set keySet();
//返回此映射中包含的键的 Set 视图。
Object put(Object k, Object v);
//将指定的值与此映射中的指定键关联（可选操作）。
void putAll(Map m);
//从指定映射中将所有映射关系复制到此映射中（可选操作）。
Object remove(Object k);
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int size();
//返回此映射中的键-值映射关系数。
Collection values();
//返回此映射中包含的值的 Collection 视图。

四种常用Map插入与读取性能比较

引用自：https://www.cnblogs.com/lzq198754/p/5780165.html
测试环境：jdk1.7.0_80
测试结果：结果单位为ms，结果为程序10次运行平均值。

Map对象遍历

引用自：https://www.cnblogs.com/fqfanqi/p/6187085.html
方式一 ：使用entrySet()遍历
这是最常见的并且在大多数情况下也是最可取的遍历方式，在键值都需要时使用。

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
for (Map.Entry<Integer, Integer> entry : map.entrySet()) { 
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); 
}

方法二：在for-each循环中遍历keys或values。

如果只需要map中的键或者值，你可以通过keySet或values来实现遍历，而不是用entrySet。

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
//遍历map中的键 
for (Integer key : map.keySet()) { 
  System.out.println("Key = " + key); 
} 
//遍历map中的值 
for (Integer value : map.values()) { 
  System.out.println("Value = " + value); 
}

该方法比entrySet遍历在性能上稍好（快了10%），而且代码更加干净。

方法三：使用Iterator遍历

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); 
while (entries.hasNext()) { 
  Map.Entry<Integer, Integer> entry = entries.next(); 
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); 
}

不使用泛型：

Map map = new HashMap(); 
Iterator entries = map.entrySet().iterator(); 
while (entries.hasNext()) { 
  Map.Entry entry = (Map.Entry) entries.next(); 
  Integer key = (Integer)entry.getKey(); 
  Integer value = (Integer)entry.getValue(); 
  System.out.println("Key = " + key + ", Value = " + value); 
}

你也可以在keySet和values上应用同样的方法。

该种方式看起来冗余却有其优点所在。首先，在老版本java中这是惟一遍历map的方式。另一个好处是，你可以在遍历时调用iterator.remove()来删除entries，另两个方法则不能。根据javadoc的说明，如果在for-each遍历中尝试使用此方法，结果是不可预测的。

从性能方面看，该方法类同于for-each遍历（即方法二）的性能。

方法四、通过键找值遍历（效率低）

Map<Integer, Integer> map = new HashMap<Integer, Integer>(); 
for (Integer key : map.keySet()) { 
  Integer value = map.get(key); 
  System.out.println("Key = " + key + ", Value = " + value);

作为方法一的替代，这个代码看上去更加干净；但实际上它相当慢且无效率。因为从键取值是耗时的操作（与方法一相比，在不同的Map实现中该方法慢了20%~200%）。如果你安装了FindBugs，它会做出检查并警告你关于哪些是低效率的遍历。所以尽量避免使用。

总结
如果仅需要键(keys)或值(values)使用方法二。如果你使用的语言版本低于java 5，或是打算在遍历时删除entries，必须使用方法三。否则使用方法一(键值都要)。

Map排序

HashMap、Hashtable、LinkedHashMap排序

Map<String, String> map = new HashMap<String, String>();
map.put("a", "c");
map.put("b", "b");
map.put("c", "a");

// 通过ArrayList构造函数把map.entrySet()转换成list
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
// 通过比较器实现比较排序
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
        return mapping1.getKey().compareTo(mapping2.getKey());
    }
});

for (Map.Entry<String, String> mapping : list) {
    System.out.println(mapping.getKey() + " ：" + mapping.getValue());
}

注：TreeMap也可以使用此方法进行排序，但是更推荐后面介绍的方法。

TreeMap排序

TreeMap默认按key进行升序排序，如果想改变默认的顺序，可以使用比较器。如下：

Map<String, String> map = new TreeMap<String, String>(new Comparator<String>() {
    public int compare(String obj1, String obj2) {
        return obj2.compareTo(obj1);// 降序排序
    }
});
map.put("a", "c");
map.put("b", "b");
map.put("c", "a");

for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

按value排序(通用)

Map<String, String> map = new TreeMap<String, String>();
map.put("a", "c");
map.put("b", "b");
map.put("c", "a");

// 通过ArrayList构造函数把map.entrySet()转换成list
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
// 通过比较器实现比较排序
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
        return mapping1.getValue().compareTo(mapping2.getValue());
    }
});

for (String key : map.keySet()) {
    System.out.println(key + " ：" + map.get(key));
}

参考：
1.http://www.runoob.com/java/java-stack-class.html
2.https://www.cnblogs.com/skywang12345/p/3308852.html
3.https://www.cnblogs.com/lzq198754/p/5780165.html
4.https://www.cnblogs.com/fqfanqi/p/6187085.html