• HashSet 集合
• HashMap 集合

HashSet集合

1.1 Set 接口的特點

Set體系的集合:

A:存入集合的順序和取出集合的順序不一致

B:沒有索引

C:存入集合的元素沒有重復

1.2 HashSet 使用&唯一性原理

1.2.1 HashSet的使用

1.2.1.1 案例代碼一：

public class HashSetDemo2 {
    public static void main(String[] args) {
        //創建集合對象
        HashSet<Student> hs = new
 
 HashSet<Student>();
        //創建元素對象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        Student s3 = new Student("lisi",19);
        //添加元素對象
        hs.add(s);
        hs.add(s2);
        hs.add(s3);
        //遍歷集合對象
        for (Student student : hs) {
            System.
 
out.println(student);
        } 
    } 
}

1.2.2 HashSet 唯一性原理

規則:新添加到HashSet集合的元素都會與集合中已有的元素一一比較

首先比較哈希值(每個元素都會調用hashCode()產生一個哈希值)

如果新添加的元素與集合中已有的元素的哈希值都不同,新添加的元素存入集合

如果新添加的元素與集合中已有的某個元素哈希值相同,此時還需要調用equals(Object obj)比較

如果equals(Object obj)方法返回true,說明新添加的元素與集合中已有的某個元素的屬性值相同,那麽新添加的元素不存入集合

如果equals(Object obj)方法返回false, 說明新添加的元素與集合中已有的元素的屬性值都不同, 那麽新添加的元素存入集合

1.2.2.1 案例代碼二：

package com.gao_01;

import java.util.HashSet;

/*
 *    使用HashSet存儲自定義對象並遍歷     
 *    通過查看源碼發現：
 *                HashSet的add()方法，首先會使用當前集合中的每一個元素和新添加的元素進行hash值比較，
 *                如果hash值不一樣，則直接添加新的元素
 *                如果hash值一樣，比較地址值或者使用equals方法進行比較
 *                比較結果一樣，則認為是重復不添加
 *                所有的比較結果都不一樣則添加

 */
public class HashSetDemo2 {
    public static void main(String[] args) {
        //創建集合對象
        HashSet<Student> hs = new HashSet<Student>();
        //創建元素對象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        Student s3 = new Student("lisi",19);
        //添加元素對象
        hs.add(s);
        hs.add(s2);
        hs.add(s3);
        //遍歷集合對象
        for (Student student : hs) {
            System.out.println(student);
        } 
    }      
}

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

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public boolean equals(Object obj) {
        //System.out.println("-------------------");
        Student s = (Student)obj;//向下轉型，可以獲取子類特有成員
        
        //比較年齡是否相等，如果不等則返回false
        if(this.age != s.age) {
            return false;
        }
        
        //比較姓名是否相等，如果不等則返回false
        if(!this.name.equals(s.name)) {
            return false;
        }
        
        //默認返回true，說明兩個學生是相等的
        return true;
    }
    
    @Override
    public int hashCode() {
        return 1;
    }
    
}

1.2.2.2 hashCode方法優化

如果讓hashCode()方法返回一個固定值,那麽每個新添加的元素都要調用equals(Object obj)方法比較,那麽效率較低，只需要讓不同屬性的值的元素產生不同的哈希值,那麽就可以不再調用equals方法比較提高效率

1.2.2.3 案例代碼三：

package com.gao_02;

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

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    /*
    @Override
    public int hashCode() {
        
         * 我們發現當hashCode方法永遠返回整數1時，所有對象的hash值都是一樣的，
         * 有一些對象他的成員變量完全不同，但是他們還需要進行hash和equals方法的比較，
         * 如果我們可以讓成員變量不同的對象，他們的hash值也不同，這就可以減少一部分equals方法的比較
         * 從而可以提高我們程序的效率
         * 
         * 可以嘗試著讓hashCode方法的返回值和對象的成員變量有關
         * 可以讓hashCode方法返回所有成員變量之和，
         * 讓基本數據類型直接想加，然後引用數據類型獲取hashCode方法返回值後再相加（boolean不可以參與運算）
         * 
         
        //return age;
        return age + name.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        System.out.println("-------------");
        
        //提高效率
        if(this == obj) {
            return true;
        }
        
        //提高健壯性
        if(this.getClass() != obj.getClass()) {
            return false;
        }
        
        
        //向下轉型
        Person p = (Person)obj;
        
        if(!this.name.equals(p.name)) {
            return false;
        }
        
        if(this.age != p.age) {
            return false;
        }
        
        return true;
        
    }*/
}

package com.gao_02;

import java.util.HashSet;

