Map（接口简介、HashMap集合、TreeMap集合、Properties、泛型、Collections工具类、Arrays工具类）

一、Map接口简介

Map接口是一种双列接口，每个元素都包含一个键对象Key和一个值对象Value，键值之间的关系称为映射。从Map访问元素时，只需指定Key，就能找到对应的Value。

部分方法

put(key,value)//将指定的值与映射中的指定键关联（可选操作）
get(key)//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null
containsKey(key)//此映射包含指定键的映射关系，则返回true
containsValue(value)//如果此映射将一个或多个键映射到指定值，则返回true
KeySet()//此映射中包含的键和Set试图
Collection<V>values()//返回此映射中包含的值的Collection试图
Set<Map.Entry<k,v>>entrySet()//返回此映射中包含的值的Set试图

put和get是用来像Map中存储和取出元素
ContainsKey和ContainsValue是用于判断Map中是否包含某个指定的键或值。keySet和values方法分别用于获取Map中的所有值

二、HahsMap集合

适用HashMap集合，必须保证不出现重复的键。如果出现了相同的键，后存储的值则会覆盖原有的值，简而言之就是“键相同，值覆盖”

遍历Map中所有的键值对方法。
①先遍历Map集合中的所有键，再根据建获取相应的值

Map map = new HashMap();            // 创建Map集合
map.put("1", "Jack");               // 存储键和值
Set keySet = map.keySet();         // 获取键的集合
Iterator it = keySet.iterator();  // 迭代键的集合
while (it.hasNext()) {
    Object key = it.next();
    Object value = map.get(key);  // 获取每个键所对应的值
    System.out.println(key + ":" + value);
}

②先获取集合中的所有的映射关系，然后从映射关系中取出键和值

Map map = new HashMap();    // 创建Map集合
map.put("1", "Jack");       // 存储键和值
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();  // 获取Iterator对象
while (it.hasNext()) {
    Map.Entry entry = (Map.Entry) (it.next());// 获取集合中键值对映射关系
    Object key = entry.getKey();                // 获取Entry中的键
    Object value = entry.getValue();           // 获取Entry中的值
    System.out.println(key + ":" + value);
}

//首先调用Map对象的entrySet方法，获得存储在Map集合中所有映射的Set集合，这个集合中存放了Map.Entry类型的元素，每个Map.Entry对象代表Map中的一个键值对，然后迭代Set集合，或得每一个映射对象，分别调用映射对象的getKey()方法和getValue方法获取键和值。

在Map中还提供了一个values方法，通过该方法可以直接获取Map中存储所有值的Collection集合。

Map map=new HashMap();
map.put("1","jack");
Collection values=map.values();
Iterator it=values.iterator();
while(it.hasNext()){
    Object value=it.next();
    System.out.prinln(value);
}

三、LinkedHashMap类
HashMap集合迭代出元素的顺序和存入是不一样的，于是使用LinkedHashMap来使Map元素迭代的顺序与存入的顺序一致。和LinkedList一样也使用双向链表来维护内部元素的关系。

Map map=new LinkedHashMap();
map.put("1","jack");
Set keySet=map.keySet();
Iterator it=keySet.iterator();
while(it.hasNext()){
    Object key=it.next();
    Object value=map.get(key);
    System.out.println(key+":"+value);
}

四、TreeMap集合

Map接口还有一个常用的实现类TreeMap。该集合用来存储键值映射关系，不允许出现重复的键。该集合是通过二叉树原理来保证键的唯一性，这与TreeSet集合存储的原理一样。

TreeMap tm=new TreeMap();
tm.put("1","jack");
Set keySet=tm.keySet();
Iterator it=keySet.iterator();
while(it.hasNext()){
    Object key=it.next();
    Object value=tm.get(key);
    System.out.println(key+":"+value);
}

//发现结果按照 学号排序 。因为学号是String类型，实现了Comparable接口，因此会默认按照自然顺序进行排序

也可以通过自定义比较器的方式对所有的键进行排序，下面按照学号从大到小比较器的案例

