java -- Map介面和可變參數_ZenDei技術網路在線

Kafka 環境搭建 kafka 安裝、配置、啟動、測試說明： 1. 安裝：直接官網下載安裝包，解壓到指定位置即可（kafka 依賴的 Zookeeper 在文件中已包含）下載地址：https://kafka.apache.org/downloads 示例版本：kafka_2.13-2.8.0.t ...

Map

Map: 映射, 是雙列集合頂層介面
java.util.Map<k,v>
k: key 鍵唯一
v: value 值可重覆

常用方法和Entry

public V put(K key,V Value)
// 指定的鍵與指定值添加到Map集合中, 添加成功返回null, 添加失敗返回之前的值
public V putIfAbsent(K key,V Value)
// jdk1.8後新增 鍵相同值不覆蓋返回原來的值

public V get(Object key)
// 根據指定的鍵, 獲取對應值, 不存在返回null
public V getOrDefault(Object key, V defaultValue)
// jdk1.8後新增 不存在返回defaultValue

public boolean containsKey(Object key)
// 判斷集合中是否包含指定的鍵

public V remove(Object key)
// 根據指定的鍵, 刪除一對元素, 返回被刪除的值
public V remove(Object key, Object value)
// 根據指定的鍵和值, 都一致則刪除, 返回被刪除的值

Set<K> keySet()
// 獲取存放所有鍵的Set集合
Collection<V> values()
// 獲取存放所有值的集合

Set<Map.Entry<K, V>> entrySet()
// 獲取鍵值對映射關係對象的Set集合


interface Entry<K,V>
K getKey()
// 獲取映射關係對象中的鍵
V getValue()
// 獲取映射關係對象中的值

LinkedHashMap

底層數據結構: 鏈表 + 哈希表
鏈表保證元素有序哈希表保證元素唯一

public class Demo {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<>();

        map.put("1張三",14);
        map.put("2李四",17);
        // put
        // 添加成功返回 null
        System.out.println(map.put("3王五", null));
        // 添加失敗返回之前的值, 並用新值覆蓋
        System.out.println(map.put("2李四", 19));

        // putIfAbsent
        // 鍵不存在添加新的鍵值對, 添加成功返回null
        System.out.println(map.putIfAbsent("4劉六", 19));
        // 若鍵存在 原有值不改變 並返回原有值
        System.out.println(map.putIfAbsent("1張三", 11));

        // get
        // 根據鍵找值, 存在則返回鍵對應的值
        System.out.println(map.get("1張三"));
        // 不存在則返回null
        System.out.println(map.get("2"));

        // getOrDefault
        // 鍵存在 返回對應值
        System.out.println(map.getOrDefault("1張三", -1));
        // 若不存在 則返回defaultValue
        System.out.println(map.getOrDefault("2", -1));

        // 判斷集合中是否包含指定的鍵, 存在返回true, 不存在返回false
        System.out.println(map.containsKey("2李四"));

        // 根據鍵刪除一對元素 返回被刪除的值
        // 不存在則返回null
        System.out.println(map.remove("1"));
        System.out.println(map.remove("1張三"));

        System.out.println(map);

        // 遍歷
        // 方式1
        // 獲取存放所有鍵的集合
        Set<String> set = map.keySet();
        // 獲取存放所有值的集合
        Collection<Integer> values = map.values();

        // 迭代器
        Iterator<Integer> iterator = values.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        // 增強for
        for (Integer value : values) {
            System.out.print(value + " ");
        }
        System.out.println();

        // 迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            System.out.print(key + " = " + map.get(key) + "\t");
        }
        System.out.println();
        // 增強for
        for (String s : set) {
            System.out.print(s + " = " + map.get(s) + "\t");
        }
        System.out.println();

        // 方式2
        // Entry是Map的內部類 所以調用時需要Map.Entry
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        // 迭代器
        Iterator< Map.Entry<String, Integer>> entries = entrySet.iterator();
        while (entries.hasNext()) {
            Map.Entry<String, Integer> next = entries.next();
            System.out.print(next.getKey() + " = " + next.getValue() + "\t");
        }
        System.out.println();
        // 增強for
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.print(entry.getKey() + " = "+entry.getValue() + "\t");
        }
    }
}

TreeMap

java.util.TreeMap
底層數據結構是紅黑樹鍵排序具有唯一性不允許null鍵允許null值

/*
    java.util.TreeMap
        底層數據結構是紅黑樹  鍵 排序 具有唯一性  不允許null鍵 允許null值
        構造方法:
            public TreeMap() 空參構建, 集合中的鍵必須實現自然排序介面 Comparable 的方法 CompareTo
            public TreeMap(Comparator<? super K> comparator) 需傳入比較器對象
 */

