java学习笔记 --- 集合（续）

1、map集合

　　1.1、特点：将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

　　1.2、Map集合和Collection集合的区别?
　　　　　　Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
　　　　　　Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)

　　1.3Map集合的功能概述：
　　　　　　1:添加功能
　　　　　　　　V put(K key,V value):添加元素。
　　　　　　　　　　　　　　　　　　　　如果键是第一次存储，就直接存储元素，返回null
 　　　　　　　　　　　　　　　　　　　 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
　　　　　　2:删除功能
　　　　　　　　 void clear():移除所有的键值对元素
　　　　　　　　 V remove(Object key)：根据键删除键值对元素，并把值返回
　　　　　　3:判断功能
　　　　　　　　boolean containsKey(Object key)：判断集合是否包含指定的键
　　　　　　　　boolean containsValue(Object value):判断集合是否包含指定的值
　　　　　　　　boolean isEmpty()：判断集合是否为空
　　　　　　4:获取功能
　　　　　　　　Set<Map.Entry<K,V>> entrySet():返回的是键值对对象的集合
　　　　　　　　V get(Object key):根据键获取值
　　　　　　　　Set<K> keySet():获取集合中所有键的集合
　　　　　　　　Collection<V> values():获取集合中所有值的集合
　　　　　　5：长度功能
　　　　　　 int size()：返回集合中的键值对的对数　　

public class MapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        // 添加元素
        // V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
        // System.out.println("put:" + map.put("文章", "马伊俐"));
        // System.out.println("put:" + map.put("文章", "姚笛"));
 
        map.put("邓超", "孙俪");
        map.put("黄晓明", "杨颖");
        map.put("周杰伦", "蔡依林");
        map.put("刘恺威", "杨幂");
 
        // void clear():移除所有的键值对元素
        // map.clear();
 
        // V remove(Object key)：根据键删除键值对元素，并把值返回
        // System.out.println("remove:" + map.remove("黄晓明"));
        // System.out.println("remove:" + map.remove("黄晓波"));
 
        // boolean containsKey(Object key)：判断集合是否包含指定的键
        // System.out.println("containsKey:" + map.containsKey("黄晓明"));
        // System.out.println("containsKey:" + map.containsKey("黄晓波"));
 
        // boolean isEmpty()：判断集合是否为空
        // System.out.println("isEmpty:"+map.isEmpty());
 
        //int size()：返回集合中的键值对的对数
        System.out.println("size:"+map.size());
 
        // 输出集合名称
        System.out.println("map:" + map);
    }
}

/*
 * 获取功能：
 * V get(Object key):根据键获取值
 * Set<K> keySet():获取集合中所有键的集合
 * Collection<V> values():获取集合中所有值的集合
 */
public class MapDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        // 创建元素并添加元素
        map.put("邓超", "孙俪");
        map.put("黄晓明", "杨颖");
        map.put("周杰伦", "蔡依林");
        map.put("刘恺威", "杨幂");
 
        // V get(Object key):根据键获取值
        System.out.println("get:" + map.get("周杰伦"));
        System.out.println("get:" + map.get("周杰")); // 返回null
        System.out.println("----------------------");
 
        // Set<K> keySet():获取集合中所有键的集合
        Set<String> set = map.keySet();
        for (String key : set) {
            System.out.println(key);
        }
        System.out.println("----------------------");
 
        // Collection<V> values():获取集合中所有值的集合
        Collection<String> con = map.values();
        for (String value : con) {
            System.out.println(value);
        }
    }
}

/**map集合的遍历：2 种方式*/
/*
 * Map集合的第一种遍历。
 * Map -- 夫妻对
 * 思路：
 *         A:把所有的丈夫给集中起来。
 *         B:遍历丈夫的集合，获取得到每一个丈夫。
 *         C:让丈夫去找自己的妻子。
 *
 * 转换：
 *         A:获取所有的键
 *         B:遍历键的集合，获取得到每一个键
 *         C:根据键去找值
 */
public class MapDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");
 
        // 遍历
        // 获取所有的键
        Set<String> set = map.keySet();
        // 遍历键的集合，获取得到每一个键
        for (String key : set) {
            // 根据键去找值
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }
    }
}
 
