Java基礎------集合框架知識點總結（二）

                                 第一個類     Set類
一、摘要。
1、Set是一個不包含重複元素的Collection。
2、Set允許包含null元素，但是隻允許同一個Set集合中只包含有一個null元素。
3、Set是Collection接口的一個子接口。
4、Set的兩個實現類HashSet和TreeSet.
5、Set接口的定義如下：
6、Set集合的功能和Collection是一致的。

public interface Set<E> extends Collection<E>

一、HashSet類。
1、概述。
1）此類實現 Set 接口，由哈希表（實際上是一個 HashMap 實例）支持。
2）可以通過元素的兩個方法，hashCode和equals來完成保證元素唯一性。
2、構造函數摘要。
1）HashSet() 構造一個新的空 set，其底層 HashMap 實例的默認初始容量是 16。
2）HashSet(Collection<? extends E> c) 構造一個包含指定 collection 中的元素的新 set。


示例一：

package 泛型;

import java.util.HashSet;
import java.util.Iterator;

/**
 * 
 * @author ZHANGYU
 *  |--Set:元素是無序的（存入和取出的順序不一定一致），元素不可以重複，線程是非同步的
 *      |--HashSet:底層數據結構是哈希表
 *          HashSet是如何保證元素的唯一性呢？
 *              是通過元素的兩個方法HashCode和equals來完成
 *              如果元素的HashCode相同，纔會判斷equals是否爲true,
 *              如果元素的HashCode不同，不會調用equals
 *          注意：判斷元素是否存在，以及刪除等操作，依賴的方法是hashCode和equals方法
 *      |--TreeSet：可以對set集合中的元素自然排序
 *                  底層數據結構是二叉樹
 *                  保證元素唯一性的一句：
 *                  compareTo方法return
 *          TreeSet排序的第一種方式：讓元素自身具有比較性
 *          元素需要實現comparable接口，實現compareTo方法
 *          這種方式稱爲元素的自然順序，也成爲默認順序
 *          
 *          TreeSet排序的第二種方式：
 *          當元素沒有比較性時，或具備的比較性不是所需要的
 *          這時候就需要讓集合自身具有比較性
 *          在集合初始化時就有了比較方式
 *  Set功能和Collection是一致的。
 */
public class setDemo {

    public static void main(String[] args){
        HashSet hs=new HashSet();
        hs.add("1");
        hs.add("2");
        hs.add("3");
        hs.add("3");
        Iterator it=hs.iterator();
        while(it.hasNext()){
            sop(it.next());
        }

    }
    private static void sop(Object obj) {
        // TODO Auto-generated method stub
        System.out.println(obj);
    }
}

示例二：

package 泛型;
/**
 * 保證集合中元素的唯一性。
 * 需求：
 * 1、向集合中存儲對象元素。
 * 2、姓名，和年齡相同視爲同一個元素。
 * 
 */
import java.util.HashSet;
import java.util.Iterator;
/*
 * 通過覆寫hashCode函數和equals函數。
 * 來保證元素的唯一性。
 */
class person1{

    private String name;
    private int age;
    public person1(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge()
    {
        return age;
    }
    //覆蓋其hashCode函數
    public int hashCode(){

        return this.name.hashCode()+age*27;

    }
     public boolean equals(Object obj){
            if(!(obj instanceof person1))
                return false;
            person1 p=(person1)obj;
            return this.name.equals(p.getName())&&this.age==p.getAge();
        }
}
public class setDemo1 {

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args){
        //建立集合對象
        HashSet hs=new HashSet();
//      向集合中添加元素
        hs.add(new person1("1",23));
        hs.add(new person1("2",25));
        hs.add(new person1("4",45));
        hs.add(new person1("4",45));
        hs.add(new person1("6",24));
        hs.add(new person1("6",24));
        //遍歷元素。
        Iterator it=hs.iterator();
        while(it.hasNext()){
            person1 p=(person1) it.next();
            sop(p.getName()+"::"+p.getAge());
        }

    }
}

二、TreeSet類。
1、概述。
1）此類實現了Set接口和SortedSet接口。
2）此類使用元素的自然順序對元素進行排序，或者根據創建 set 時提供的 Comparator 進行排序，具體取決於使用的構造。
2、構造函數概述。
1）TreeSet() 構造一個新的空 set，該 set 根據其元素的自然順序進行排序。
2）TreeSet(Collection<? extends E> c) 構造一個包含指定 collection 元素的新 TreeSet，它按照其元素的自然順序進行排序。
3）TreeSet(Comparator<? super E> comparator) 構造一個新的空 TreeSet，它根據指定比較器進行排序。
示例：

