黑马程序员———集合(下)[包含Collections和Arrays类]

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

  Map集合：该集合存储键值对 。一对一对往里存。而且要保证键的唯一性。
      1.添加：
          put(K key,V value)
          putAll(Map<? extends K,? extends V> m)
     2.删除：
          clear();
          remove(Object key)
     3.判断：
          containsValue(Object value)
          containsKey(Object key)
          isEmpty()
     4.获取：
          get(Object key)//返回指定键所映射的值
          size()
          values()//返回此映射中包含的值的Collection视图。
         
           * Set<Map.Entry<K,Y>> entrySet()   //返回此映射中包含的键的Set视图。
          * Set<K> keySet()       //返回此映射中包含的键的Set视图。
         
         
Map
     |--Hashtable：底层是哈希表数据结构，不可以存入null键null值该集合，是线程同步的，JDK1.0，效率低
     |-- HashMap：底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的，JDK1.2，效率高。
     |-- TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序。

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



package cn.itcast.Collection2;

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

/*
Map取出集合的两种方式：
     1.keySet：将Map中所有的键存入到Set集合。因为Set具备迭代器。
                 所以可以用迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
         
          Set<K> keySet:取出原理： 将Map集合转成Set集合，在通过迭代器取出。
    
     2.Set<Map.Entry<K,Y>> entrySet： 将Map中的映射关系存入到Set集合中,而这个关系的数据类型是Map.Entry
          Map.Entry中有分别获取键和值得方法：getKey();getValue();
    
    
Map.Entry其实Entry是一个接口，它是Map接口中的一个内部接口。
interface Map
{
     public static interface Entry
     {
          public abstract Object getKey();
          public abstract Object getValue();
     }
}

为什么要把Entry定义成子接口，而不定义成接口呢？
     先有集合，才有映射关系，而这个映射关系是集合的 内部事物 。而Entry是直接访问Map的元素。
     public static interface Map.Entry<K,V> 能加static的接口只有内部接口。

*/
public class MapDemo2
{
     public static void main(String[] args)
     {
          Map<String,String> map = new HashMap<String,String>();
          map.put("01","zs1");
          map.put("02","zs2");
          map.put("03", "zs3");
         
           Set<String> keySet = map.keySet();
          for(Iterator<String> it = keySet.iterator();it.hasNext();)
          {
               String key = it.next();
               String value = map.get(key);
               System.out.println("key: "+key+", value: "+value);
          }
         
         
          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 key = me.getKey();
               String value = me.getValue();
               System.out.println(key+" = "+value);
          }
     }

}


其他的具体参考有关.java文件。

 

 

  Collections工具类

      Collections.sort:
               不用于Set集合，用于List集合。

      Collections.max:
               根据元素的自然顺序，返回给定collection的最大元素。集合中所有元素必须实现Comparable接口，且所有元素必须可相互比较。
    
      Collections.binarySearch :二分搜索法，集合必须是有序的。
              
               返回的是搜索键的索引，否则返回（-（插入点） - 1）。

      Collections.swap:
               在指定列表的指定位置处交换元素。（如果指定位置相同，则调用此方法不会更改列表。）
         
      Collections.shuffle:
               使用指定的随机源对指定列表进行置换。所有置换发生的可能性都是相等的，假定随机源是公平的。


      Collections.fill:
                        使用指定元素替换指定列表中的所有元素。
                           
     Collections.replaceAll:                        
                      使用另一个值替换列表中出现的所有某一指定值。
                        
                           
     Collections.reverse:                     
                  反转指定列表中元素的顺序。
        
     Collections.reverseOrder:
    *在无序的集合TreeSet中使用到比较器，这个方法可以反转比较器。
          public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)返回一个比较器，
         

很多集合都是高效的，但是是线程不不同的，导致不安全，则 使用以下方法可以让集合安全，在以下方法中同样封装了集合中相应的方法如add，romove等。

               synchronizedCollection(Collection<T> c)
                       
               synchronizedList(List<T> list)
                        
               synchronizedMap(Map<K,V> m)
                       
               synchronizedSet(Set<T> s)


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

**： 数组变集合。
static <T> List<T>     asList(T... a)
          返回一个受指定数组支持的固定大小的列表。
         
static int          binarySearch(byte[] a, byte key)
          使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
          也能传其他基本数据类型。
    
static byte[]   copyOf(byte[] original, int newLength)
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
         
static boolean[]   copyOfRange(boolean[] original, int from, int to)
          将指定数组的指定范围复制到一个新数组。     
         
static boolean   deepEquals(Object[] a1, Object[] a2)
          如果两个指定数组彼此是深层相等 的，则返回 true。
          不仅比较数组，还比较数组中的元素。
         
static boolean   equals(boolean[] a, boolean[] a2)
          如果两个指定的 boolean 型数组彼此相等，则返回 true。
         
static void   fill(boolean[] a, boolean val)
          将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
   
static int   hashCode(boolean[] a)
          基于指定数组的内容返回哈希码。
         
static void   sort(byte[] a)
          对指定的 byte 型数组按数字升序进行排序。        
    
static String   toString(boolean[] a)
          返回指定数组内容的字符串表示形式。                  
         
                             
                             
把数组变成集合有什么好处：（为什么要将数组变成集合？）
       可以使用集合的思想和方法来操作数组中的元素。
     注意：将数组变成集合，不可以使用集合中的增删方法，因为数组的长度是固定的，
     如果使用了增删，则会发生java.lang.UnsupportedOperationException
     contains     get      indexOf          subList   这些就可以使用。
    
    
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。（如下面示例）
                        
                        
集合变数组。
Collection接口中的toArray方法。
<T> T[]  toArray(T[] a)


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


Iterable<T>接口：
     抽离出iterator()方法，提高了集合框架的扩展性，还给集合框架提高了新的功能：
     "foreach"高级for循环。
    
高级for循环：
格式：for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
     {
          执行语句。
     }
    
对集合进行遍历：
     只能获取集合元素，但是不能对集合进行操作。
    
迭代器除了遍历，还可以进行remove集合中元素的动作。
     如果是用ListIterator，还可以在遍历过程对集合进行增删改查的动作。

传统for和高级ror有什么区别呢？
       高级for有一个局限性：必须有被遍历的目标。
     建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标。
    

JDK1.5版本出现的新特性。
       方法的可变参数： int... arr
               public static void show(int ... arr，int a)//error
               public static void show(int a,int ...arr)
                 在使用可变参数时，可变参数一定定义在参数列表的最后面。

main:

     {
          show(1);
          show(1,2,3,4,5,6,7,8,9);
     }
     public static void show(int a,int ... arr)
     {
          System.out.println(arr.length);
     }

静态导入：
     StaticImport  ：
             import static java.util.Arrays.*;
                       import要放最前面
    
当类名重名时，需要指定具体的包名。
当方法重名时，需要指定所属的对象或者类。

 

 

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