java集合

package map;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
 

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		
		//arrayListDemo();//线程不安全 随机访问效率高，随机插入(效率低因为要扩容)、随机删除效率低
		//Vector 和arrayList类似,但线程安全 
		//linkListDemo();//线程不安全 随机访问效率低，但随机插入、随机删除效率高
		//stackDemo();和linkList类似 LIFO(后进先出),

		
		
		/*
		 * MAP key无序 不能重复,
		 Map提供接口分别用于返回 键集、值集或键-值映射关系集。
        entrySet()用于返回键-值集的Set集合
        keySet()用于返回键集的Set集合
       values()用户返回值集的Collection集合
       因为Map中不能包含重复的键；每个键最多只能映射到一个值。所以，键-值集、键集都是Set，值集时Collection。


		 * 
		 * */
		
		hashMapDemo();//线程不安全，允许null
		//hashtableDemo();和hashmap类似，线程安全，不允许null
		//treeMapDemo 排序的时候用
		
		
		
		
		hashSetDemo();
		
		
	}
	

	public static void arrayDemo(){
		System.out.println("ssssss");
	}
	
	public static void arrayListDemo(){
		// ArrayList通过一个数组去保存数据,默认是10个单元,每次扩容=原始容量*1.5+1
		ArrayList<String> al = new ArrayList<String>();
		al.add("bomb");
		al.add("missile");
		al.add("gun");
		al.add("tank");
		
		System.out.println("bomb = "+al.get(0));
		 
		al.remove(2);
		al.add(2, "ship");//可指定位置,覆盖
		al.add("missile");//可重复
		
		System.out.println("contain bomb ? "+al.contains("bomb"));//查找存在
		
		
		//迭代器遍历 低效
		Iterator<String> iterator = al.iterator();
		while (iterator.hasNext()) {
			System.out.println("Iterator item = "+iterator.next());
		}
		//下标访问 高效
		int size=al.size();
		for(int i=0;i<size;i++){
			System.out.println("Index item = "+al.get(i));
		}
		//for循环 中效
		for(String str:al ){
			System.out.println("For item = "+str);
		}
		
		//查找indexOf 反向查找lastIndexOf
		System.out.println("Index of first missile "+al.indexOf("missile"));
		System.out.println("Index of last missile "+al.lastIndexOf("missile"));
		
		//转数组
		String[] arr = (String[])al.toArray(new String[0]);
		for (String str:arr)
			System.out.println("toArray "+ str);
		
		al.clear();
		System.out.println("Is empty ? "+ al.isEmpty());
	}
	
	public static void linkListDemo(){
		LinkedList<String> ll = new LinkedList<String>();
		ll.add("a");
		ll.add("b");
		ll.add("c");
		ll.addFirst("f");//原有会往后移
		System.out.println("getFirst():"+ll.getFirst());
		ll.removeFirst();
		ll.addLast("l");
		ll.removeLast();
		
		ll.set(2, "s");//低效 不要用下标访问linkList,包括get(i)
		System.out.println("ll is "+ll);
		System.out.println("pollFirst():"+ll.pollFirst());//输出第一个元素并删除该元素
		System.out.println("peekFirst():"+ll.peekFirst());//输出第一个元素
		System.out.println("ll is "+ll);
		
		
		
		//LIFO(后进先出)的堆栈
		ll.push("s1");
		ll.push("s2");
		ll.push("s3");
		
		System.out.println("pop "+ll.pop());
		System.out.println("ll is "+ll);
		
		
		
	}
	
	public static void hashMapDemo() {
		HashMap<String, String> hm = new HashMap<String, String>();
		hm.put("k1", "v1");
		hm.put("k2", "v2");
		hm.put("k3", "v3");
		hm.put("k4", "v4");
		
		Iterator<Entry<String,String>> iter = hm.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry<String, String> entry = iter.next();
			System.out.println("key "+entry.getKey()+"  value "+entry.getValue());
			
		}
		System.out.println("key contains k4 ? "+hm.containsKey("k4"));
		System.out.println("value contains v3 ? "+hm.containsValue("v3"));
		
		hm.remove("k3");
		
		 System.out.println("hm "+hm );
	}
	
	public static void hashSetDemo() {
		HashSet<String> hs = new HashSet<String>();
		
		hs.add("aaaa");
		hs.add("bbbb");
		hs.add("cccc");
		
		for(Iterator<String> iter = hs.iterator();iter.hasNext();)
				System.out.println("item "+ iter.next());
	}
	
}