黑马程序员——Java语言基础——06.集合框架（2）泛型和Map集合

------- android培训、java培训、期待与您交流！ ----------

本节考点：

一、泛型限定，上限下限什么时候用

二、map和Collection的不同

三、Map两种遍历方式，用高级for循环写

2-1 泛型

2-1-1 泛型应用

(1)为什么会出现泛型？
因为集合存放的数据类型不固定，故往集合里面存放元素时，存在安全隐患，
如果在定义集合时，可以想定义数组一样指定数据类型，那么就可以解决该类安全问题。
JDK1.5后出现了泛型，用于解决集合框架的安全问题。
泛型是一个类型安全机制。
(2)泛型定义格式：通过<>来定义要操作的引用数据类型
ArrayList<String> al = new ArrayList<String>;
(3)泛型的好处：
将运行时期出现的ClassCastException(类型转换异常)问题转移到编译时期；
避免了强制转换的麻烦
(4)什么时候定义泛型？
泛型在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
(5)泛型的形式
泛型类：即自定义泛型类
A：当类中要操作的引用数据类型不确定时，早起定义Object来完成扩展，现在定义泛型来完成
B：局限性：泛型类定义的泛型，在整个类中有效，如果该泛型类的方法被调用，
  当泛型类的对象明确要操作的类型后，所有要操作的类型就被固定。
泛型方法：泛型放在返回值前面，修饰符的后面
A:为了避免泛型类的局限性，让不同方法可以操作不同的类型，而且类型还不确定，
 则可以将泛型定义在方法上
B:特殊之处：静态方法不可以反问类上定义的泛型
 如果静态方法操作的应用数据类型不确定，可以讲泛型定义在静态方法上

示例：

class Demo<D>//泛型类{public void print(D d)//泛型类方法{System.out.println(d);}public <D> void show(D d)//泛型方法，<D>应该写在public后面{System.out.println(d);}public static <D> void method(D d)//静态方法不能访问定义在类上的泛型，只能定义泛型方法，<D>要跟在静态修饰符后面{System.out.println(d);}}

泛型接口：
当泛型定义在接口上时，则子类中要指定实现接口类型，同时还可以子类也可以定义为泛型类

示例：

interface Demo<D>{public abstract void method(D d);}class DemoInterface<D> implements Demo<D>{public void method(D d){System.out.println(d);}}

2-1-2 泛型限定

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型限定：

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。 

class GenericHigherLimit{public static void main(String[] args) {ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("shabi01"));al.add(new Person("shabi02"));al.add(new Person("shabi03"));ArrayList<Student> al1 = new ArrayList<Student>();al1.add(new Student("xiaoxuesheng01"));al1.add(new Student("xiaoxuesheng02"));al1.add(new Student("xiaoxuesheng03"));al1.add(new Student("xiaoxuesheng04"));printAl(al);}public static void printAl(ArrayList<? extends Person> al)//此处不能直接写ArrayList<Person>因为ArrayList<Person> = ArrayList<Student>,Error{Iterator<? extends Person> it = al.iterator();while(it.hasNext())System.out.println(it.next().getName());//上面泛型改成<? super Student>后，不能调用getName方法}/*public static void printAl(ArrayList<? super Student> al){Iterator<? super Student> it = al.iterator();while(it.hasNext()){Person p = (Person)it.next();System.out.println(p.getName());}}<? super Student>的意思是可以传入Student及其父类，结果导致传入的是Object类需要对其类型强转后才能调用特有方法*/}class Person{private String name;Person(String name){this.name = name;}public String getName(){return name;}} class Student extends Person{private String name;Student(String name){super(name);}}

泛型的细节：

1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；

2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；

原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；

3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String> al = new ArrayList<Object>();  //错//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。ArrayList<? extends Object> al = new ArrayList<String>();al.add("aa");  //错//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？public static void method(ArrayList<? extends Object> al) {al.add("abc");  //错//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。}

2-2 Map集合

|--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

|--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|--TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

2-2-1 Map集合与Collection的不同

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

2-2-2 常用方法

1，添加。

 put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

void putAll(Map);

2，删除。

void clear()：清空

value remove(key) ：删除指定键。

3，判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value) ：是否包含value

4，取出。

int size()：返回长度

value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection values()：获取map集合中的所有的值。

示例：

