黑马程序员_集合的(泛型与双列集合)

------- android培训、java培训、期待与您交流！----------
泛型
为什么要用泛型
泛型的使用：
将运行时异常提前到编译期
提高了安全性
省去了类型强制转换的麻烦
泛型的举例(代码实现)




[java] view plaincopy
package cn.itcast2;  
  
import java.util.ArrayList;  
import java.util.Iterator;  
  
public class Demo {  
  
    public static void main(String[] args) {  
        //创建集合对像,并在<>中添加泛型,确定数据类型是String  
        ArrayList<String> list = new ArrayList<String>();  
          
        list.add("唐嫣");  
        list.add("柳岩");  
  
        Iterator<String> iterator = list.iterator();  
          
        while (iterator.hasNext()) {  
            String string = iterator.next();  
            System.out.println(string);  
        }  
          
        for (String string : list) {  
            System.out.println(string);  
        }  
    }  
  
}  


 Object可以代表任意的数据类型。
  * 但是如果使用Object代表任意的数据类型，需要程序员提前预知数据类型，这个是很难实现的。


 * 所以可以使用泛型来指定数据类型。


 * 菱形泛型：对象本身可以不明确泛型，使用<>方式，此时，直接使用的就是引用的泛型。


泛型的应用:   


泛型类：


 * 在定义类的时候，定义泛型


 * 这个泛型类型就是一个数据类型，可以随意使用。


 * 在创建对象时，为这个形参的泛型赋值一个真正的数据类型。


 * 基本数据类型不可以作为泛型定义


 * 泛型的命名：只要符合标识符规则集合。通常使用T，E


 * 当需要使用多个不确定的类型时，这些不确定的类型都可以在泛型定义时用，分隔定义。


泛型方法:


在方法上定义泛型,在方法中使用泛型,与类无关.


代码实现:




[java] view plaincopy
package cn.itcast2;  
/* 
 * 泛型方法： 
 *      在方法上定义泛型，方法内使用泛型，与类无关。 
 */  
public class Demo6<T> {  
  
    public static void main(String[] args) {  
  
        Demo6<String> demo6 = new Demo6<String>();  
        demo6.method("我是泛型类中指定的类型");  
        Integer i = 100;  
        demo6.method2(i);  
    }  
  
    public void method(T t) {  
        System.out.println(t);  
    }  
      
    public <E> void method2(E e) {  
          
        E e2 = e;  
        System.out.println(e2);  
    }  
}  
 泛型接口
 *  泛型接口的定义：直接在接口上加泛型


 * 泛型接口的使用：


 * 在定义类时，需要实现该接口时，直接指定泛型，创建对象时，无需再指定泛型


 * 在定义类时，需要实现该接口时，不直接指定泛型，创建对象时，再指定泛型类型


代码实现(准备两个类用来实现两种情况)


准备一:




[java] view plaincopy
package cn.itcast2;  
  
public class MyClass implements MyInterface<String> {  
  
    @Override  
    public void method(String t) {  
  
        System.out.println(t);  
    }  
}  


准备二:


[java] view plaincopy
package cn.itcast2;  
  
public class MyClass2<T> implements MyInterface<T> {  
  
    @Override  
    public void method(T t) {  
        System.out.println(t);  
    }  
      
}  
泛型接口的代码实现:


[java] view plaincopy
package cn.itcast2;  
  
public class Demo7 {  
  
    public static void main(String[] args) {  
          
        MyClass mc = new MyClass();  
        mc.method("我是在定义类的时候，已经给接口的泛型指定了数据类型");  
        System.out.println("这种在定义类时已经指定了泛型的类，在创建对象时，无需再指定类型");  
          
        MyClass2<Integer>  mc2 = new MyClass2<Integer>();  
        mc2.method(100);  
        System.out.println("这种在定义类时没有指定泛型的类，在创建对象时，需再指定类型");  
          
    }  
}  


Map双列集合:
Map集合


(1)Map集合存储的是键值对元素。键是唯一的,值可以重复。


(2)Map和Collection的区别


A:Map是双列集合，存储的元素键值对，键唯一，值可以重复。


B:Collection是单列集合，存储的元素是单一的，List集合可以重复，Set集合元素唯一。


