黑马程序员--Java学习日记之集合(map集合和collections类)

一、概述
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
在使用Collection集合的时候，存入时，就是简单的向集合中存储；取出时：使用数组、迭代器、List集合中增加了一个带”索引”的。但有的时候，我们存储一个对象，会给它”起个名字”，获取对象时，用这个名字就可以取出这个对象。这时候，对于我们取出对象，非常的方便；使用Map存储对象：存储时，要给对象起个名字，存入时，连名字和对象一起存储。 这个名字就是键(key)， 要存储的对象就是值(Value);

二、分类
Map我们需要学习的是他的三个子类，分别是HashMap、LinkedHashMap和TreeMap。它们各自的特点如下：
1.HashMap：基于哈希表的Map接口实现，哈希表的作用是用来保证键的唯一性
2.LinkedHashMap：由哈希表保证键的唯一性，有链表保证键存储的有序性(存储和取出顺序一样)
3.TreeMap：内部使用平衡二叉树的结构，这种树结构会对内部的“键”进行排序，排序方式有自然排序和比较器排序两种。

三、基本方法
※添加功能
V put(K key, V value):添加元素，如果键是第一次存储，就是直接存储元素，并返回null；如果键不是第一次存储，就用值把以前的值替换掉，返回以前的值
※删除功能
V remove(Object key)：根据键删除对应的值，并返回该值
void clear（）；移除所有的键值对元素
※判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value)：判断结合是否包含指定的值
boolean isEmpty（）：判断集合是否为空
※获取功能
int size()：返回集合中的键值对的对数
Collection values()：获取集合中所有值的集合
V get(Object key)：根据键来获取值，如果不包含，则返回null
：获取集合中所有键的集合
：返回此映射中包含的映射关系的Set视图，即获取所有的“键值对”对象的集合

四、HashMap
Map是接口，所以我们用他的一个子类HashMap来实例化。

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

/*
 * 主要是Map集合的一些功能
 * 
 */
public class MapMethod {
    public static void main(String[] args) {
        //实例化一个HashMap
        Map<String, String> map = new HashMap<>();
        /*
         * 添加功能
         */
        String v1 = map.put("java001", "王力宏");
        String v2 = map.put("java002", "张学友");
        String v3 = map.put("java003", "刘德华");
        String v4 = map.put("java004", "陈慧娴");
        //存一个重复的键，但不重复的值。结果：新值替换旧值，键不变
        String v5 = map.put("java004", "陈慧娴");
        System.out.println("v4 = " + v4);//null
        System.out.println("v5 = " + v5);//陈慧娴
        /*
         * 删除功能
         */
        System.out.println("删除键为：java001,返回的值：" + map.remove("java001"));//王力宏
        System.out.println("删除键为：java008,返回值为：" + map.remove("java008"));//null
        //清空集合功能
        //map.clear();

        /*
         * 判断功能
         */
        System.out.println("键java001是否存在：" + map.containsKey("java001"));//false
        System.out.println("键java002是否存在：" + map.containsKey("java002"));//true
        System.out.println("值：陈慧娴是否存在：" + map.containsValue("陈慧娴"));//true
        System.out.println("值：王力宏是否存在：" + map.containsValue("王力宏"));//false
        System.out.println("目前集合是否为空：" + map.isEmpty());//false
        //map.clear();
        System.out.println("清空集合后，集合是否为空：" + map.isEmpty());//true
        //最后打印一下集合
        System.out.println("打印集合：" + map);
    }
}1

这里在举个集合遍历的两个例子，第一个是用get()和keySet()方法；第二个使用entrySet()方法。

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