class MapDemo{public static void main(String[] args){Map<String,String> map = new HashMap<String,String>();map.put("01","shabi");map.put("02","shab");map.put("03","sha");map.put("04","sh");map.put("05","s");sop(map.put("05","h"));//添加时如果添加相同的key，会覆盖原来的值，并返回被覆盖的值sop(map);sop(map.remove("01"));sop(map.containsValue("s"));//注意：map集合中只有containsKey和containsValue，没有contains方法sop(map.get("02"));sop(map.get("08"));Collection<String> str = map.values();sop(str);}public static void sop(Object obj){System.out.println(obj);}}

2-2-3 Map集合的两种遍历方式

1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物，而且该事物在直接访问Map集合中的元素。

示例：

class MapTest {public static void main(String[] args) {Map<Student,String> schoolClass = new TreeMap<Student,String>(new MyComparator());schoolClass.put(new Student("nishaibi01",19),"shanghai");schoolClass.put(new Student("woshaibi02",14),"fuyang");schoolClass.put(new Student("tashaibi04",9),"nanchang");schoolClass.put(new Student("hehshaibi05",109),"shanghai");//第一种取出方式/*Iterator<Student> it = schoolClass.keySet().iterator();while (it.hasNext()){Student s = it.next();String value = schoolClass.get(s);System.out.println(s.getName()+"  "+s.getAge()+"  "+value);}*///第二种取出方式Iterator<Map.Entry<Student,String>> it = schoolClass.entrySet().iterator();while (it.hasNext()){Map.Entry<Student,String> me = it.next();Student key = me.getKey();String value = me.getValue(); System.out.println(key.getName()+"  "+key.getAge()+"  "+value);}}}class MyComparator implements Comparator<Student>{public int compare(Student s1,Student s2){int num = s1.getName().compareTo(s2.getName());if(num == 0)return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));return num;}}

还可以使用高级for循环来进行遍历（考点）

还有一种取出值的方式values（）；

/** * 需求：遍历Map集合的三种方式 * @author user * */public class MapTest {public static void main(String[] args) {Map<String,String> map = new TreeMap<String,String>();map.put("01","shabi");map.put("02","shab");map.put("03","sha");map.put("04","sh");//第一种遍历：keySet/*Iterator<String> it = map.keySet().iterator();while(it.hasNext()){String s = it.next();System.out.println(s+"  "+map.get(s));}*/Set<String> keys = map.keySet();for (String key : keys){String value = map.get(key);System.out.println(key+" "+value);}//第二种：entrySet/*Set<Map.Entry<String, String>> set = map.entrySet();Iterator<Map.Entry<String,String>> it = set.iterator();while (it.hasNext()){Map.Entry<String, String> me = it.next();System.out.println(me.getKey()+"  "+me.getValue());}*/for (Map.Entry<String, String> me : map.entrySet()) {System.out.println(me.getKey()+"--"+me.getValue());}//第三种：values,只能得到所有的值Collection<String> col = map.values();for (String s : col) {System.out.println(s);}}}

练习：（重要：面试有类似的题目）
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
希望打印结果：a(1)c(2).....
通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。
注意了，当发现有映射关系时，可以选择map集合。
因为map集合中存放就是映射关系。
什么使用map集合呢？
当数据之间存在这映射关系时，就要先想map集合。
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
3，遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null，将该字母和1存入到map集合中。
如果返回不是null，说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。
代码如下：

import java.util.*;class MapTest{public static void main(String[] args) {TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();String s = "aaabcccdddee";char[] arr = s.toCharArray();for (int i=0; i<arr.length; i++){Integer value = map.get(arr[i]);if(value == null)map.put(arr[i],1);elsemap.put(arr[i],value+1);}StringBuffer sb = new StringBuffer();Iterator<Map.Entry<Character,Integer>> it = map.entrySet().iterator();while (it.hasNext()){Map.Entry<Character,Integer> me = it.next();Integer value = me.getValue();Character key = me.getKey();sb.append(key+"("+value+")");}sop(sb);}public static void sop(Object obj){System.out.println(obj);}}

练习：定义一个完整的学生类，可根据姓名、年龄排序

class Student implements Comparable<Student>//此处写泛型{private String name;private int age;Student(String name,int age){this.name = name;this.age = age;}public String getName(){return name;}public int getAge(){return age;}public int hashCode(){return this.name.hashCode()+age*3;}public int compareTo(Student s)//上面写了泛型，这里就不用写成Object，也不用强转了{int num = this.name.compareTo(s.name);if (num == 0){return new Integer(this.age).compareTo(new Integer(s.age));}return num;}public boolean equals(Object obj){if(!(obj instanceof Student))throw new ClassCastException("传入类型不匹配");Student s = (Student)obj;return this.name.equals(s.name) && this.age == s.age;}}

2-2-4 使用集合技巧

看到Array就是数组结构，有角标，查询速度很快。

看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；

看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。

看到tree就是二叉树，就要想到排序，就想要用到比较。

比较的两种方式：

一个是Comparable：覆盖compareTo方法；

一个是Comparator：覆盖compare方法。

LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

集合什么时候用？

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

保证唯一，就用Set。不保证唯一，就用List。

------- android培训、java培训、期待与您交流！ ----------