Java基礎——集合框架（三）

Map集合

Map集合：該集合存儲鍵值對，一對一對的往裏存，而且要保證鍵的唯一性

添加
1. put(K key,V value)添加鍵值對
2. putAll(Map ? extends K,? extends V m)添加一個集合(含泛型限定)
刪除
1. clear()移除所有的映射關係
2. remove(Object key)移除單個的映射關係
判斷
1. containsValue(Object value)判斷是否存在這個值
2. containsKey(Object key)判斷是否存在這個鍵
3. isEmpty()判斷映射關係中是否未包含任何元素
獲取
1. get(Object key)根據鍵獲取值
2. size()獲取映射關係數
3. values()返回所有的映射關係的值
4. entrySet() 返回類型是Set《Map.Entry《k,v》》(博客編輯模式不能寫尖括號，這裏用書名號代替)將map集合中的映射關係存入到set集合中，而這個關係的數據類型就是Map.Entry
5. keySet()返回類型是Set集合，將Map中的所有的鍵存入到Set集合中，因爲Set具備迭代器，所以可以用迭代方式獲取所有的鍵，再根據get方法獲取所有的鍵對應的值。
  1. Map集合的取出原理，將map集合轉成set集合，再通過迭代器取出元素。

實現了Map接口的子類的特點：

Map
- HashTable
  - 底層是哈希表數據結構，不可以存null鍵和null值，線程同步的，jdk1.0開始的，效率低
- HashMap
  - 底層是哈希表數據結構的，允許存入null鍵和null值，線程非同步的，jak1.2開始的，效率高
- TreeMap
  - 底層是二叉樹數據結構的，線程不同步，可以用於給map集合中的鍵進行排序。

發現，Map和Set很像

其實Set底層就是使用了Map集合。

演示Map接口中的基本方法：

//Map方法中的基本方法演示
import java.util.*;
public class MapDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        Map<Integer,String> map = new HashMap<Integer,String>();

        //增加元素put方法
        map.put(1,"zhangsan1");
        map.put(2,"zhangsan2");
        map.put(3,"zhangsan3");
        map.put(4,"zhangsan4");

        //put方法返回的值爲：該鍵映射的值之前的位置上的元素
        sop("05號學生第一次存進來時候put方法的返回值是："+map.put(05,"zhangsan5"));//null
        sop("05號學生第二次存進來時候put方法的返回值是："+map.put(05,"zhangsan5"));//zhangsan5

        sop("初始Map集合中的元素爲"+map);

        //判斷
        sop("集合中有鍵爲4的嗎："+map.containsKey(4));//true
        sop("集合中有值爲“zhangsan6”的嗎："+map.containsValue("zhangsan6"));//false

        //刪除元素
        map.remove(05);
        sop("刪除05鍵後，集合中的元素還剩下："+map);

        //刪除元素後的返回值是：被刪除鍵的映射位置上的值

        sop("刪除4鍵之後，返回的值是："+map.remove(04));//zhangsan4
        sop("刪除4鍵後，集合中的元素還剩下："+map);

        //查詢：
        sop("獲取3鍵對應的值："+map.get(3));//zhangsan3

        //查看該集合中所有映射關係中的值，返回來的是個Set集合
        Collection<String> coll = map.values();
        sop("獲取集合中所有的映射關係對象的值爲："+coll);

        sop("這個時候集合中的元素的個數是："+map.size());//3
    }
}

運行結果：

keySet方法：可以獲取到集合中所有的鍵，那麼獲取到了鍵的話，獲取值就容易多了。

示例如下：

//Map集合中取出所有鍵值對的方法

//keySet方法的演示
import java.util.*;
public class MapDemo2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        Map<Integer,String> map = new HashMap<Integer,String>();

        map.put(1,"zhangsan1");
        map.put(2,"zhangsan2");
        map.put(3,"zhangsan3");
        map.put(4,"zhangsan4");

        //先獲取Map集合中的鍵，存入到set集合中
        Set<Integer> keySet = map.keySet();

        //有了Set集合就可以使用迭代器取出Map集合中的鍵
        for (Iterator<Integer> it = keySet.iterator(); it.hasNext(); )
        {
            Integer i = it.next();//i就是獲取到的鍵

            //既然有了鍵，就可以獲取到對應的值
            String s = map.get(i);

            sop("Key="+i+"....Value="+s);
        }

    }
}

