java系列：集合框架(二)

Map集合：

Map接口定义的集合又称为查找表，用于存储所谓“Key-Value”键值对，Key可以看成Value的索引；

根据内部结构的不同，Map接口有多种实现类，其中常用的有内部为hash表实现的HashMap和内部为排序二叉树实现的TreeMap。同样这样的数据结构在存放数据时，也不建议存放两种以上的数据类型，所以，通常我们在使用Map时也要使用泛型约束存储内容的类型

Map主要实现类：

HashMap：

1. 它是 一个散列表，存储的内容是键值对映射；
2. HashMap基于hash原理，我们通过put()和get()方法存储和获取数据；
3. 键不可以重复，如果重复会覆盖原来的映射(value);
4. 键可以为null，值也可以为null，值可以多个为空，键只能有一个为空；

TreeMap：

1. TreeMap是一个二叉树的数据结构，不允许出现相同的键；
2. 键不可以为null，值可以为null；
3. 它会对键自然排序；

Hashtable：

1. 线程安全，他的键值都不可以为null；
2. 建议使用concurrentHashMap；

LinkedHashMap：

1. 它是HashMap的子类；
2. HashMap和双向链表合二为一就是LinkedHashMap；
3. 保持插入顺序，访问顺序； 

Map接口中常见的方法

返回值	方法	解释
V	get(Object Key)	返回指定键所映射的值，如果此映射不包含该键的映射关系，则返回null
V	put(key,value)	将指定的值与此映射中的指定键关联
void	putAll(Map<K,V> m)	从指定映射中将所有映射关系复制到此映射中
int	size()	返回此映射中的键-值映射关系数
boolean	isEmpty()	如果此映射中未包含键值对则返回true
Set<Map, Entry<K,V>>	entrySet	返回此映射中包含映射关系的Set视图
Set<K>	keySet()	返回此映射中包含的键的Set视图
V	remove(Object key)	如果存在一个键的映射关系，则将其从此映射的删除
void	clear()	从此映射中移除所有映射关系

public class Demo {
    public static void main(String[] args) {
        HashMap<Integer,Student> hashMap=new HashMap();
        hashMap.put(101,new Student(101,"张三"));
        hashMap.put(102,new Student(102,"李四"));
        hashMap.put(103,new Student(103,"王五"));
        //HashMap键不可以重复，如果重复会覆盖掉原来映射
        //HashMap键可以为null，值也可以为null,值可以多个为null,键只能一个为null
        hashMap.put(null,null);
        hashMap.put(103,null);
        //clone 浅拷贝
        HashMap<Integer,Student> clone =(HashMap<Integer,Student>)hashMap.clone();
        clone.get(101).setName("赵六");
        System.out.println(clone);
        System.out.println(hashMap);
        //遍历的三种方式
        Set<Map.Entry<Integer, Student>> entries = hashMap.entrySet();
        Iterator<Map.Entry<Integer, Student>> iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, Student> next = iterator.next();
            System.out.println("key:"+next.getKey()+"value:"+ next.getValue());
        }
        //第二种 建议使用第二种
        Iterator<Integer> iterator1 = hashMap.keySet().iterator();
        while(iterator1.hasNext()){
            Integer key = iterator1.next();
            Student student = hashMap.get(key);
            System.out.println("key:"+key+" value:"+ student);
        }
        //第三种
        Collection<Student> values = hashMap.values();
        Iterator<Student> iterator2 = values.iterator();
        while(iterator2.hasNext()){
            System.out.println(iterator2.next());
        }
    }
}

泛型：

泛型是JDK1.5引入的新特性，泛型的本质是参数化类型，在类、接口、方法的定义过程中，所操作的数据类型为传入的指定参数类型，所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型，同时，编译器会以此进行检查

• 自定义泛型，泛型<>的内容可以任意，通常用E、T表示；
• 泛型只支持引用数据类型，不支持基本数据类型，可以使用对应的包装类；
• 迭代器也支持泛型，但是迭代器使用的泛型应该和他所迭代的集合的泛型类型一致；
• 如果泛型不指定类型的话，默认为Object类型；

public class Demo{
    public void main(String[] args){
        List<Integer>  lists =  new ArrayList<Integer>();  
        //JDK1.8支持这种方式
        List<Integer>  list =  new ArrayList<>() ;                    
        Iterator<Integer>   iterator =  list.iterator();//迭代器支持泛型
        //List<int>  list = new ArrayList<>();  错误代码    
    }
}

自定义泛型：

Point<Integer> p1 = new Point<>(1,2,3);
point<Double,Long> p2 = new Point<Double,Long>(1.2,3L);

foreach循环：

foreach循环实在JDK1.5推出的，主要是增强了for循环，可以拥有数组和集合的遍历；

for循环：自己维护循环次数，循环体自行维护获取元素的方法；

int[] array = new int[]{1,2,3,4,5};
for(int i=0;i<array.length;i++){
    System.out.println(array[i]);
}

foreache循环：自动维护循环次数(由遍历的数组或集合的长度决定)，自动获取每次迭代的元素；

int[] array = new int[]{1,2,3,4,5};
for(int i:array){
    System.out.println(i);
}

foreach循环执行流程：遍历数组array中的每一个元素，将元素一次赋值给i后进入循环体，直到所有元素均被迭代完毕后退出循环；

注意事项：

使用foreach循环，i的类型应该与循环迭代的数组或集合中的元素类型一致，至少要是兼容的类型；

Collections工具类

Collections是java.util下的类，是针对集合的帮助类，提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作；

常用的方法：

1）copy()：从一个列表拷贝得到另一个列表中；

2）sort()：根据元素的自然顺序对指定列表进行升序排序；

3）shuffle()：使用默认随机源对指定列表进行排序，随机排序；

4）reverse()：反转指定列表中的元素顺序；

---

完！！！！