------- 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还可以使用 高级for循环来进行遍历（考点）
{
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;
}
}
还有一种取出值的方式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);
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)//上面写了泛型，这里就不用写成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。