運行結果：

entrySet方法，可以獲取到map集合中的映射關係，有了關係就可以用getKey，getValue方法獲取到關係中的鍵和值。

//Map集合中取出所有鍵值對的方法

//entrySet方法的演示
import java.util.*;
public class MapDemo2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        Map<Integer,String> map = new HashMap<Integer,String>();

        map.put(1,"zhangsan1");
        map.put(2,"zhangsan2");
        map.put(3,"zhangsan3");
        map.put(4,"zhangsan4");

        //entrySet的返回類型是Set集合，集合中的元素類型是Map.Entry<>他是一個接口，所以也需要泛型
        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();

        //然後可以通過迭代器的方法取出Set集合中的元素
        for (Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();it.hasNext() ; )
        {
            //取出的元素是Map.Entry<>類型的，還是要加泛型，取出來的元素是map集合中的映射關係，
            Map.Entry<Integer,String> me = it.next();

            //取出來關係之後可以用getKey和getValue方法獲取鍵和值
            Integer key = me.getKey();
            String value = me.getValue();

            sop(key+"::"+value);
        }
    }
}

運行結果爲：

實驗結果表明，可以取出來元素，但是，問題來了，

Map.Entry是什麼東西呢？

Map.Entry是在Set集合中存儲元素的類型，
是由entrySet方法取出來的Map集合中的關係映射。
（假如說丈夫妻子是一個鍵值對，那麼結婚證就是這個關係映射。）
Map是一個接口，Map.Entry也是一個接口
而且Entry是Map接口的子接口，而且是靜態的，公有的，（可以直接用.Entry）
他在文檔中是怎麼寫的呢？

interface Map
{
    public static interface Entry
    {
        public abstract Object getKey();
        public abstract Object getValue();
    }
}

class HashMap implements Map
{
    class HaHa implements Map.Entry
    {
        public Object getKey()
        {}
        public Object getValue()
        {}
    }
}

看一個HashMap的練習：
在Map集合中存儲學生對象和住址，學生有姓名和年齡，姓名年齡相同視爲同一個人，
1，定義學生對象，
2，將學生對象存入Map集合中
3，取出存進去的元素。


//HashMap練習
import java.util.*;

//定義學生類
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    //給學生設置姓名和年齡
    public void set(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()
    {
        return name+"..."+age;
    }
    //考慮到可能會new很多的學生對象，有可能會存儲到各種集合中 ，所以要重寫hashCode和equals方法，
    public int hashCode()
    {
        return name.hashCode()+age*7;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Student))
            throw new ClassCastException("類型不匹配");
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age==s.age;
    }
    //萬一要存進TreeSet集合中呢？
    public int compareTo(Student s)//因爲在最上邊有泛型限定了，進來的全是Student
    {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if (num==0)
            return this.name.compareTo(s.name);
        return num;
    }
}
public class MapTest {
    public static void main(String[] args) 
    {
        //創建集合
        HashMap<Student,String> hm = new HashMap<Student,String>();
        //創建對象
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        //給對象初始化
        s1.set("zhangsan",23);
        s2.set("lisi",24);
        s3.set("wangwu",27);
        s4.set("zhaoliu",21);
        //將集合中添加元素
        hm.put(s1,"beijing");
        hm.put(s2,"nanjing");
        hm.put(s3,"tianjin");
        hm.put(s4,"shanghai");

        //第一種取出方式

        Set<Student> keySet = hm.keySet();
        for (Iterator<Student> it = keySet.iterator();it.hasNext() ; )
        {
            //獲取鍵
            Student stu = it.next();
            //根據鍵獲取值，用get方法
            String addr = hm.get(stu);
            System.out.println(stu.getName()+"...."+stu.getAge()+"....."+addr);
        }

        System.out.println("********************************************************");

        //第二種取出方式

        //將映射關係存入到set集合中，
        Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
        //用迭代器取出Set集合中的關係
        for (Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();iter.hasNext() ; )
        {
            //關係
            Map.Entry<Student,String> me = iter.next();
            //獲取關係中的鍵和值。
            Student student = me.getKey();
            String address = me.getValue();

            System.out.println(student.getName()+"...."+student.getAge()+"....."+address);
        }
    }
}

運行結果爲：

再看一個TreeMap的練習

還是學生對象，需要在Map集合中進行排序，按照姓名排序。（在之前定義的學生類中是按照年齡排序的）

