Map、Collections、Arrays

集合框架中的另一个顶层接口：Map

Map：用于存储具备着对应关系的键和值。而且要保证键的唯一性。一次存储一对元素。

Collection一次存储一个元素。称之为单利集合。

Map集合一次存储一对元素，称之为双列集合

Map常见方法：

1， 添加。

v put(k,v)

voidputAll(map);

2， 删除

void clear():清空集合

v remove（key）：通过键删除元素，并返回对应的值

3， 判断

boolean containsKey（key）;

boolean containsValue(value);

boolean isEmpty（）；

4， 获取

value get（key）：根据键获取值，如果键不存在，返回null。可以用来判断一个集合中是否存在某一个键。

5， 获取map中所有的元素（对应关系）。

Map是不具备迭代器的，获取原理就是将map集合先转成set集合。然后在使用迭代器。

Set<key>keySet();

Set<Map.Entry<key,value>>entrySet();

Collection<value>values();获取map集合号所有的值。

 

Map体系：

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

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

    |——TreeMap：可以对Map集合中的键进行指定顺序的排序。默认是使用键的自然顺序，当然也可以使用比较器

map集合的两种取出方式：

1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，

补充：关于Map.Entry

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

原因：a.Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

            b.并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

什么时候使用map呢？

当分析问题时，发现其中存在着映射关系，这时应该想到两个容器，一个是map一个是数

组。如果映射关系的一方是有序的编号（可以作为索引），而且映射关系的个数确定，建议使用数组。否则，就使用map集合。

凡是映射关系的出现，都可以使用查表法的思想去解决问题。

 

其它集合什么时候使用呢？

如果要保证元素的唯一性，不存在映射关系，必须先考虑使用set集合

如果不需要保证唯一性，直接考虑list集合。

 

Collections工具类：

在Collections工具类中很多方法是用于对List集合进行操作的，如比较，查找，随机排序等等

1、集合的各种方法：

 

1）查找：

  T max(Collection<?extends T> coll) --->根据集合的自然顺序，获取coll集合中的最大元素

  Tmax(Collection<? extends T> coll,Comparator<? super T> comp)--->根据指定比较器comp

的顺序，获取coll集合中的最大元素

int binarySearch(Lsit<?extends Comparable<? super T>> list,Tkey) --->二分法搜索list集合

中的指定对象

2）替换：

      voidfill(List<? super T> list, T obj) --->将list集合中的全部元素替换成指定对象obj

      booleanreplaceAll(List<T> lsit,T oldVal,T newVal) --->使用newVal替换list集合中的

oldVal值

 

3）排序：

      void shuffle(List<?> list)--->使用默认随机源对list集合中的元素进行随机排序

      voidsort(Lsit<T> list)--->根据自然顺序对list集合中的元素进行排序

      voidsort(List<T> lsit,Comparator<? super T> c) --->根据指定比较器c的排序方式对list集合进行排序

4）反转

     reverse(List<?> list) --->反转list集合中元素的顺序

      ComparatorreverseOrder()--->返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

      ComparatorreverseOrder(Comparator<T> cmp)    --->   返回一个比较器，强行逆转了指定比较器的顺序

 

示例：

                                

                                publicstatic void sop(Object obj)
                                {
                                   System.out.println(obj);
                                }
                                //定义比较器
                                classStrLenCom implements Comparator<String>
                                {
                                   publicint compare(String s1,String s2)
                                   {
                                          intn = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                                          if(n == 0)
                                                 returns1.compareTo(s2);
                                          returnn;
                                   }
                                }
                                ......
                                   List<String>list = new ArrayList<String>();
                                   list.add("abd");
                                   list.add("cd");
                                   list.add("f");
                                   list.add("yyyy");
                                   list.add("abd");
                                   //打印原集合
                                   sop(list);
                                   sop("--------------排序-------------------");
                                   //随机排序：
                                   Collections.shuffle(list);
                                   sop("随机排序：" + list);
                                   //对元素排序，存入的对象必须具备比较性
                                   Collections.sort(list);
                                   //打印新集合
                                   sop("自然排序后的集合元素：" + list);
                                   //按指定比较器顺序排序
                                   Collections.sort(list,newStrLenCom());
                                   sop("长度排序：" + list);
                                   sop("------------获取最大元素-----------------");
                                   //获取最大元素
                                   Stringmax = Collections.max(list);
                                   sop("max= " + max);
                                   sop("--------------查找--------------------");
                                   intindex = Collections.binarySearch(list,"acd");
                                   sop("二分法查找值:" + index);
                                   intex = half(list,"acd");
                                   sop("二分法查找值:" + ex);
                                   Collections.sort(list,newStrLenCom());
                                   sop("排序后的集合元素：" + list);
                                   intx = half2(list,"acd",new StrLenCom());
                                   sop("二分法查找值:" + x);
                                   sop("---------------替换-反转----------------");
                                   //反转
                                   Collections.reverse(list);
                                   sop("反转后：" + list);
                                   //替换
                                   Collections.fill(list,"pp");
                                   sop("替换后:" + list);

Arrays工具类：

1、Lsit<T> asList(T... a)   --->    将数组转换为集合

 

注意：将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的，如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

 

a.如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素

 

b.如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在

 

2、binarySearch()：查找方法，fill()：替换方法，sort()：排序方法等

 

特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作

 

如：sort(T[]a,Comparator<? super T> c)

 

       fill(int[]a,int from,int to)等

 

3、String toString() 可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式

 

4、集合转为数组

 

      voidtoString(String[] s)  --->  将集合转为指定数组s，并可通过Arrays.toString(s)获取数组s中的元素

 

1）指定类型的数组定义的长度：

 

a.当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size

 

b.当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组，并且多出的元素的值为null

 

2）为何将集合转为数组：为了限定对集合中元素的操作，如增删，因为想对创建的集合不做增删方面的操作。

 

 

示例：

                            

                                publicstatic void sop(Object obj)
                                {
                                   System.out.println(obj);
                                }
                                ......
                                int[]arr = {5,8,6};
                                sop("toString: int[]转为集合：" +Arrays.toString(arr));
                               
                                String[]sarr = {"ac","eg","nse","gui"};
                                List<String>list = Arrays.asList(sarr);
                                sop("asList--String对象数组转集合：" + list);
 
                                List<int[]>li = Arrays.asList(arr);
                                sop("asList--int[]转集合:" + li);
                                Integer[]iarr = {5,8,6};
                                List<Integer>lis = Arrays.asList(iarr);
                                sop("asList--Integer[]转集合:" + lis);

                            

集合转数组：

       

                                   ArrayList<String>as = new ArrayList<String>();
                                   as.add("01");
                                   as.add("02");
                                   as.add("03");
                                   sop("原集合" + as);
                                   String[]s = new String[as.size()];
                                   as.toArray(s);
                                   sop("新数组" +Arrays.toString(s));