TreeMap tr=new TreeMap(new Mycomparator());//传入自定义比较器
tm.put("1","jack");
Set keySet=tm.keySet();
Iterator it=keySet.iterator();
while(it.hasNext()){
    Object key=it.next();
    Object value=tm.get(key);
    System.out.println(key+":"+value);
}

//
class MyComparator implements Comparator {         // 自定义比较器
    public int compare(Object obj1, Object obj2) {// 实现比较方法
        String id1 = (String) obj1;                  // 将Object类型的参数强转为String类型
        String id2 = (String) obj2;   
        return id2.compareTo(id1);                   // 将比较之后的值返回
    }
}

四、Properties集合

Properties是Hashtable的子类，虽然Hashtable已经被HashMap取代，但是该子类确很重要

主要有从来存储字符串类型的键和值，实际开发中，经常使用他来存取应用的配置项。

import java.util.*;
public class Example01 {
   public static void main(String[] args) {
        Properties p=new Properties();             // 创建Properties对象
        p.setProperty("backgroup-color", "red");
        p.setProperty("Font-size", "14px");
        p.setProperty("Language", "chinese");
        Enumeration names = p.propertyNames();   // 获取Enumeration对象所有键的枚举
        while(names.hasMoreElements()){           // 循环遍历所有的键
            String key=(String) names.nextElement();
            String value=p.getProperty(key);        // 获取对应键的值
            System.out.println(key+" = "+value);
        }
    }
}

五、泛型

何为泛型？
集合可以存储任何类型的数据，但是当把对象存入集合后，集合汇忘记该对象的类型。将该对象取出的时候，获得的是一个Object类型。程序无法确定一个集合中的元素到底是什么类型，因此，如果取出元素时进行强制类型转换就会出错。

例如存入了String类型 和 Integer 类型时，取出时再转换为String类型就会出错。为了解决这个问题，java引入了“参数化类型”即泛型。
泛型可以限定方法操作的数据类型，在定义集合类时，使用<参数化类型> 的方法来制定该类中方法操作的数据类型

ArrayList <参数化类型> list=new ArrayList<参数化类型>();

自定义泛型

假如我们要做个自定义容器来保存数据。那么该容器一定要有两个方法，一个是save方法用来保存数据，一个是get方法用来获取数据。
定义如下

void save(参数类型 参数){}
返回值 参数类型 get(){ }

声明一个类时使用泛型，指定其参数类型，并将save的参数类型和get的返回值类型都指定为T(type的缩写，可使用其他类型，但方便理解一般使用T)

class cachePool<T> {             // 在创建类时，声明参数类型为T
    T temp;
    public void save(T temp) { // 在创建save()方法时，指定参数类型为T
        this.temp = temp;
    }
     public T get() {             // 在创建get()方法时，指定返回值类型为T 
        return temp;
    }
}
public class Example26 {
    public static void main(String[] args) {
        // 在实例化对象时，传入参数为Integer类型
         cachePool<Integer> pool = new cachePool<Integer>(); 
         pool.save(new Integer(1));
         Integer temp = pool.get();
         System.out.println(temp);
    }
}

六、Collections工具类

为了方便操作集合，JDK专门提供了一个工具类Collections 位于java.util
排序操作

直接使用Collections调用即可

查找、替换操作

七、Arrays工具类
这是用来专门操作数组的工具类 Arrays

Arrays的sort方法进行排序

Arrays.sort(xxx)//xxx为数组名

Arrays的binarySearch(xxx,yyy)查找元素
注意 该方法只针对排序后的数组

binarySearch(xxx,yyy)
//xxx为数组名，yyy为需要查找的元素

Arrays的copyOfRange(xxx,from,to)赋值部分数组

copyOfRange(xxx,from,to)
//xxx为原数组名，from为复制起始元素索引（包括），to为结束元素索引（不包括）

Arrays的fill(xxx,yyy)填充元素（用一个值替换所有元素）

Arrays的fill(xxx,yyy)
//xxx为数组名 ，yyy为需要填入的元素

Arrays的toString(xxx)把数组转换为字符串
该方法并不是把Object类的toString方法重写

Arrays的toString(xxx)
//xxx为数组名