package 泛型;
/*
需求
1、存儲對象元素
2、給其賦予比較性，使其進行比較。
*/
import java.util.Iterator;
import java.util.TreeSet;
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    //覆寫compareTo函數，按照指定的比較性進行排序
    public int compareTo(Object obj) {
        // TODO Auto-generated method stub
        if(!(obj instanceof Student))
            throw new RuntimeException("不是學生類");
        Student s=(Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.getName());
        return -1;
    }

}
public class TreeSetDemo1 {

    public static void main(String[] args){
        TreeSet ts=new TreeSet();
        ts.add(new Student("abc",23));
        ts.add(new Student("abg",25));
        ts.add(new Student("adc",32));
        ts.add(new Student("sbc",43));
        ts.add(new Student("afc",43));
        Iterator it=ts.iterator();
        while(it.hasNext()){
            Student s=(Student)it.next();
            System.out.println(s.getName()+"::"+s.getAge());
        }

    }
}

                                 第二個類     Map類

一、概述。
1、Map<K,V>可用於保存具有映射關係的數據。
2、一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。
3、Map<K,V>接口的實現如下：

    public interface Map<K,V>

二、Map集合的簡介。
1、方法。
1） 存
* V put(K key, V value) 添加元素如果存入相同的鍵，他會覆蓋先存入的值，並且返回被覆蓋的那個值

void putAll(Map<? extends K,? extends V> m) 

2 ）刪。
void clear()
remove(Object key)
3） 判斷。
containsKey(Object key)
containsValue(Object value)
isEmpty()

4 ）獲取。
get(Object key ）
size()
values()

entrySet()
keySet()
2、Map的子類。
Map
 |—Hashtable:底層是哈希表數據結構，不可以存入null鍵和null值。該集合線程同步，jdk1.0 效率低。
  |—HashMap:底層是哈希表數據結構，可以存入null鍵和null值。該集合線程不同步，jdk1.2 效率高。
     |—TreeMap:底層是二叉樹數據結構，線程不同步，可以給集合中的鍵進行排序。
和Set很像，其實set底層就是使用了map集合。
示例一：

package 泛型;
/*
Map集合的一些基本方法演示。
*/
import java.util.HashMap;
import java.util.Map;

public class MapTest1 {

    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "lisi1");

        map.put("03", "wangwu");
        map.put("04", "zhaoliu");
        System.out.println("1"+map);

        System.out.println("2"+map.get("01"));
        System.out.println("3"+map.remove("01"));
        System.out.println("4"+map);
        System.out.println("5"+map.containsKey("01"));
        System.out.println("6"+map.containsValue("lisi"));
        System.out.println("7"+map);
        System.out.println("8"+map.put("02", "lisi"));
        System.out.println("9"+map);


    }
}

HashMap類
一、概述。
1、此類實現了Map集合，對元素的添加和刪除具有較高的效率。
2、此類提供了所有可選的映射操作，並且允許使用null值和null鍵，但必須保證鍵的唯一性。
3、此類是非同步的類，同時也不保證映射順序。
二、構造函數摘要。
1、HashMap() 構造一個具有默認初始容量 (16) 和默認加載因子 (0.75) 的空 HashMap。
2、HashMap(Map<? extends K,? extends V> m)構造一個映射關係與指定 Map 相同的新 HashMap。

示例一：

package 泛型;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/*取出演示：
 * entrySet()
 * 
 * keySet()：返回map集合存入到set集合中，通過set迭代器取出所有的鍵，之後通過map的get方法獲取值
 */
public class MapTest2 {
    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("02", "lisi1");
        map.put("03", "wangwu");
        map.put("04", "zhaoliu");
        //第一種
//      Set<String> key=map.keySet();
//      Iterator<String> it=key.iterator();
//      while(it.hasNext()){
//          String obj=it.next();
//          System.out.println(obj+"::"+map.get(obj));
//      }
        //第二種
        Set<Entry<String,String>> en=map.entrySet();
        Iterator<Entry<String,String>> it=en.iterator();
        while(it.hasNext()){
            Entry<String,String> e=it.next();
            System.out.println(e.getKey()+"::"+e.getValue());
        }
    }   
}

示例二：