public class HashSetDemo3 {
    public static void main(String[] args) {
        //創建集合對象
        HashSet<Person> hs = new HashSet<Person>();
        //創建元素對象
        Person p = new Person("zhangsan",18);
        Person p2 = new Person("lisi",18);
        Person p3 = new Person("lisi",18); 
       
        //添加元素對象
        hs.add(p);
        hs.add(p2);
        hs.add(p3);
        //遍歷集合對象
        for (Person person : hs) {
            System.out.println(person);
        }
    }
}

1.3 Collections 中的方法

1.3.1 案例代碼四：

package com.gao_03;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
 * Collections：
 * 面試題：Collection和Collections有什麽區別？
 *         Collection是集合體系的最頂層，包含了集合體系的共性
 *         Collections是一個工具類，方法都是用於操作Collection
 * 
 */
public class CollectionsDemo {
    public static void main(String[] args) {
        //static void swap(List list, int i, int j) :將指定列表中的兩個索引進行位置互換
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(4);
        Collections.swap(list, 0, 1);
        
        System.out.println(list);
    
    }

    private static void method6() {
        //static void  sort(List<T> list) :按照列表中元素的自然順序進行排序
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(4);
        list.add(3);
        list.add(2);
        
        Collections.sort(list);
        System.out.println(list);
    }

    private static void method5() {
        //static void shuffle(List list):傻否，隨機置換  
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Collections.shuffle(list);
        System.out.println(list);
    }

    private static void method4() {
        //static void reverse(List list)  :反轉
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        
        Collections.reverse(list);
        System.out.println(list);
    }

    private static void method3() {
        //static void fill(List list, Object obj) :使用指定的對象填充指定列表的所有元素
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);
        
        Collections.fill(list, "android");
        
        System.out.println(list);
    }

    private static void method2() {
        //static void copy(List dest, List src) :是把源列表中的數據覆蓋到目標列表
        //註意：目標列表的長度至少等於源列表的長度
        //創建源列表
        List<String> src = new ArrayList<String>();
        src.add("hello");
        src.add("world");
        src.add("java");
        
        //創建目標列表
        List<String> dest = new ArrayList<String>();
        dest.add("java");
        dest.add("java");
        dest.add("java");
        dest.add("java");
        Collections.copy(dest, src);
        System.out.println(dest);
    }

    private static void method() {
        //static int  binarySearch(List list, Object key) 使用二分查找法查找指定元素在指定列表的索引位置 
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        
        int index = Collections.binarySearch(list, 4);
        System.out.println(index);
    }
}

HashMap集合

2.1 Map接口概述

我們通過查看Map接口描述，發現Map接口下的集合與Collection接口下的集合，它們存儲數據的形式不同，如下圖。

A:Collection中的集合，元素是孤立存在的（理解為單身），向集合中存儲元素采用一個個元素的方式存儲

B:Map中的集合，元素是成對存在的(理解為夫妻)。每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值。

C:Collection中的集合稱為單列集合，Map中的集合稱為雙列集合。

需要註意的是，Map中的集合不能包含重復的鍵，值可以重復；每個鍵只能對應一個值。

2.2 Map常用功能

A:映射功能：

V put(K key, V value) :以鍵=值的方式存入Map集合

B:獲取功能：

V get(Object key):根據鍵獲取值

int size():返回Map中鍵值對的個數

C:判斷功能：

boolean containsKey(Object key):判斷Map集合中是否包含鍵為key的鍵值對

boolean containsValue(Object value):判斷Map集合中是否包含值為value鍵值對

boolean isEmpty():判斷Map集合中是否沒有任何鍵值對

D:刪除功能：

void clear():清空Map集合中所有的鍵值對

V remove(Object key):根據鍵值刪除Map中鍵值對

E:遍歷功能：

Set<Map.Entry<K,V>> entrySet():將每個鍵值對封裝到一個個Entry對象中,再把所有Entry的對象封裝到Set集合中返回

Set<K> keySet() :將Map中所有的鍵裝到Set集合中返回

Collection<V> values():返回集合中所有的value的值的集合

2.2.1 案例代碼六：

package com.gao_01;

import java.util.HashMap;
import java.util.Map;

/*
 *     Map的常用功能：
 *         映射功能：
 *                  V put(K key, V value) 
 *         獲取功能：
 *                 V get(Object key) 
 *                 int size() 
 *         判斷功能：
 *                 boolean containsKey(Object key) 
                 boolean containsValue(Object value) 
                 boolean isEmpty() 
 
 *         刪除功能：
 *                 void clear()  
 *                 V remove(Object key)  
 * 
 *         遍歷功能：
 *                 Set<Map.Entry<K,V>> entrySet() 
 * 
 * 
 *             Set<K> keySet()  
 *             Collection<V> values()  
 
 */
