java集合三：Map

HashMap

package com.company.map;
/*
    存储在HashMap中的key部分的元素,需要同时重写hashCode + equals方法

    关于Map集合中的常用方法：
        void clear();   情况Map
        boolean isEmpty(); 判断该集合是否为空
        int size(); 获取Map中键值对的个数

        boolean containsKey(Object key); 判断Map中是否包含这样的key
        boolean containsValue(Object value); 判断Map中是否包含这样的value

        Set<Map.Entry<K,V>> entrySet()  返回此映射中包含的映射关系的 Set 视图。

        Object get(Object key);  通过key获取value
        Object put(Object key, Object value); 向集合中添加键值对

        Object remove(Object key); 通过这个key将键值对删除

        set keySet(); 获取Map中所有的key
        Collection values(); 获取Map集合中所有的value
*/
import java.util.*;

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

        // 1.创建Map集合
        Map persons = new HashMap();  // HashMap的默认初始化容量是16，默认加载因子是0.75

        // 2.储存键值对
        persons.put("10000", "Jack");
        persons.put("10001", "SUN");
        persons.put("10004", "Tom");
        persons.put("10007", "Tony");
        persons.put("10000", "Bob");

        // 3.输出键值对个数
        System.out.println(persons.size());  // 4 最后一个key值重复，存储是会覆盖掉

        // 4.判断集合中是否包含这样的key
        System.out.println(persons.containsKey("10000"));  // true

        // 5.判断集合中是否包含这样的value
        // 【注意】：Map中如果key重复了，value采用的是“覆盖”
        System.out.println(persons.containsValue("Bob"));  // true  key值重复，存储是会覆盖掉

        // 6.通过key获取value
        String k = "10000";
        Object v = persons.get(k);
        System.out.println(v);  // Bob

        // 7.通过key删除键值对
        persons.remove("10001");
        System.out.println(persons.size());  // 3

        // 8.获取所有的value
        // 所有的value是Collection的集合
        Collection values = persons.values();
        Iterator it = values.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        // 9.获取所有的key
        // 所有的key是一个Set集合
        // 以下程序演示如何遍历Map集合
        Set keys = persons.keySet();
        Iterator it2 = keys.iterator();
        while(it2.hasNext()){
            Object id = it2.next();
            Object name = persons.get(id);
            System.out.println(id + "-->" + name);
            /*
                输出是无序的
                10007-->Tony
                10000-->Bob
                10004-->Tom
            */
        }

        // 10.entrySet
        // 将Map转换成Set集合，这种方法用得并不多
        Set entrySet = persons.entrySet();
        Iterator it3 = entrySet.iterator();
        while(it3.hasNext()){
            System.out.println(it3.next());
            /*
                10007=Tony
                10000=Bob
                10004=Tom
            */
        }
    }
}

Properties

package com.company.map;

import java.util.Properties;

/*
    HashMap默认初始化容量是16，默认加载因子是0.75
    Hashtable默认初始化容量是11，默认加载因子是0.75

    java.util.Properties; 也是由key和value组成，但是key和value都是字符串类型。
*/
public class MapTest02 {
    public static void main(String[] args) {

        // 1.创建属性类对象
        Properties p = new Properties();

        // 2.存  注意：key不能重复，如果重复则value覆盖。
        p.setProperty("driver", "oracle.jdbc.diver.OracleDiver");
        p.setProperty("username", "scott");
        p.setProperty("password", "tiger");
        p.setProperty("url", "jbc:oracle:thin:@192.168.1.100:1521:company");
        p.setProperty("username", "scottt");

        // 3.取，通过key获取value
        String v1 = p.getProperty("driver");
        String v2 = p.getProperty("username");
        String v3 = p.getProperty("password");
        String v4 = p.getProperty("url");

        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);

    }
}

SortedMap

package com.company.map;
/*
    SortedMap中的key特点：无序不可重复，但是存进去的元素可以按照大小自动排列。

    如果想自动排序，key部分的元素需要：1.实现Comparable接口； 2.单独写一个比较器。
*/
import java.util.*;

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

        // Map, key存储Product,value存储重量
        SortedMap products = new TreeMap();

        // 准备对象
        Product p1 = new Product("西瓜", 2.5);
        Product p2 = new Product("苹果", 5.5);
        Product p3 = new Product("香蕉", 3.98);
        Product p4 = new Product("葡萄", 4.29);

        // 添加
        products.put(p1, 8.0);
        products.put(p2, 3.0);
        products.put(p3, 5.0);
        products.put(p4, 2.0);

        // 遍历
        Set keys = products.keySet();
        Iterator it = keys.iterator();
        while(it.hasNext()){
            Object k = it.next();
            Object v = products.get(k);
            System.out.println(k + "-->" + v + "kg");
        }
    }
}

// 实现Comparable接口
class Product implements Comparable{

    String name;
    double price;

    Product(String name, double price){
        this.name = name;
        this.price = price;
    }

    public String toString(){
        return "Product[name:" + name + ", price:" + price + " ]";
    }

    public int compareTo(Object o){
        double price1 = this.price;
        double price2 = ((Product)o).price;
        if(price1 < price2){
            return -1;
        }else if(price1 > price2){
            return 1;
        }else{
            return 0;
        }

    }
}

package com.company.map;
/*
    用比较器的方法，有两种方法：
        1.额外再编写一个类实现Comparator(),重写compare()方法
        2.匿名内部类：这种方法需要注意在创建是内部类必须是：new Comparator(){}

*/

import java.util.*;

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

        // Map, key存储Product,value存储重量
        // 采用匿名内部类
        SortedMap products = new TreeMap(new Comparator() {
            public int compare(Object o1, Object o2) {

                double price1 = ((Product1) o1).price;
                double price2 = ((Product1) o2).price;

                if (price1 == price2) {
                    return 0;
                } else if (price1 > price2) {
                    return 1;
                } else {
                    return -1;
                }
            }
        });

        // 准备对象
        Product1 p1 = new Product1("西瓜", 2.5);
        Product1 p2 = new Product1("苹果", 5.5);
        Product1 p3 = new Product1("香蕉", 3.98);
        Product1 p4 = new Product1("葡萄", 4.29);

        // 添加
        products.put(p1, 8.0);
        products.put(p2, 3.0);
        products.put(p3, 5.0);
        products.put(p4, 2.0);

        // 遍历
        Set keys = products.keySet();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            Object k = it.next();
            Object v = products.get(k);
            System.out.println(k + "-->" + v + "kg");
        }
    }
}

// 实现Comparable接口
class Product1 {

    String name;
    double price;

    Product1(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String toString() {
        return "Product[name:" + name + ", price:" + price + " ]";
    }

}