public class Demo {
    public static void main(String[] args) {
        TreeMap<Person, String> map = new TreeMap<>();
        map.put(new Person("張三",12),"bj");
        map.put(new Person("張三",14),"sh");
        map.put(new Person("李四",15),null);
        map.put(new Person("王五",11),"gz");
        map.put(new Person("宮本",19),"jp");
        // 不允許null鍵
        // map.put(null,"us");
        System.out.println(map);
        // 獲取第一個鍵
        System.out.println(map.firstKey());
        // 獲取最後一個鍵
        System.out.println(map.lastKey());
        // 獲取第一個鍵值對
        System.out.println(map.firstEntry());
        // 獲取最後一個鍵值對
        System.out.println(map.lastEntry());
        // 獲取 按排序方法 取索引 >= 指定鍵的最小鍵(>=指定鍵並距離最近)
        System.out.println(map.ceilingKey(new Person("李四", 13)));
        // 獲取 按排序方法 取索引 >= 指定鍵的最小鍵值對(>=指定鍵並距離最近)
        System.out.println(map.ceilingEntry(new Person("李四", 13)));
        // 獲取 按排序方法 取索引 <= 指定鍵的最小鍵(<=指定鍵並距離最近)
        System.out.println(map.floorKey(new Person("李四", 13)));
        // 獲取 按排序方法 取索引 <= 指定鍵的最小鍵值對(<=指定鍵並距離最近)
        System.out.println(map.floorEntry(new Person("李四", 13)));
        System.out.println("=================");

        TreeMap<Person, String> treeMap = new TreeMap<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                if (o1.age == o2.age) {
                    return o2.name.compareTo(o1.name);
                }
                return o1.age - o2.age;
            }
        });
        treeMap.put(new Person("張三",12),"bj");
        treeMap.put(new Person("張三",14),"sh");
        treeMap.put(new Person("李四",15),null);
        treeMap.put(new Person("王五",11),"gz");
        treeMap.put(new Person("宮本",19),"jp");
        System.out.println(treeMap);


    }
}


class Person implements Comparable<Person> {
    String name;
    int age;

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

    @Override
    public int compareTo(Person o) {
        if (o.age == this.age) {
            return o.name.compareTo(this.name);
        }
        return o.age - this.age;
    }

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

HashMap

/*
    java.util.HashMap
        底層數據結構是哈希表 允許null鍵和null值  鍵是無序的 具有唯一性
        先比較hashCode
            不同 元素不相同
            相同 繼續比較equals
                相同
                不同
        因此必須重寫hashCode和equals方法
 */

public class Demo {
    public static void main(String[] args) {
        Map<Person, String> map = new HashMap<Person, String>();
        map.put(new Person("張三",12),"bj");
        map.put(new Person("李四",12),"sh");
        map.put(new Person("王五",12),"gz");
        map.put(new Person("宮本",12),"jp");
        map.put(null,"us");

        Set<Person> peopleSet = map.keySet();
        for (Person person : peopleSet) {
            if (person == null) {
                System.out.println(person + " " + map.get(person));
                continue;
            }
            System.out.println(person.getName() + " " + person.getAge() + " " + map.get(person));
        }

        Set<Map.Entry<Person, String>> entries = map.entrySet();
        for (Map.Entry<Person, String> entry : entries) {
            Person key = entry.getKey();
            if (key == null) {
                System.out.println(key + " " + entry.getValue());
                continue;
            }
            System.out.println(key.getName() + " "+ key.getAge() + " "+entry.getValue());
        }

    }

}
class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

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

可變參數

在JDK1.5之後，如果我們定義一個方法需要接受多個參數，並且多個參數類型一致，我們可以對其簡化.

// 格式
修飾符 返回值類型 方法名(參數類型... 形參名){  }
/*
    可變參數 指參數的個數可變
        當參數數據類型確定,且需要較多次重載時, 可以使用可變參數
        可變參數必須放在參數列表的最後, 且只能有一個可變參數
        格式: 本質上就是數組
            public static int avg(int... nums)
            當不傳入參數時, 相當於傳了空數組
            由於本質是數組, 因此傳入數組也可以
*/

public class function {
    public static void main(String[] args) {

        System.out.println(avg(1,2,3,4,5,7,8,9,2));
        System.out.println(avg(18,9,2));
        System.out.println(avg(1,2));
        int[] arr = {1,23,42,45,34,21};
        System.out.println(avg(arr));
    }

    public static int avg(int... nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum / nums.length;
    }
}

練習

使用Map重寫前天第十一題

使用54張牌打亂順序,三個玩家參與游戲，三人交替摸牌，每人17張牌，最後三張留作底牌.

import java.util.*;

public class PokerDemo {
    public static void main(String[] args) {
        Map<Integer, String> pokerMap = new HashMap<Integer, String>();
        ArrayList<Integer> pokerIndex = new ArrayList<Integer>();
        String[] colors = {"♥","♠","♣","♦"};
        String[] numbers = "2-A-K-Q-J-10-9-8-7-6-5-4-3".split("-");
        int index = 2;
        pokerMap.put(0, "大王");
        pokerMap.put(1, "小王");
        for (String number : numbers) {
            for (String color : colors) {
                pokerMap.put(index, color+number);
                index++;
            }
        }

        for (int i = 0; i < 54; i++) {
            pokerIndex.add(i);
        }
        Collections.shuffle(pokerIndex);

        ArrayList<Integer> player1 = new ArrayList<Integer>();
        ArrayList<Integer> player2 = new ArrayList<Integer>();
        ArrayList<Integer> player3 = new ArrayList<Integer>();
        ArrayList<Integer> dipai = new ArrayList<Integer>();

        for (int i = 0; i < pokerIndex.size(); i++) {
            if (i >= 51){
                dipai.add(pokerIndex.get(i));
            } else if (i % 3 == 0) {
                player1.add(pokerIndex.get(i));
            } else if (i % 3 == 1) {
                player2.add(pokerIndex.get(i));
            } else {
                player3.add(pokerIndex.get(i));
            }
        }

        System.out.println("玩家1: " + showPoker(player1, pokerMap));
        System.out.println("玩家2: " + showPoker(player2, pokerMap));
        System.out.println("玩家3: " + showPoker(player3, pokerMap));
        System.out.println("底牌: " + showPoker(dipai, pokerMap));
    }
    public static String showPoker(ArrayList<Integer> player, Map<Integer, String> pokerMap) {
        Collections.sort(player);
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < player.size(); i++) {
            sb.append(pokerMap.get(player.get(i)));
            if (i == player.size() - 1) {
                sb.append("]");
            } else {
                sb.append(", ");
            }
        }
        return sb.toString();
    }
}