//將學生在Map集合中進行排序
import java.util.*;
//定義比較器。按照姓名排序
class StuNameComp implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        return num;
    }
}
public class TreeMapTest {
    public static void main(String[] args) 
    {
        //創建集合
        TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComp());
        //創建對象
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        Student s5 = new Student();
        //給對象初始化
        s1.set("zhangsan",23);
        s2.set("lisi",24);
        s3.set("wangwu",27);
        s4.set("zhaoliu",21);
        s5.set("zhaoliu",27);//姓名相同，年齡不同。
        //將集合中添加元素
        tm.put(s1,"beijing");
        tm.put(s2,"nanjing");
        tm.put(s3,"tianjin");
        tm.put(s4,"shanghai");
        tm.put(s5,"shanghai");

        //取出元素
        Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
        for (Iterator<Map.Entry<Student,String>> it = entrySet.iterator();it.hasNext() ; )
        {
            Map.Entry<Student,String> me = it.next();
            Student s = me.getKey();
            String addr = me.getValue();
            System.out.println(s.getName()+".."+s.getAge()+"..."+addr);
        }
    }

}

運行結果爲：

運行結果可以看出來，全部按照姓名排序，姓名相同的都按照年齡排序了。

那什麼時候使用映射關係呢？

當數據與數據之間存在映射關係時，就要先考慮到map集合。

那麼再做一個練習：
獲取指定字符串中的字母出現的次數。
希望打印結果爲：a(1)b(2)……..

通過結果發現，每一個字母都有對應的次數，說明字母和次數之間都有映射關係。

這時候想到了map集合就是存儲映射關係的。


//獲取一段字符串中每個字符出現的次數。


/*
思路：
1，將字符串轉換成字符數組，因爲要對每一個字母進行操作
2，定義一個map集合，因爲打印結果的字母有順序，所以使用TreeMap集合，
3，遍歷字符數組
    將每一個字母作爲鍵去查map集合
    如果返回null，將該字母和1存進集合中
    如果返回不會null，說明該字母在map集合已經存在，並有對應次數
    那麼就獲取該次數並進行自增，然後將該字母和自增後的次數存入到map集合中，覆蓋掉原來鍵所對應的值。
4，將map集合中的數，變成指定的字符串形式返回。
*/