/*
 * Map集合的第2种遍历。
 * Map -- 夫妻对
 *
 * 思路：
 *         A:获取所有结婚证的集合
 *         B:遍历结婚证的集合，得到每一个结婚证
 *         C:根据结婚证获取丈夫和妻子
 *
 * 转换：
 *         A:获取所有键值对对象的集合
 *         B:遍历键值对对象的集合，得到每一个键值对对象
 *         C:根据键值对对象获取键和值
 *
 * 这里面最麻烦的就是键值对对象如何表示呢?
 *
 *         Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合
 */
public class MapDemo4 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<String, String> map = new HashMap<String, String>();
 
        // 创建元素并添加到集合
        map.put("杨过", "小龙女");
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("陈玄风", "梅超风");
 
        // 获取所有键值对对象的集合
        Set<Map.Entry<String, String>> set = map.entrySet();
        // 遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : set) {
            // 根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "---" + value);
        }
    }
}

2、HashMap:Map集合的子类。是基于哈希表的Map接口实现。
　　　　　　　　　　　哈希表的作用是用来保证键的唯一性的。

public class HashMapDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
 
        // 创建元素并添加元素
        // Integer i = new Integer(27);
        // Integer i = 27;
        // String s = "林青霞";
        // hm.put(i, s);
 
        hm.put(27, "林青霞");
        hm.put(30, "风清扬");
        hm.put(28, "刘意");
        hm.put(29, "林青霞");
 
        // 下面的写法是八进制，但是不能出现8以上的单个数据
        // hm.put(003, "hello");
        // hm.put(006, "hello");
        // hm.put(007, "hello");
        // hm.put(008, "hello");
 
        // 遍历
        Set<Integer> set = hm.keySet();
        for (Integer key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }
 
        // 下面这种方式仅仅是集合的元素的字符串表示
        // System.out.println("hm:" + hm);
    }
}

3、 LinkedHashMap:HashMap的子类，是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
　　　　　　由哈希表保证键的唯一性
　　　　　　由链表保证键盘的有序(存储和取出的顺序一致)

/*
 * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
 * 由哈希表保证键的唯一性
 * 由链表保证键盘的有序(存储和取出的顺序一致)
 */
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
 
        // 创建并添加元素
        hm.put("2345", "hello");
        hm.put("1234", "world");
        hm.put("3456", "java");
        hm.put("1234", "javaee");
        hm.put("3456", "android");
 
        // 遍历
        Set<String> set = hm.keySet();
        for (String key : set) {
            String value = hm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

4、TreeMap:是基于红黑树的Map接口的实现。

/*
 * TreeMap:是基于红黑树的Map接口的实现。
 *
 * HashMap<String,String>
 * 键：String
 * 值：String
 */
public class TreeMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        TreeMap<String, String> tm = new TreeMap<String, String>();
 
        // 创建元素并添加元素
        tm.put("hello", "你好");
        tm.put("world", "世界");
        tm.put("java", "爪哇");
        tm.put("world", "世界2");
        tm.put("javaee", "爪哇EE");
 
        // 遍历集合
        Set<String> set = tm.keySet();
        for (String key : set) {
            String value = tm.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

5、Collections：是针对集合进行操作的工具类，都是静态方法。

　　1、Collection和Collections的区别?
　　　　Collection:是单列集合的顶层接口，有子接口List和Set。
　　　　Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

　　2、Collections方法：

　　　　public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
　　　　public static <T> int binarySearch(List<?> list,T key):二分查找
　　　　public static <T> T max(Collection<?> coll):最大值
　　　　public static void reverse(List<?> list):反转
　　　　public static void shuffle(List<?> list):随机置换

public class CollectionsDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List<Integer> list = new ArrayList<Integer>();
 
        // 添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
 
        System.out.println("list:" + list);
 
        // public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
        // Collections.sort(list);
        // System.out.println("list:" + list);
        // [10, 20, 30, 40, 50]
 
        // public static <T> int binarySearch(List<?> list,T key):二分查找
        // System.out
        // .println("binarySearch:" + Collections.binarySearch(list, 30));
        // System.out.println("binarySearch:"
        // + Collections.binarySearch(list, 300));
 
        // public static <T> T max(Collection<?> coll):最大值
        // System.out.println("max:"+Collections.max(list));
 
        // public static void reverse(List<?> list):反转
        // Collections.reverse(list);
        // System.out.println("list:" + list);
 
        //public static void shuffle(List<?> list):随机置换
        Collections.shuffle(list);
        System.out.println("list:" + list);
    }
}