——- android培训、java培训、期待与您交流！ ———-

Map接口

Map接口概念：

Map并没有继承Collection接口，可用于保存具有映射关系的数据，其提供的是key到value的映射。因此，Map集合中保存这两组值，一组用于保存key，另一组用于保存value，key和value都可以是任何引用数据类型。
注意：Map集合中的key不允许重复，每一个key只能映射一个value。

Map和Collection的区别：

Collection一次存一个元素；Map一次存一对元素。
Collection是单列集合；Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

Map

|——Hashtable：是线程同步的，不允许存储null键和null值，底层是哈希表数据结构。

|——HashMap：线程是不同步的，允许存储null值好null值，底层是哈希表数据结构，替代了Hashtable。

|——TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map中常用的方法:

//一对一模式
package MapDemo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapDemo {

    public static void main(String args[]){
        //demo1();
        //demo2();
        //demo3();
        demo4();
    }

    public static void demo1(){
        HashMap hm = new HashMap();
        hm.put("01", "java1");  //将指定的值与此映射中的指定键关联
        hm.put("02", "java2");
        hm.put("03", "java3");
        hm.put("04", "java4");
        hm.put("05", "java5");

        //hm.clear();      //从此映射中移除所有映射关系。

        sop(hm.size());  //返回此映射中的键-值映射关系数。

        sop(hm.values());  //返回此映射中包含的值的 Collection 视图。
    }

    public static void demo2(){
        HashMap hm = new HashMap();
        hm.put("01", "java1");  //将指定的值与此映射中的指定键关联
        hm.put("02", "java2");
        hm.put("03", "java3");
        hm.put("04", "java4");
        hm.put("05", "java5");

        Collection coll = hm.values();  //取出Map集合中的value值第一种方法

        Iterator it = coll.iterator();
        while(it.hasNext()){
            sop(it.next());
        }
    }

    public static void demo3(){
        HashMap hm = new HashMap();
        hm.put("01", "java1");  //将指定的值与此映射中的指定键关联
        hm.put("02", "java2");
        hm.put("03", "java3");
        hm.put("04", "java4");
        hm.put("05", "java5");

        Set keySet = hm.keySet();  //取出Map集合中的value值第二种方法

        Iterator it = keySet.iterator();
        while(it.hasNext()){
            String key = (String) it.next();
            String value = (String) hm.get(key);
            sop(value);
        }
    }

    public static void demo4(){
        HashMap hm = new HashMap();
        hm.put("01", "java1");  //将指定的值与此映射中的指定键关联
        hm.put("02", "java2");
        hm.put("03", "java3");
        hm.put("04", "java4");
        hm.put("05", "java5");

        Set me = hm.entrySet();      //取出Map集合中的value值第四种方法
        Iterator it = me.iterator();
        while(it.hasNext()){
            Map.Entry i = (Entry) it.next();
            String key = (String) i.getKey();
            String value = (String) i.getValue();
            sop(key+"………………"+value);
        }
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }

}

//一对多模式
package MapDemo2;

import java.awt.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class MapDemo2 {
    

    public static void main(String[] args) {
        HashMap sdxx = new HashMap();

        ArrayList yiban = new ArrayList();
        ArrayList erban = new ArrayList();

        yiban.add(new Student("01","zhangsan"));
        yiban.add(new Student("02","lisi"));

        erban.add(new Student("01","zhaoliu"));
        erban.add(new Student("02","wangwu"));

        sdxx.put("key1", yiban);
        sdxx.put("key2", erban);

        Set keySet = sdxx.keySet();

        Iterator it = keySet.iterator();
        while(it.hasNext()){
            getInfo((ArrayList) sdxx.get(it.next()));
        }

    }

    public static void getInfo(ArrayList list){
        Iterator it = list.iterator();
        while(it.hasNext()){
            sop(it.next());
        }
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }

}

class Student{
    String num;
    String name;
    public Student(String num,String name){
        this.num = num;
        this.name=name;
    }
    public String toString(){
        return num+"------"+name;
    }
}

HashMap和Hashtable的区别

public static void main(String[] args) {
        /*HashMap和Hashtable的区别？
         * 1.HashMap和Hashtable都是哈希算法
         * 
         * 2.HashMap是jdk。1.2版本出来的，线程不安全，效率快；
         *    Hashtable是jdk1.0版本出来的，线程安全，效率低
         *    
         *  3.HashMap中键，值都可以为null
         *    Hasheable中键和值不能为null*/

        HashMap<String,String> hm = new HashMap<>();
        hm.put("abc", null);
        hm.put(null, "abc");
        System.out.println(hm);//{null=abc, abc=null}

        Hashtable<String,String> ht = new Hashtable<>();
        ht.put("abc", null);
        ht.put(null, "abc");
        System.out.println(ht);// java.lang.NullPointerException
    }

使用集合的技巧：
看到Array就是数组结构，有角标，查询速度很快。
看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
看到tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

保证唯一，就用Set。不保证唯一，就用List。

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

Collections类常用的方法：

public class DemoCollections {
    

    /*
     * Collections和Collection的区别是
     * Collection是集合的跟接口
     * Collections是集合的工具类，，其中方法都是静态的可以直接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 static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("a");
        list.add("d");
        list.add("x");
        list.add("e");
        Collections.sort(list);
        System.out.println(list);//[a, c, d, e, x]sort 对集合中的方法进行排序

        int index = Collections.binarySearch(list, "e");
        System.out.println(index);//3 利用二分查找法对指定元素的索引

        String s = Collections.max(list);
        System.out.println(s);//x 找集合中最大的

        Collections.replaceAll(list, "x", "w");//替换集合中所有的指定元素
        System.out.println(list);//[a, c, d, e, w]

        Collections.reverse(list);
        System.out.println(list);//[w, e, d, c, a]将集合中的所用元素反转

        Collections.shuffle(list);
        System.out.println(list);//[w, a, d, e, c]使用默认随机源对集合中元素进行置换，此方法可用于模拟发牌
    }

}

Arrays：用于操作数组对象的工具类，里面都是静态方法。

Arrays工具类的asList()方法的使用

package cn.itcast.vector;

import java.util.Arrays;
import java.util.List;

public class DemoAsList {
    
    public static void main(String[] args) {
        //int[] arr = {11,22,22,33,44};
        //List<int[]> li = Arrays.asList(arr);
        //System.out.println(li);//此处输出是[[[email protected]]因为此方法把整个数组当成一个对象，
                                //与下面的字符串比较，所以aslist不能转基本数据类型，只能转化引用数据类型

        //基本数据类型可以用Integer进行转换
        Integer[] arr2 = {
   11,22,22,33,44};//Integer可以自动装箱，他把每一个数当成一个对象装箱
        List<Integer> li2 = Arrays.asList(arr2);
        System.out.println(li2);
        //String[] arr = {"44","55","66","77"};
        //List<String>list=Arrays.asList(arr);//调用Array中的aslist方法
        //System.out.println(list);

    }

}

Collection 和 Collections的区别：

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。