import java.util.*;
public class MapTest2 {
    public static void main(String[] args) 
    {
        String s = "abcdecabcdaefbdab";
        String s1 = charCount(s);
        System.out.println(s1);
    }
    public static String charCount(String str)
    {
        //將字符串變成數組
        char[] chs = str.toCharArray();
        //創建一個map集合
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
        //遍歷數組
        for (int x = 0;x<chs.length ;x++ )
        {
            //判斷字符串中的元素是否符合規則
            if (!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
                continue;
            //通過get方法返回的值來查看每一個字符在集合中有沒有存在，沒有的話返回空，有的話返回一個數字
            Integer value = tm.get(chs[x]);
            //如果返回爲null，存該字母和1
            if(value==null)
            {
                tm.put(chs[x],1);
            }
            //否則，將value值取出來，自增之後，將該字母和自增後的值一起存進集合中。
            else
            {
                value++;
                tm.put(chs[x],value);
            }
        }
        //使用字符容器存放要打印的字符串
        StringBuilder sb = new StringBuilder();
        //取出要取出的元素，存進StringBuilder中。
        Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
        for (Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();it.hasNext() ; )
        {
            Map.Entry<Character,Integer> me = it.next();
            char c = me.getKey();
            int i = me.getValue();
            sb.append("("+c+","+i+") ");
        }
        return sb.toString();
    }
}

運行結果爲：

Map集合擴展

map集合被使用是因爲具備映射關係。
但是有沒有存在這種映射呢？
一個學校有很多個教室，一個教室有很多個學生，也就是說一對多的映射，
這樣的話該怎麼寫呢？

//一對多的映射關係
import java.util.*;
public class MapDemo3 {
    public static void main(String[] args) 
    {
        /*
        這就是一個簡單的一對多的映射模式，
        一個學校對應的兩個系，一個系對應的兩個學號，一個學號對應的一個學生
        所以，這裏一個學校裏的映射關係就是系名，系（集合）
        一個系裏的映射關係就是學號，姓名
        */
        //創建一個學校的集合
        HashMap<String,HashMap<String,String>> ycu = new HashMap<String,HashMap<String,String>>();

        //創建兩個系的集合
        HashMap<String,String> jisuanji = new HashMap<String,String>();
        HashMap<String,String> shuxue = new HashMap<String,String>();
        //將系添加進學校集合
        ycu.put("jisuanjixi",jisuanji);
        ycu.put("shuxuexi",shuxue);
        //將學生添加進系集合
        jisuanji.put("01","sunheran");
        jisuanji.put("02","wanglingli");

        shuxue.put("01","wangxuesha");
        shuxue.put("02","wangjiajia");
        //獲取學生信息
        getDeptInfo(ycu);
    }
    public static void getDeptInfo(HashMap<String,HashMap<String,String>> xuexiao)
    {
        //獲取系名鍵
        Set<String> keySet = xuexiao.keySet();
        for (Iterator<String> it = keySet.iterator();it.hasNext() ; )
        {
            //根據鍵獲取系值（集合）
            String deptName = it.next();
            HashMap<String,String> dept = xuexiao.get(deptName);
            System.out.println(deptName);
            //根據獲取到的系值集合獲取集合裏邊的學生的信息
            getStudentInfo(dept);
        }

    }
    public static void getStudentInfo(HashMap<String,String> dept)
    {
        //獲取學號
        Set<String> keySet = dept.keySet();
        for (Iterator<String> it = keySet.iterator();it.hasNext() ; )
        {
            //根據學號獲取姓名
            String id = it.next();
            String name = dept.get(id);
            System.out.println(id+"...."+name);
        }
    }
}

運行結果爲：

但是實際開發中一般不這麼幹，爲什麼呢？因爲學生信息一般都會封裝成學生對象，將學生對象存進一個List集合中
具體代碼如下：

//一對多的映射關係，實際開發中這個用的多一些
import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    //給學生設置姓名和年齡
    public void set(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()
    {
        return name+"..."+age;
    }
    //考慮到可能會new很多的學生對象，有可能會存儲到各種集合中 ，所以要重寫hashCode和equals方法，
    public int hashCode()
    {
        return name.hashCode()+age*7;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Student))
            throw new ClassCastException("類型不匹配");
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age==s.age;
    }
    //萬一要存進TreeSet集合中呢？
    public int compareTo(Student s)//因爲在最上邊有泛型限定了，進來的全是Student
    {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if (num==0)
            return this.name.compareTo(s.name);
        return num;
    }
}
public class MapDemo4 {
    public static void main(String[] args) 
    {
        //創建一個學校的集合
        HashMap<String,List<Student>> ycu = new HashMap<String,List<Student>>();

        //創建兩個系的集合
        List<Student> jisuanji = new ArrayList<Student>();
        List<Student> shuxue = new ArrayList<Student>();
        //將系添加進學校集合
        ycu.put("jisuanjixi",jisuanji);
        ycu.put("shuxuexi",shuxue);

        //創建學生對象
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        s1.set("sunheran",21);
        s2.set("wanglingli",25);
        s3.set("wangxuesha",23);
        s4.set("wangjiajia",22);
        //將學生添加進系集合
        jisuanji.add(s1);
        jisuanji.add(s2);

        shuxue.add(s3);
        shuxue.add(s4);
        //獲取學生信息
        getDeptInfo(ycu);
    }
    public static void getDeptInfo(HashMap<String,List<Student>> xuexiao)
    {
        //獲取系名鍵
        Set<String> keySet = xuexiao.keySet();
        for (Iterator<String> it = keySet.iterator();it.hasNext() ; )
        {
            //根據鍵獲取系值（集合）
            String deptName = it.next();
            List<Student> stu = xuexiao.get(deptName);
            System.out.println(deptName);
            //根據獲取到的系值集合獲取集合裏邊的學生的信息
            getStudentInfo(stu);
        }

    }
    public static void getStudentInfo(List<Student> dept)
    {
        for (Iterator<Student> it = dept.iterator();it.hasNext() ; )
        {
            Student s = it.next();
            System.out.println(s.getName()+"...."+s.getAge());
        }
    }
}

運行結果爲：

Java基礎——集合框架（三）

Map集合

Map集合擴展

Java基礎——集合框架（二）

Java基礎——String類、StringBuffer、Integer

Java基礎——包

線程之間通信、停止線程、守護線程

Java基礎——異常及處理方法

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結