(3)Map集合的功能


A:添加功能


V put(K key,V value)


B:删除功能 


remove(K key)


C:判断功能


containsKey(K key)


containsValue(V value)


D:获取功能


V get(K key)


Set<K> keySet()


Collection<V> values()


Set<Map.Entry<K,V>> entrySet()


Map.Entry：


getKey


getValue


E:长度功能


int size()


(4)Map集合的数据结构问题：


Map集合的数据结构对键有效，跟值无关。






它的底层数据结构和Set中讲解的一致。


如果是哈希表结构，就需要重写hashCode()和equals()。


如果是二叉树结构，就有两种方式：Comparable,Comparator


(5)Map的遍历方式
假设有一个HashMap集合，存储的键和值都是String类型。名称叫hm。






A:根据键找值


a:获取所有键的集合


b:遍历键的集合，获取到每一个键


c:根据键找值


代码实现


Set<String> set = hm.keySet();


for(String key : set) {


String value = hm.get(key);


System.out.println(key+"---"+value);


}






B:根据键值对对象找键和值(理解)


a:获取所有键值对对象的集合


b:遍历键值对对象的集合，获取到每一个键值对对象


c:根据键值对对象获取键和值






代码体现：






Set<Map.Entry<String,String>> set = hm.entrySet();


for(Map.Entry<String,String> me : set) {


String key  = me.getKey();


String value = me.getValue();


System.out.println(key+"---"+value);


}


Map的集合体系


)Map集合的体系


Map


|--HashMap


|--LinkedHashMap


|--Hashtable(不常使用)


|--TreeMap


Map嵌套Map(代码实现):




[java] view plaincopy
package cn.itcast2;  
  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.Map;  
import java.util.Set;  
/* 
 * Map嵌套Map 
 */  
public class Test2 {  
  
    public static void main(String[] args) {  
  
        //创建集合对象  Map学校   第一个泛型是：学校名称（String）    第二个泛型：学校的班级(Map)      
        //班级Map：第一个泛型：班级名称(String)   第二个泛型：班级个数(Integer)  
          
        //创建学校集合  
        Map<String, Map<String,Integer>> school = new HashMap<String, Map<String,Integer>>();  
          
        //为北京大学准备班级(为school这个集合准备元素对象)  
        String name = "北京大学";  
        Map<String, Integer> class1 = new HashMap<String, Integer>();  
            //为第一个班添加内容  
        class1.put("文学", 5);  
        class1.put("地理", 4);  
        class1.put("传媒", 4);  
        class1.put("计算机", 4);  
          
        //为黑龙江大学准备班级(为school这个集合准备另外的元素对象)  
        String name2 = "黑龙江大学";  
        Map<String, Integer> class2 = new HashMap<String, Integer>();  
            //为第一个班添加内容  
        class2.put("文学", 2);  
        class2.put("地理", 3);  
        class2.put("传媒", 2);  
        class2.put("计算机", 10);  
          
        school.put(name, class1);  
        school.put(name2, class2);  
          
        System.out.println(school);  
          
        //遍历  
        //获取学校的所有元素对象  
        //返回所有学校名称的set集合      (key的set集合)  
        Set<String> keySet = school.keySet();  
          
        Iterator<String> iterator = keySet.iterator();  
          
        while (iterator.hasNext()) {  
            //依次拿到每一个学校的key  
            String outKey = (String) iterator.next();  
            System.out.println(outKey);  
            //根据学校的key找到学校对应的值  
            Map<String, Integer> outMap = school.get(outKey);  
              
            //获取每一个学校的key的Set集合  
            Set<String> innerKeySet = outMap.keySet();  
              
            Iterator<String> iterator2 = innerKeySet.iterator();  
              
            while (iterator2.hasNext()) {  
                //依次找到每一个内部Map的key  
                String innerKey = iterator2.next();  
                //再根据每一个内部Map的Key找到内部Map的value  
                Integer innerValue = outMap.get(innerKey);  
                //打印集合内容  
                System.out.println("\t"+innerKey+":"+innerValue);  
            }  
        }  
    }  
  
}  








 


































































































版权声明：本文为博主原创文章，未经博主允许不得转载。