map类型对比
HashMap：遍历时，获取数据的顺序完全随机；不支持线程同步；
LinkedHashMap：可以保存记录的插入顺序，遍历输出的顺序和插入的顺序一致；
TreeMap：遍历时，保存的记录可以根据键自动排序；
HashTable：支持线程同步；不允许记录的键或者值为空；
public class mapTest {
public static void main(String args[]){
System.out.println("*************************LinkedHashMap*************");
Map<Integer,String> map = new LinkedHashMap<Integer,String>();
map.put(7, "阿里");
map.put(9, "腾讯");
map.put(6,"百度");
for (Iterator it = map.keySet().iterator(); it.hasNext();)
{
Object key = it.next();
System.out.println( key+"="+ map.get(key));
}
System.out.println("*************************HashMap*************");
Map<String,String> map1 = new HashMap<String, String>();
map1.put("7", "阿里");
map1.put("9", "腾讯");
map1.put("6", "百度");
for(Iterator it1 = map1.keySet().iterator();it1.hasNext();){
Object key = it1.next();
System.out.println(key+"="+map1.get(key));
}
System.out.println("*************************TreeMap*************");
Map<Integer,String> map2 = new TreeMap<Integer, String>();
map2.put(7, "阿里");
map2.put(9, "腾讯");
map2.put(6, "百度");
for(Iterator it2 = map2.keySet().iterator();it2.hasNext();){
Object key = it2.next();
System.out.println(key+"="+map2.get(key));
}
}
}
运行结果如下：
HashMap的遍历方法
public static void main(String args[]){
System.out.println("*************************LinkedHashMap*************");
Map<Integer,String> map = new LinkedHashMap<Integer,String>();
map.put(7, "阿里");
map.put(9, "腾讯");
map.put(6,"百度");
//遍历map
//方法1.1，keySet遍历,同时获取key和value：6=百度
for (Iterator it = map.keySet().iterator(); it.hasNext();)
{
Object key = it.next();
System.out.println( key+"="+ map.get(key));
}
//方法1.2,keySet遍历,只需要map的key或者value
// //KeySet 获取key
// for (Integer key : map.keySet()) {
// System.out.println(key);
// }
// // values 获取value
// for (String value : map.values()) {
// System.out.println(value);
// }
//方法2,Iterator遍历,可删除元素：Key: 7; Value: 阿里
// Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
// while (it.hasNext()) {
// Map.Entry<Integer, String> e2 = it.next();
// // e2.remove(); 删除元素
// System.out.println("Key: " + e2.getKey() + "; Value: " + e2.getValue());
// }
//方法3，entrySet遍历, 同时获取key，value，推荐使用
// for (Map.Entry<Integer, String> entry : map.entrySet()) {
// System.out.println(entry.getKey() + ":" + entry.getValue());
// }
//方法4，Lambda遍历，性能低于entrySet
// map.forEach((key, value) -> {
// System.out.println(key + ":" + value);
// });
｝
Set类型对比
HashSet：遍历时，获取数据的顺序完全随机；不支持线程同步；
LinkedHashSet：可以保存记录的插入顺序，遍历输出的顺序和插入的顺序一致；
TreeSet：遍历时，保存的记录可以根据键自动排序；
HastSet和TreeSet是Set的两种典型：一般我们首选HashSet，当我们需要保持一个排序的set时，才选择TreeSet。由于TreeSet需要红黑树来维护元素次序，所有HashSet比TreeSet的性能更好。
而LinkedHashSet是HashSet的一个子类，LinkedHashSet的底层实现是链表，所以可以维护元素的插入顺序，因此遍历LinkedHashSet会更快；但对于普通的插入、删除等操作，HashSet效率更高。
从三种Set集合和Map集合对比来看，Set和Map惊人的相似。其实从Java源码看，Java是先实现了Map，然后通过包装一个所有value都为Null的Map就实现了Set集合。所以Map子类和Set子类名字相似、Map里key集和Set集合里元素的存储形式也相似、且Set和Map子类功能也相似。
/**
* Set集合
* @param args
*/
public static void main(String args[]){
//LinkedHashSet：可以保存记录的插入顺序，遍历输出的顺序和插入的顺序一致；
System.out.println("*************************LinkedHashSet*************");
LinkedHashSet set0 = new LinkedHashSet();
set0.add(7);
set0.add(9);
set0.add(6);
set0.add(8);
set0.add(null);
System.out.println(set0);
//HashSet：遍历时，获取数据的顺序完全随机；不支持线程同步；
System.out.println("*************************HashSet*************");
HashSet set1 = new HashSet();
set1.add(7);
set1.add(9);
set1.add(6);
set1.add(8);
set1.add(null);
System.out.println(set1);
//TreeSet：遍历时，保存的记录可以根据键自动排序；
System.out.println("*************************TreeSet*************");
//1、自然排序,元素对象默认实现Comparator接口
TreeSet set2 = new TreeSet();
set2.add(7);
set2.add(9);
set2.add(6);
set2.add(8);
System.out.println(set2);
//2、定制排序，元素对象不需要实现接口，创建set集合时提供Comparator接口与集合关联
}
}
运行结果如下：
List集合对比
ArrayList：是基于数组的线性表，随机访问时性能好，使用随机访问法(get)遍历较好
LinkedList：是基于链表的线性表，执行删除、插入时性能比较好，使用迭代器Iterator遍历较好
PriorityQueue：队列实现类，元素顺序是按队列元素大小进行排序，所以并不是标准队列，不符合先进先出
ArrayDeque：双端队列，允许从两端来操作；还可以当栈使用(pop()/push())
/**
* List集合
* @param args
*/
public static void main(String args[]){
//ArrayList：是基于数组的线性表，随机访问时性能好，使用随机访问法(get)遍历较好
System.out.println("*************************LinkedHashSet*************");
List list0 = new ArrayList();
list0.add(7);
list0.add(9);
list0.add(6);
list0.add(8);
list0.add(null);
//for(int i = 0;i <list0.size(); i++){
// System.out.println(list0.get(i));
// }
System.out.println(list0);
//LinkedList：是基于链表的线性表，执行删除、插入时性能比较好，使用迭代器Iterator遍历较好
//是Lint接口实现类，可以当list；还实现了deque接口，可以当双端队列，也可以当栈
System.out.println("*************************LinkedList*************");
LinkedList list1 = new LinkedList();
//------------------------预想排在第三位
list1.add(7);
list1.offer(9);
//栈顶部------------------预想排在第二位
list1.push(6);
//队列头部(相当于栈顶部)--预想排在第一位
list1.offerFirst(8);
//队列尾部
list1.offerLast(null);
//for (Iterator<Integer> iterator = list1.iterator(); iterator.hasNext();) {
// System.out.println(iterator.next());
//}
System.out.println(list1);
//PriorityQueue：队列实现类，元素顺序是按队列元素大小进行排序，所以并不是标准队列，不符合先进先出
System.out.println("*************************PriorityQueue*************");
//1、自然排序,元素对象默认实现Comparator接口
PriorityQueue queue = new PriorityQueue();
queue.offer(7);
queue.offer(9);
queue.offer(6);
queue.offer(8);
System.out.println(queue);
//2、定制排序，元素对象不需要实现接口，创建set集合时提供Comparator接口与集合关联
//ArrayDeque：双端队列，允许从两端来操作；还可以当栈使用(pop()/push())
//程序需要使用栈时，推荐使用ArrayDeque，尽量避免使用stack
System.out.println("*************************ArrayDeque*************");
//1、自然排序,元素对象默认实现Comparator接口
ArrayDeque deque = new ArrayDeque();
deque.offer(7);
deque.offer(9);
deque.offer(6);
deque.offer(8);
//访问第一个，但并不将第一个元素删除出栈
System.out.println(queue.peek());
//访问第一个，但将第一个元素删除出栈????????为什么没有pop()方法
//System.out.println(queue.pop());
System.out.println(queue);
}
}
3277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
