本节考点:
一、泛型限定,上限下限什么时候用
二、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。