public class MapDemo2 {
    public static void main(String[] args) {
        //創建Map對象
        Map<String,String> map = new HashMap<String,String>();
        
        //V put(K key, V value) ：就是將key映射到value，如果key存在，則覆蓋value，並將原來的value返回
        System.out.println(map.put("ITCAST001", "張三"));
        System.out.println(map.put("ITCAST002", "李四"));
        System.out.println(map.put("ITCAST001", "王五"));
        
        //void clear() : 清空所有的對應關系  
        //map.clear();
        
        //V remove(Object key) :根據指定的key刪除對應關系，並返回key所對應的值，如果沒有刪除成功則返回null
        //System.out.println(map.remove("ITCAST005"));
        
        //boolean containsKey(Object key) : 判斷指定key是否存在
        //System.out.println(map.containsKey("ITCAST003"));
        
        //boolean containsValue(Object value)：判斷指定的value是否存在
        //System.out.println(map.containsValue("王五"));
        
        //boolean isEmpty() : 判斷是否有對應關系
        //System.out.println(map.isEmpty());
        
        //int size() : 返回對應關系的個數
        //System.out.println(map.size());
        
        //V get(Object key) : 根據指定的key返回對應的value
        System.out.println(map.get("ITCAST002"));
        
        System.out.println(map);
    }
}

2.2.2 案例代碼七：

package com.gao_01;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 *     Set<K> keySet()  
 *     Collection<V> values() 
 */
public class MapDemo3 {
    public static void main(String[] args) {
        //創建Map對象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射關系
        map.put("ITCAST001", "張三");
        map.put("ITCAST002", "李四");
        map.put("ITCAST005", "李四");
        
        //Set<K> keySet() : 以Set的形式獲返回所有的key
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }
        System.out.println("-----------");
        
        //Collection<V> values() :
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }
    }
}

2.3 Map 的兩種遍歷方式、

2.3.1 利用keySet（）方法遍歷

package com.gao_01;

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

/*
 *     Map的第一種遍歷方式：
 *             首先召集所有的丈夫
 *             遍歷所有的丈夫
 *             獲取每一個丈夫
 *             讓每一個丈夫去找他自己的媳婦
 */
public class MapDemo4 {
    public static void main(String[] args) {
        //創建Map對象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射關系
        map.put("謝婷瘋", "張箔紙");
        map.put("陳關西", "鐘欣桶");
        map.put("李亞碰", "王飛");
        //遍歷Map對象
        
        //首先召集所有的丈夫
        Set<String> keys = map.keySet();
        //遍歷所有的丈夫
        for (String key : keys) {
            //讓每個丈夫去找他自己的媳婦就可以了
            String value = map.get(key);
            System.out.println("丈夫：" + key + "---" + "媳婦：" + value);
        }
        
    }
}

2.3.2 利用entrySet（）方法遍歷

package com.gao_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 *     Map的第二種遍歷方式：
 *         通過結婚證對象來獲取丈夫和媳婦
 * 
 *  class 結婚證<K,V> {
 *      K 丈夫;
 *      V 媳婦;
 *  
 *      public 結婚證(K 丈夫，V 媳婦) {
 *          this.丈夫 = 丈夫;
 *          this.媳婦 = 媳婦;
 *      }
 *  
 *  
 *      public K get丈夫() {
 *          return 丈夫;
 *      }
 *  
 *      public V get媳婦() {
 *          return 媳婦;
 *      }
 *  }
 *  
 *  
 *  class Entry<K,V> {
 *      K key;
 *      V value;
 *  
 *      public Entry(K key，V value) {
 *          this.key = key;
 *          this.value = value;
 *      }
 *  
 *  
 *      public K getKey() {
 *          return key;
 *      }
 *  
 *      public V getValue() {
 *          return value;
 *      }
 *  }
 *  
 *  Set<Map.Entry<K,V>> entrySet()  
 * 
 */
public class MapDemo5 {
    public static void main(String[] args) {
        //創建Map對象
        Map<String,String> map = new HashMap<String,String>();
        //添加映射關系
        map.put("尹誌平", "小龍女");
        map.put("令狐沖", "東方菇涼");
        map.put("玄慈", "葉二娘");
        //獲取所有的結婚證對象
        Set<Map.Entry<String,String>> entrys = map.entrySet();
        //遍歷包含了結婚證對象的集合
        for (Map.Entry<String, String> entry : entrys) {
            //獲取每個單獨的結婚證對象
            //通過結婚證對象獲取丈夫和媳婦
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("丈夫：" + key + "---" + "媳婦:" + value);
        }
        
    }
}

