Arraylist、HashSet去重複 treeSet排列實現方法 HashMap遍歷取值

java提供的Arraylist自己不能對添加的元素進行去重，須要在添加後進行比較，若是相同就不添加

public static ArrayList single(ArrayList al) {
		
		ArrayList temp = new ArrayList();

		Iterator it = al.iterator();
		
		while(it.hasNext()){
			Object obj = it.next();
	
			if(!temp.contains(obj)){  //若是元素已經存在就不添加 確保不重複
				temp.add(obj);
			}
		}
		
		return temp;
	}

java裏Hashset默承認以自動對字符型等簡單對象進行去重複，如

public static void main(String[] args) {

		HashSet hs = new HashSet();
		
		hs.add("hehe");
		hs.add("xixii");
		hs.add("hehe");
		
		Iterator it = hs.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

HashSet判斷是否重複時，先判斷HashCode是否同樣，兩個對象hashcode不相等，他們必定不equals。兩個對象hashcode相等，他們不必定equals，還須要進一步判斷。再重寫equals方法，步驟

1.  判斷傳入的對象是否爲空，若是爲空，沒有比較的必要 返回false

2.  判斷當前對象是否和傳入對象是同一個對象，若是是一個對象，沒有必要比較，返回true

3.  判斷當前對象是否和傳入的對象類型相同，若是不一樣，沒有比較的意義 返回false

4. 若是當前對象和傳入對象類型相同（傳入對象能夠是相同或者子類），將傳入的對象強制轉換爲當前對象類型

5. 逐個的來比較對象中的每個屬性值（對象的比較用equals()方法，基本類型用==，double,float 有精度損失的，能夠將其轉換成對應的Double,Float後在調用equals()進行比較）

public class Person {
        
        private String name;
	private int age;
        
        public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	public int hashCode() {	
		return name.hashCode()+age*27;  //不一樣對象產生不一樣的hashcode 不會調用equals提升效率
	}
        
        @Override	
	public boolean equals(Object obj) {
		
		if(this == obj)   //判斷是否爲同一個對象 是返回 true 證實已經存在
			return true;
		if(!(obj instanceof Person))  //不是同一對象 判斷是否 隸屬於 person類對象
			throw new ClassCastException("類型錯誤"); //不是拋出異常
		
		Person p = (Person)obj;  //轉換爲 Person類型
		
		return this.name.equals(p.name) && this.age == p.age; //返回 是否存在
	}
}

排序有兩種實現方式：comparable和Comparator

第一種 comparable 排序

TreeSet排序  實現comparable接口 只有TreeSet能夠排序 HashSet不能夠，全部的set均可以去重複

public class Person implements Comparable<Person> {

    ........
    ........
    
    public int compareTo(Person p){
		
	int temp = this.age - p.age;  //按年齡排序
	return temp==0?this.name.compareTo(p.name):temp;   //年齡相同按姓名排序
    }
	
}

例子

public static void main(String[] args) {

	TreeSet ts = new TreeSet();  //TreeSet對象
		
	ts.add(new Person("zhangsan",28));
	ts.add(new Person("lisi",21));
	ts.add(new Person("wangu",24));
	ts.add(new Person("zangu",24));
		
	Iterator it = ts.iterator();		
	while(it.hasNext()){
		Person p = (Person)it.next();
			
		System.out.println(p.getName()+":"+p.getAge());
	}
	
}
先按年齡 相同年齡 再按姓名。
結果：lisi 21
      wanggu 24
      zangu  24
      zhangsan 28

第2種 comparator排序

public class ComparatorByName implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {

		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		
		int temp = p1.getName().compareTo(p2.getName());  //先按姓名	
		return temp==0?p1.getAge()-p2.getAge(): temp;     //再按年齡排
	}
}

public static void main(String[] args) {

	TreeSet ts = new TreeSet(new ComparatorByName());	
		
	ts.add(new Person("zhangsan",28));
	ts.add(new Person("lisi",21));
	ts.add(new Person("zangu",24));
	ts.add(new Person("zangu",26));
		
	Iterator it = ts.iterator();
		
	while(it.hasNext()){
		Person p = (Person)it.next();			
		System.out.println(p.getName()+":"+p.getAge());
	}	
}
結果：lisi 21
      zangu 24
      zangu 26
      zhangsan 28

map鍵值對  遍歷值的獲取  

entrySet能夠直接獲取 key和value keySet() 先得到key 而後經過get(key)得到value值

public static void method(Map<Integer,String> map){
	
	Map<Integer,String> map = new HashMap<Integer,String>();	
	map.put(8,"zhaoliu");
	map.put(2,"zhaoliu");
	map.put(7,"xiaoqiang");
	map.put(6,"wangcai");
				
	Collection<String> values = map.values();  //得到value值
		
	Iterator<String> it2 = values.iterator();
	while(it2.hasNext()){
		System.out.println(it2.next());
	}
		
	Set<Map.Entry<Integer, String>> entrySet = map.entrySet();  //
		
	Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
		
	while(it.hasNext()){
		Map.Entry<Integer, String> me = it.next();
		Integer key = me.getKey();        //得到key
		String value = me.getValue();     //得到value
		System.out.println(key+"::::"+value);			
	}
		
	Set<Integer> keySet = map.keySet();
	Iterator<Integer> it = keySet.iterator();
		
	while(it.hasNext()){
		Integer key = it.next();
		String value = map.get(key);
		System.out.println(key+":"+value);		
	}
}

HashMap 每一個key 只有一個value 最後一次key的value會從新之前的value。

keySet實現HashMap遍歷 

public static void main(String[] args) {

	HashMap<Student,String> hm = new HashMap<Student,String>();
	
	hm.put(new Student("lisi",38),"北京");
	hm.put(new Student("zhaoliu",24),"上海");
	hm.put(new Student("zhaoliu",24),"鐵嶺");
		
	Iterator<Student> it = hm.keySet().iterator();
		
	while(it.hasNext()){
		Student key = it.next();      //先獲得key
		String value = hm.get(key);   //根據key得到value
		System.out.println(key.getName()+":"+key.getAge()+"---"+value);
	}	
}

輸出結果 lisi 38 北京

            zhaoliu 24 鐵嶺   //替換了前面的 上海的那個

TreeMap也能夠實現排列 Comparator，方式與TreeSet同樣，這裏就不介紹了