public class MapTraverse {
    public static void main(String[] args) {
        mapTraverseOne();//方法一
        mapTraverseTwo();//方法二
    }
    /*
     * 方法一：用get()和keySet()方法
     */
    public static void mapTraverseOne(){
        //实例化一个集合
        HashMap<String,String> map = new HashMap<>();
        //填充集合
        map.put("java001", "王力宏");
        map.put("java002", "张学友");
        map.put("java003", "刘德华");
        map.put("java004", "陈慧娴");

        //遍历
        //1.取所有的键
        Set<String> keySet = map.keySet();
        //2.遍历Set
        for(String key : keySet){
            System.out.println(key + "----" + map.get(key) );
        }
    }
    /*
     * 方法二：
     */
    public static void mapTraverseTwo()
    {
        // 实例化一个Map
        HashMap<String, String> map = new HashMap<>();
        // 填充集合
        map.put("java001", "王力宏");
        map.put("java002", "张学友");
        map.put("java003", "刘德华");
        map.put("java004", "陈慧娴");

        //获取"键值对"对象(Map.Entry类型的集合)
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for(Map.Entry<String, String>  entry : entrySet){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("key = " + key + " value = " + value);
        }

    }
}

五、LinkedHashMap:
此集合中的链表保证存储的元素和取出元素的顺序是一样的。

import java.util.LinkedHashMap;
import java.util.Set;
/*
 * LinkedHashMap集合中元素的存入顺序和取出的顺序是一样的
 */
public class LinkedHashMapDemo {
        public static void main(String[] args) {
        LinkedHashMap<String,String> map = new LinkedHashMap<>();
        map.put("java001", "王力宏");
        map.put("java002", "张学友");
        map.put("java003", "刘德华");
        map.put("java004", "陈慧娴");

        map.put("java002", "刘青云");//重复的键，没有添加

        //遍历
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println(key + "----" + map.get(key));//取出时跟存入的顺序是一致 的
        }
    }
}
1

六、TreeMap
TreeMap集合会对集合里的元素进行排序，如果是基本数据类型或者是String类型，就会自己自动排序，但是如果是引用数据类型，那就的自己去实现，这里我们用引用数据类型存储，并按指定的规则排序。其中有两种排序：
1.自然排序:类要实现Comparable接口，重写compareTo()方法。
2.比较器排序：类药实现Comparator接口，重写compare()方法。
这里我们用第一种方法，对Student类实现先按姓名字母排序，如果姓名相同，则按年龄从小到大排序

首先有个Student类，类中实现了Comparable接口，重写了compareTo()方法

//Student类实现了Comparable接口
public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //重写compareTo()方法
    @Override 
    public int compareTo(Student o) {
        int n1 = this.name.compareTo(o.getName());
        int n2 = (n1 == 0 ? this.age - o.getAge() : n1);
        return n2;
    }

}

这里讲一下HashMap和Hashtable的区别：

A.HashMap:①内部实现”哈希表”；
②并允许使用 null 值和 null 键；
③线程不同步。线程不安全，效率高；
④从1.2版本开始；

B.Hashtable:①内部实现”哈希表”
②不允许使用null值和null键；
③线程同步的。线程安全的，效率低；
④从1.0版本开始；

七、Collections类
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
※一些基本方法
：根据元素的自然顺序对指定列表按升序进行排序。
：在集合list中查找key，使用二分查找，其中list参数是要搜索的列表，key是要搜索的键
:根据元素的自然顺序，返回给定 collection 的最大元素。
:反转指定列表中元素的顺序。
:将内部的元素随机打乱；

方法举例:

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

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(20);
        intList.add(10);
        intList.add(60);
        intList.add(30);
        intList.add(50);
        intList.add(80);
        intList.add(40);
        intList.add(70);
        intList.add(90);
        intList.add(100);

        //1.sort(List<T> list)
        Collections.sort(intList);
        System.out.println("打印集合：" + intList);

        //2.int binarySearch(List<?> list,T key)
        System.out.println("在集合中查找80 ：" + Collections.binarySearch(intList, 80));//7
        System.out.println("在集合中查找800：" + Collections.binarySearch(intList, 800));//负数（没找到）
        //3.T max(Collection<?> coll)
        System.out.println("最大元素：" + Collections.max(intList));//100
        //4.reverse(List<?> list)
        System.out.println("将集合反转：");
        Collections.reverse(intList);
        System.out.println("反转后：" + intList);
        //5.shuffle(List<?> list)
        System.out.println("将集合中的元素打乱：");
        Collections.shuffle(intList);
        System.out.println("打乱后：" + intList);
    }
}

                                                                        ——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-