黑马程序员--集合框架（map集合，Collections,Arrays）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
Map集合:该集合存储键值对，是双列集合。一对一对往里面存,且要保证键的唯一性。
Map

|--HashTable  底层是哈希表数据结构，不可以存入null键和null值。
              用作键的对象必须实现hashCode和equals方法。
              该集合是线程同步的。
|--HashMap    底层是哈希表数据结构，允许使用null键和null值 。
              该集合是线程不同步的。
|--TreeMap    底层是二叉树结构，线程不同步，可以给Map集合的键值排序。

注意HashTable和HashMap的区别。

TreeMap中用作键的对象，必须实现Compareble接口，覆盖compareTo方法，让对象自身具备可比较性，称为对象的自然排序。也可以构造时，传入指定的比较器，对对象进行排序。

Map集合的共性方法

1.添加
V put(K k,V v)
注意：put方法使用时，如果存的两个数，键值相同，那么后者会覆盖前者，会把前边的值返回。
putAll(Map<? extends K,? extends V>)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key)
size()
Collection<V> valuse()返回此映射中包含的值的 Collection 视图。
 Set<Map.Entry<K,V>> entrySet() 
      返回此映射中包含的映射关系的 Set 视图。 
 Set<K> keySet() 
      返回此映射中包含的键的 Set 视图。 

Map集合和Set集合很像，其实，Set底层就是使用了Map集合

重点：Map集合的两种取出方式

1.Set<K> keySet():
将Map中所有的键存入到Set集合。因为Set具备迭代器。
所以可以迭代方式取出所有的键，根据get方法。获取每一个键对应的值。
2.Set<Map.Entry<K,V>> entrySet():
将Map中的映射关系存放在Set集合中，这种关系的类型是Map.Entry。

Map集合取出演示：

public void fun(){
    Map<String,String> map=new HashMap<String,String>();
        map.put("zhangsan","8");
        map.put("lisi","9");
        map.put("wangwu","10");
        map.put("hehe","20");

        //取出方式1
        //获取Map集合的所有键的Set集合，keySet();
        Set<String> keySet=map.keySet();
        //有了Set集合就可以。获取其迭代器
        Iterator<String> it=keySet.iterator();
        while(it.hasNext())
        {
            String key=it.next();
            //通过键获取值
            String value=map.get(key);
            System.out.println("name:"+key+", age:"+value);
        }

        //取出方式2
        //将Map集合中的映射关系取出。存入到Set集合中
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
        Iterator<Map.Entry<String,String>> it=entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<String,String> me=it.next();
            String value=me.getValue();
            String key=me.getKey();
            System.out.println("name:"+key+", age:"+value);
        }
}

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

Java为了方便对各种集合的操作提供了专门的操作工具：Collections，Arrays工具类。
Collections是专门对集合进行操作的工具类。
Collections中的常用方法：

1.static <T extends Comparable<? super T>> void sort(List<T> list)
    对list进行排序，按自然顺序从小到大排序
  static <T> void sort(List<T> list, Comparator<? super T> c) 
    根据指定比较器产生的顺序对指定列表进行排序 
2.static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 
      根据元素的自然顺序，返回给定 collection 的最大元素 
3.static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
      使用二分搜索法搜索指定列表，以获得指定对象。 
  static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
      使用二分搜索法搜索指定列表，以获得指定对象。 
4.static <T> void fill(List<? super T> list, T obj) 
      使用指定元素替换指定列表中的所有元素 
5.static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
      使用另一个值替换列表中出现的所有某一指定值。 
6.static void reverse(List<?> list) 
      反转指定列表中元素的顺序 
7.static <T> Comparator<T> reverseOrder() 
      返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
  static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
      返回一个比较器，它强行逆转指定比较器的顺序。 
8.static void swap(List<?> list, int i, int j) 
      在指定列表的指定位置处交换元素。 
9.<T> Collection<T> synchronizedCollection(Collection<T> c) 
      返回指定 collection 支持的同步（线程安全的）collection。 
  static <T> List<T> synchronizedList(List<T> list) 
      返回指定列表支持的同步（线程安全的）列表。 
  static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
      返回由指定映射支持的同步（线程安全的）映射。 
  static <T> Set<T> synchronizedSet(Set<T> s) 
      返回指定 set 支持的同步（线程安全的）set。 

Arrays:用于操作数组的工具类 ,里面都是静态方法.

asList();将数组转换成集合

将数组变成集合有什么好处呢？
可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合中的增删方法。
因为数组的长度是固定的。
可以使用：contains、get、indexOf、subList等方法，就是不能使用增删方法，因为数组的长度是固定的
如果增删，那么会发生UnsupportedOperationException。

如果数组中的元素都是对象。那么数组中的元素会直接转换成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
eg: 

    int[] nums={4,5,6,87,3,4};
    List<int[]> li=Arrays.asList(nums);
    System.out.println(li.size());  //结果为1
    Integer[] arr={4,5,6,87,3,5};
    List<Integer> list=Arrays.asList(arr);
    System.out.println(list.size());//结果为6

对对象进行比较，必须是玩Comparable 或者Compatator

集合变数组：
Collection接口中的toArray()
使用方法： T[] toArray(T[] a)将集合转换为数组。
转换时应当注意：

1.指定类型的数组长度要定义多长呢？
当定义类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size,当指定类型的数组长度大于集合的size，就不会创建新数组，而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2.为什么要将集合变数组呢？
为了限定对元素的操作。不需要进行增删了