Java 集合類的細節

java集合類

1.Collection，Map層次圖

2.Collection接口

list

存放有序且容許重複的集合的接口  這裏的有序是指存入順序和取出順序相同。子類有：{ ArrayList,LinkedList}  

ArrayList： 是經過數組結構實現的List集合 (經過索引值快速取出數據) 刪除，插入慢，可以使用for語句遍歷
        　　　　 public Object get(int index)　　　　　　　　 　　返回列表中指定位置的元素
         　　　　public void add(int index, Object element) 　　在列表的指定位置插入指定元素.將當前處於該位置的元素（若是有的話）和全部後續元素向右移動
       　　　　  public Object set(int index, Object element)  用指定元素替換列表中指定位置的元素,返回替換出來的元素
        　　　　 public Object remove(int index)  　　　　　　　　移除列表中指定位置的元素
        　　　　 List subList(int fromIndex, int toIndex) 　　　 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。
       　　　　  int indexOf(Object o) 　　　　　　　　　　　　返回此列表中第一次出現的指定元素的索引；若是此列表不包含該元素，則返回 -1。

LinkedList: 是經過使用雙向鏈表實現的List集合(毫無疑問，LinkedList對於頻繁的插入刪除有着較好的效率，
　　　　　　　適合實現棧(Stack)和隊列(Queue)。可以使用for語句遍歷

         　　void addFirst(E e)   　　  將指定元素插入此雙端隊列的開頭。
        　　 void addLast(E e) 　　　　 將指定元素添加到此列表的結尾。等效於add(E e)
         　　E getFirst() 　　　　　　　 返回此列表的第一個元素,等效於element(),只看不動.
         　　E getLast() 　　　　　　　　返回此列表的最後一個元素。只看不動.

set

存放無序且不包含重複元素的集合的接口。子類：{HashSet SorterSet}實現類：{ LinkedHashSet, TreeSet} 

LinkHashSet:

　　根據元素的哈希碼進行存放，同時用鏈表記錄元素的加入順序。 不能使用for語句遍歷,可使用foreach，Iterator

TreeSet:

 TreeSet使用紅黑樹結構對加入的元素進行排序存放,輸出時也會按排序後的順序,因此放入TreeSet中元素必須是」可排序的」
 兩個對象判斷是否重複是經過HashCode和equals 比較的。TreeSet不能使用for語句遍歷,可使用foreach，Iterator

Collection代碼實現

遍歷：

        Collection <String>collection1=new ArrayList();
        collection1.add("1");
        collection1.add("1");
        Iterator<String> iterator=collection1.iterator();
        while (iterator.hasNext())
        Log.d(TAG, "onCreate:collection1:: "+iterator.next());

集合對象排序：

(1) 排序對象實現Comparable接口重寫方法compareTo

public class Person2  implements Comparable<Person2>{

    public String name;
     public  int age;

    public Person2(String name, int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public int compareTo(@NonNull Person2 o) {
        return this.age-o.age;
    }
}

View Code

 

 　　　　List<Person2> list=new ArrayList<>();
        list.add(new Person2("gxw",23));
        list.add(new Person2("gxw2",25));
        list.add(new Person2("gxw4",22));
        Collections.sort(list);
        for(Person2 person2:list){
        Log.d(TAG, "onCreate: Person2::"+person2.name+"**"+person2.age);

        }

(2) 建立一個比較器，實現ava.util.Comparator接口，重寫compare方法

public class Comparator<E> implements java.util.Comparator<Person3> {
    @Override
    public int compare(Person3 o1, Person3 o2) {
        /**
         * 先比較name，再比較age
         */
       int flag= o1.getName().compareTo(o2.getName());
        if(flag==0){
        return  o1.getAge()-o2.getAge();
        }else{
            return flag;
        }

    }
}

View Code

public class Person3  {
    public String name;
    public int age;

    public Person3(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person3{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

 　　　　List<Person3> list2=new ArrayList<>();
        list2.add(new Person3("gxw",23));
        list2.add(new Person3("gxw",24));
        list2.add(new Person3("gxw",25));
        list2.add(new Person3("gxc",23));
        list2.add(new Person3("gxe",23));
        list2.add(new Person3("gxy",24));
        list2.add(new Person3("gxa",25));
        list2.add(new Person3("gxz",25));
        Comparator<Person3> comparator=new Comparator<Person3>();
        Collections.sort(list2,comparator);

        for(Person3 person3:list2){
        Log.d(TAG, "onCreate: Person3::"+person3.toString());
        }

Map接口

 

Map實現類中存儲的「鍵-值」映射對是經過鍵來惟一標識。

V   put(K key, V value) 　             將指定的"鍵-值"對存入Map中
V   get(Object key);　 　              返回指定鍵所映射的值
V   remove(Object key);　              根據指定的鍵把此"鍵-值"對從Map中移除。
boolean containsKey(Object key);       判斷此Map是否包含指定鍵的"鍵-值"對。
boolean containsValue(Object value);   判斷此Map是否包含指定值的"鍵-值"對。
int  size();　                          得到些Map中"鍵-值"對的數量。
Set<K>  keySet(); 　                    返回此Map中包含的鍵的Set集。
Collection<V> values();　               返回此Map中包含的值的Collection集。值是可重複的.

對於Map接口來講，其自己是不能直接使用迭代進行輸出的，由於Map中的每個位置存放的是一對值（keyvalue），
而Iterator中每次只能找到一個值。因此若是非要使用迭代進行輸出的話，要按照如下操做步驟完成：
1.將Map的實例經過entrySet()方法變爲Set接口對象
2.經過Set接口的實例的iterator() 將Iterator實例化
3.經過Iterator迭代輸出，每一個內容都是Map.Entry的對象
4.經過Map.Entry進行keyvalue的分離。getKey,getValue

HashMap:

　　HashMap中的映射對的"鍵"若是是自定義的類,應該重寫hashCode()和equals()方法。

　　Hashtable 
　　是同步的(線程安全的);
　　不能有null鍵，也不能有null值,不然運行時出空指針異常;
　　基於陳舊的Dictionary<K,V>類 ,有contains() 方法,用於測試此映射表中是否存在指定值,等同於HashMap類中的containsValue()

　　HashMap
　　是不一樣步的(線程非安全的);
　　能存儲最多一個null鍵，任意多個null值;
　　有containsKey(),containsValue()方法,沒有contains() 方法
　　繼承AbstractMap<K,V>
TreeMap:

　　TreeMap內部使用紅黑樹結構對"key"進行排序存放，因此放入TreeMap中的"key-value"對的"key"必須是"可排序"的。
　　TreeMap()使用鍵的天然順序構造一個新的、空的樹映射。
　　TreeMap(Comparator<? super K>  comparator) 構造一個新的、空的樹映射，該映射根據給定比較器進行排序。

Map代碼實現

遍歷:

（1）遍歷key-Vaule值

 　　　　HashMap<String,String> map=new HashMap<String,String>();
        map.put("key1","value2");
        map.put("key2","value1");
        map.put("key4","value4");
        map.put("key3","value3");
        Iterator<Map.Entry<String,String>>it=map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry1 = it.next();
            Log.d(TAG, "onCreate: Map::entry"+entry1.getKey()+"*"+entry1.getValue());
        }

（2）keySet遍歷key值

   　　　　Set<String> set1=map.keySet();
          Iterator<String> it2=set1.iterator();
          while (it2.hasNext())
            Log.d(TAG, "onCreate: KeySet::"+it2.next());

（3）遍歷Value值

        for(String s:map.values()){
            Log.d(TAG, "onCreate: MapValue::"+s);
        }

（4）遍歷key_Value

     for(Map.Entry<String,String> entry3:map.entrySet()){

            Log.d(TAG, "onCreate: Map3:::"+entry3.getKey()+"*"+entry3.getValue());
        }

 

Map排序

key值排序：

　　　　 TreeMap<PersonMap,String> map2=new TreeMap<>();
        map2.put(new PersonMap("gxw",23),"222");
        map2.put(new PersonMap("gxw2",23),"322");
        map2.put(new PersonMap("gxw3",24),"332");
        map2.put(new PersonMap("gxw",24),"342");
        map2.put(new PersonMap("gxwr",23),"3424");
        for(Map.Entry<PersonMap,String> en:map2.entrySet()){
            Map.Entry<PersonMap,String> it3=en;
            Log.d(TAG, "onCreate: Map210:"+it3.getKey().toString()+"*"+it3.getValue());
        }

public class PersonMap  implements Comparable<PersonMap>{

    String name;
    int age;

    public PersonMap(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(@NonNull PersonMap o) {
        int flag=this.age-o.age;
        if(flag==0){
          return   this.name.compareTo(o.name);
        }else{

        }
        return flag;
    }

    @Override
    public String toString() {
        return "PersonMap{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

Value排序

        TreeMap<PersonMap,String> map3=new TreeMap<>();
        map3.put(new PersonMap("gxw",23),"222");
        map3.put(new PersonMap("gxw2",23),"322");
        map3.put(new PersonMap("gxw3",24),"332");
        map3.put(new PersonMap("gxw",24),"342");
        map3.put(new PersonMap("gxwr",23),"3424");
        List<Map.Entry<PersonMap,String>>list3=new ArrayList<>(map3.entrySet());

        MapComapreble ma=new MapComapreble();
        Collections.sort(list3,ma);
        for (Map.Entry<PersonMap,String> keyss:list3)
            Log.d(TAG, "onCreate: Value230:::"+keyss.getKey().toString()+"**"+keyss.getValue());

public class MapComapreble implements java.util.Comparator<Map.Entry<PersonMap,String>>  {


    @Override
    public int compare(Map.Entry<PersonMap, String> o1, Map.Entry<PersonMap, String> o2) {
        return o1.getValue().compareTo(o2.getValue());
    }


}

小結：

Set: 無序,無下標,不能隨機訪問,不可重複
List:有序,有下標,能夠隨機訪問，可重複
Map："key-value"對,較多存放和查詢,較少遍歷
HashMap－讀寫二者都較高
ArrayList－讀(指定下標隨機訪問)快,插入/刪除元素慢
LinkedList－讀(指定下標隨機訪問)慢,插入/刪除元素快