package 泛型;
/*每個學生都有對應的歸屬地，
 * 學生：student11 地址String
 * 學生屬性：姓名、 年齡
 * 注意：姓名和年齡相同視爲同一個學生
 * 保證學生的唯一性
 * 
 * 
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

class student11 implements Comparable<student11>{
    private String name=null;
    private int age=0;
    public student11(String name, int age) {
        this.setName(name);
        this.setAge(age);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int hashCode(){
        return name.hashCode()+age*27;
    }
    public boolean equals(Object obj){
        if(!( obj instanceof student11))
            return false;
        student11 s=(student11)obj;
        return this.name.equals(s)&&this.getAge()==age;
    }
    @Override
    public int compareTo(student11 s) {
        // TODO Auto-generated method stub
        int num=new Integer(this.age).compareTo(new Integer(s.getAge()));
        if(num==0)
            return this.name.compareTo(s.getName());
        return num;
    }
    public String toString(){
        return this.name+"::"+this.age;
    }


}

public class MapTest3 {

    public static void main(String[] args){
        HashMap<student11,String> map=new HashMap<student11,String>();
        map.put(new student11("dzhangsan",21), "beijing");
        map.put(new student11("slisi",23), "tianjin");
        map.put(new student11("xwangwu",25), "shandong");
        map.put(new student11("vzhaoliu",26), "shanghai");
        map.put(new student11("wancai",27), "anhui");
        //第一種取出方式。
        Set<student11> keyset=map.keySet();
        Iterator<student11> it=keyset.iterator();
        while(it.hasNext()){
            student11 s=it.next();
            System.out.println(s.getName()+"::"+s.getAge()+"::"+map.get(s));
        }

        //第二種取出方式
        System.out.println();
        Set<Entry<student11,String>> entry=map.entrySet();
        Iterator<Entry<student11,String>> it1=entry.iterator();
        while(it1.hasNext()){
            Entry<student11,String> en=it1.next();
            student11 s=en.getKey();
            String add=en.getValue();
            System.out.println(s+"::"+add);

        }
    }
}

TreeMap類
一、概述。
   該類映射根據其鍵的自然順序進行排序，或者根據創建映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。
二、構造函數摘要。
1、TreeMap() 使用鍵的自然順序構造一個新的、空的樹映射。
2、TreeMap(Comparator<? super K> comparator) 構造一個新的、空的樹映射，該映射根據給定比較器進行排序。
3、TreeMap(Map<? extends K,? extends V> m) 構造一個與給定映射具有相同映射關係的新的樹映射，該映射根據其鍵的自然順序 進行排序。
示例一：

package 泛型;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

class stuNameComparator implements Comparator<student11>{

    public stuNameComparator(){

    }
    //根據姓名進行排序。
    public int compare(student11 o1, student11 o2) {
        // TODO Auto-generated method stub
        int num=o1.getName().compareTo(o2.getName());
        if(num==0)
            return new Integer(o1.getAge()).compareTo(o2.getAge());
        return num;
    }

}
public class TreeMapTest1 {
    public static void main(String[] args){
        TreeMap<student11,String> tm=new TreeMap<student11,String>(new stuNameComparator());
        tm.put(new student11("zhangsan",21), "beijing");
        tm.put(new student11("lisi",23), "tianjin");
        tm.put(new student11("wangwu",56), "shandong");
        tm.put(new student11("zhaoliu",26), "shanghai");
        tm.put(new student11("wancai",73), "anhui");
        tm.put(new student11("a",75), "anhui");
        Set<Entry<student11,String>> entry=tm.entrySet();
        Iterator<Entry<student11,String>> it=entry.iterator();
        while(it.hasNext()){
            Entry<student11, String> s=it.next();
            System.out.println(s.getKey()+":"+s.getValue());
        }

    }
}

示例二：

“`
package 泛型;
/*
* 1.練習
* “adcdswe”獲取字符串中的字母，並且算出字母出現的次數
* a(1)
* d(1)
*

• 
  
  • */
    import java.util.Iterator;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.TreeMap;

public class TreeMapTest2 {

public static void main(String[] args){
    charCount("abcedaadadasdsddsdgdsdf");
}
public static void charCount(String str){
    char[] ch=str.toCharArray();
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
    for(int i=0;i<ch.length;i++){
        boolean flage=tm.containsKey(ch[i]);
        if(flage==true){
            int count=tm.get(ch[i]);
            count++;
            tm.put(ch[i], count);
        }
        else{
            tm.put(ch[i], 1);
        }
    }
    Set<Entry<Character,Integer>> entry=tm.entrySet();
    Iterator<Entry<Character,Integer>> it=entry.iterator();
    while(it.hasNext()){
        Entry<Character,Integer> en=it.next();
        System.out.println(en.getKey()+"("+en.getValue()+")");
    }
}

}