2.4 可變參數

當參數不確定的時候, 類型要明確

Java可以把多個參數直接幫我們轉成數組

理解: 可變參數本質就是一個長度可變的數組.

格式:

實參: 一個參數一個參數的傳遞

形參: 類型…變量名

PS：

在可變參數之後不可以再追加參數

參數的數量定義, 可以給多個甚至也可以一個都不不給

2.4.1 案例代碼：

Public static int getSum(int…num){
    int sum = 0;
        for(int i = 0; i < num.length; i++){
            sum+=num[i];
}
return sum;
}

3.1 Map中嵌套Map

案例代碼：

package com.gao_03;

public class Student {
    private String num;
    private String name;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String num, String name) {
        super();
        this.num = num;
        this.name = name;
    }
    public String getNum() {
        return num;
    }
    public void setNum(String num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [num=" + num + ", name=" + name + "]";
    }
    
    
}


package com.gao_03;

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

/*
 * itheima：基礎班,就業班
        基礎班:01 zhangsan；02 lisi
        就業班:01 wangwu；02 zhaoliu    
        

    分析：
            我們需要有班級和學生，班級和學生之間是一種對應關系（映射關系），
            由於有對應關系，所以我們可以使用Map集合來存儲這樣的數據，
            可以使用班級作為key，學生作為value，
            Map中的key只能對應一個value，但是我們一個班級中有多個學生，
            我們可以創建一個包含多個學生的集合，讓班級和這個集合產生一一對應的關系，
            學生信息分為學號和姓名，這也是一種對應關系，所以我們使用Map集合來存儲學生信息
            
    學校Map
            基礎班    基礎班學生Map
            就業班    就業班學生Map
            
    Map嵌套Map
    


 * 
 */
public class MapTest {
    public static void main(String[] args) {
        //學校Map
        Map<String,Map<String,String>> itheima = new HashMap<String,Map<String,String>>();
        
        //基礎班學生Map
        Map<String,String> base = new HashMap<String,String>();
        base.put("01", "zhangsan");
        base.put("02", "lisi");
        
        //就業班學生Map
        Map<String,String> job = new HashMap<String,String>();
        job.put("01", "wangwu");
        job.put("02", "zhaoliu");
        
        //把包含了學生的Map添加到學校Map中
        itheima.put("基礎班", base);
        itheima.put("就業班", job);
        
        //遍歷學校Map，查看有多少個班級和對應的學生
        //先獲取所有的班級
        Set<String> keys =itheima.keySet();
        for (String key : keys) {
            //輸出班級名稱
            System.out.println("班級名稱：" + key);
            
            //根據班級獲取對應的所有學生
            Map<String,String> stus = itheima.get(key);
            //獲取所有學生的學號
            Set<String> nums = stus.keySet();
            for (String num : nums) {
                //根據學號獲取學生姓名
                String name = stus.get(num);
                System.out.println("學號：" + num + ",姓名：" + name);
            }
        }
        
    }
}

案例代碼：

package com.gao_03;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/*
 * itheima：基礎班,就業班
        基礎班:01 zhangsan；02 lisi
        就業班:01 wangwu；02 zhaoliu
        
    更為面向對象
    
    
    學校Map
        基礎班    基礎班學生List
        就業班    就業班學生List
        
    Map嵌套Collection
        
    
 */
public class MapTest2 {
    public static void main(String[] args) {
        //學校Map
        Map<String,List<Student>> itheima = new HashMap<String,List<Student>>();
        
        //基礎班學生List
        List<Student> base = new ArrayList<Student>();
        base.add(new Student("01","zhangsan"));
        base.add(new Student("02","lisi"));
        
        //就業班學生List
        List<Student> job = new ArrayList<Student>();
        job.add(new Student("01","wangwu"));
        job.add(new Student("02","zhaoliu"));
        
        //把包含了學生對象的List添加到學校Map中
        itheima.put("基礎班", base);
        itheima.put("就業班", job);
        
        //遍歷學校Map，查看有多少班級和對應的學生
        //獲取所有Entry對象
        Set<Map.Entry<String,List<Student>>> entrys = itheima.entrySet();
        for (Map.Entry<String, List<Student>> entry : entrys) {
            //獲取班級
            String key = entry.getKey();
            System.out.println("班級名稱：" + key);
            //獲取包含了學生對象List
            List<Student> value = entry.getValue();
            for (Student student : value) {
                System.out.println(student);
            }
        }
    }
}

Java集合 -- HashSet 和 HashMap