本节考点：
一、泛型限定，上限下限什么时候用
二、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)
- {
- System.out.println(d);
- }
-
- public static <D> void method(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)
- {
- Iterator<? extends Person> it = al.iterator();
-
- while(it.hasNext())
- System.out.println(it.next().getName());
- }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- }
-
- 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");
-
- public static void method(ArrayList<? extends Object> al) {
- al.add("abc");
-
- }
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"));
-
- sop(map);
- sop(map.remove("01"));
- sop(map.containsValue("s"));
- 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<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（）；
-
-
-
-
-
- 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");
-
-
-
-
-
-
-
- Set<String> keys = map.keySet();
- for (String key : keys){
- String value = map.get(key);
- System.out.println(key+" "+value);
- }
-
-
-
-
-
-
-
-
- for (Map.Entry<String, String> me : map.entrySet()) {
- System.out.println(me.getKey()+"--"+me.getValue());
- }
-
- 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);
- else
- map.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)
- {
- 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。
765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
