黑马程序员系列第五篇 集合（2）

 

（前言：本篇文章主要依据毕向东老师的课程视频整理而成，如要详细学习，请观看毕老师视频  百度网盘链接地址：http://pan.baidu.com/s/1o6mwDzO）

 

目录：  1、泛型      2、Map（HashMap、TreeMap）

 

1、泛型

  JDK1.5以后出现的新特性，用于解决安全问题，是一个安全机制；集合类中都有用到泛型。

  好处：将运行时期出现的问题转移到了编译时期，便于程序安全；避免了强制转换的麻烦。

  什么时候定义泛型类：当类中要操作的引用数据类型不确定时。早期用Object完成扩展，现在用泛型。

  局限性：定义的泛型在整个类中有效，如果泛型类中泛型类型确定，则这个对象的所有用到泛型的方法只能使用这个具体类型。

  解决局限性的办法：在某些方法中定义方法泛型

  注意：静态方法可以定义泛型，但不可以引用泛型类定义的泛型。

  泛型限定的书写格式 ：上限-<? Extends 类名>    下限-<? Super 类名>（？为通配符，也可理解为占位符）

 

一个例子简单演示  泛型接口、泛型类、普通泛型方法、静态泛型方法

public class GenericClass {

    public static void main(String[] args) throws ClassNotFoundException {
        
      Utils<String> util=new Utils<String>();
      GenericClass obj=new GenericClass();

      util.getClassName("abc");
      util.getClassLoader(obj);
      Utils.getClassPack(obj);
    }
}
//泛型接口
interface Util<T>{
    public void getClassName(T a);
}
//泛型类
class Utils<T> implements Util<T>{
    //泛型类中使用普通方法
    public void getClassName(T cla){
        System.out.println(cla+"的类名为"+cla.getClass().getName());
    }        
    //普通泛型方法
    public <G> void getClassLoader(G cla){
        System.out.println(cla.getClass().getName()+"的加载器："+
                           cla.getClass().getClassLoader().getClass().getName());
    }
    //静态泛型方法
    public static <T> void getClassPack(T cla){
        System.out.println(cla.getClass().getName()+"所在的包："+
                           cla.getClass().getPackage().getClass().getName());
    }
}

 

2、Map（HashMap、TreeMap）

是一种双列集合

 

什么时候使用map集合：当数据间存在映射关系时

 

HashTable  底层是hash表数据结构，不可存入null键null值，线程同步，jdk1.0（少用，可被HashMap替代，仅了解）

 

HashMap    底层是哈希表数据结构，可存入null键null值，线程不同步 效率高，jdk1.2

 

TreeMap     底层是二叉树数据结构，线程不同步，可以用于给map中的键进行排序

 

和Set的关系   Set集合底层使用的就是Map集合

 

方法归纳   

1、添加 put（K key,V value）、 putAll(Map<? Extends K,? extends V> m)

 

2、删除  clear() 、  remove(Object key)

 

3、判断 containsValue(Object value)、 containsKey(Object key) 、 isEmpty()

 

4、获取  get(Object key) 、 size()  、values() 、  entrySet()  、keySet()

 

 

用两种方式取出Map集合中的对象的代码示例：

public class MapDemo {
    /**
     * 目的：用两种方式取出Map集合中的对象，并打印。这两种方式方别封装到了两个函数中
     */
    public static void main(String[] args) {
        //创建集合，存入对象
        //Map<Employee,Integer> map=new HashMap<Employee,Integer>();
        Map<Employee,Integer> map=new TreeMap<Employee,Integer>(new nameComp());
          map.put(new Employee("00123","linda"),10000 );
          map.put(new Employee("00124","jack"),8000 );
          map.put(new Employee("00153","tom"),12000 );
          map.put(new Employee("00153","tom"),15000 );
          map.put(new Employee("00127","hary"),8000 );
          
        //调用函数       
        //getKeySet(map);
        getEntrySet(map);
    }
    //通过keySet方法获取hashMap中所有值的方法。取出Map集合元素方法，转换成Set集合，再用迭代器取出
    public static <K,V> void getKeySet(Map<K,V> map){
        
        Set<K> keySet = map.keySet();
        Iterator<K> it = keySet.iterator();
        while (it.hasNext()) {
            K key = it.next();
            V value = map.get(key);
            System.out.println("key:" + key + ";value:" + value);
        }
    }
    //通过entrySet方法获取hashMap中所有值的方法。取出Map集合元素方法，转换成Set集合，再用迭代器取出
    public static <K,V> void getEntrySet(Map<K,V> map){
        
        Set<Map.Entry<K, V>> entrySet=map.entrySet();
        Iterator<Map.Entry<K, V>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<K, V> keyValue =  it.next();
            System.out.println("key:" +keyValue.getKey() + ";value:" +keyValue.getValue());
        }
    }
}
class Employee implements Comparable<Employee>{
    private String no;
    private String name;
    
    public Employee(String no,String name){
        this.name=name;
        this.no=no;
    }

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //重写toString方法，方便打印结果
    public String toString(){
        return no+"-"+name;
    }
    @Override
    public int compareTo(Employee emp) {
        return this.no.compareTo(emp.no);
    }
//重写hashCode和equals方法，判断存入对象是否有重复
    @Override
    public int hashCode() {
        return this.no.hashCode()+this.name.hashCode()*39;
    }
    @Override
    public boolean equals(Object obj) {
        Employee emp=(Employee)obj;
        if(!(obj instanceof Employee)){
            throw new ClassCastException("错误对象！！！");
        }
        return this.name.equals(emp.name)&&this.no.equals(emp.no);
    }    
}
//自定义比较器
class nameComp implements Comparator<Employee>{
    @Override
    public int compare(Employee o1, Employee o2) {
        int num=o1.compareTo(o2);
        if(num==0)
            num=o1.getName().compareTo(o2.getName());
        return num;
    }
    
}

统计给定字符串的各个字母个数代码示例

//统计给定字符串的各个字母个数，将统计方法封装在findLetter函数中
public class TreeMapDemo {

    public static void main(String[] args) {
        
         findLetter("aabbcvddewgf44###ds");
    }
    //统计字母的函数，并打印统计结果
    public static void findLetter(String str){
    //新建TreeMap集合
      Map<Character,Integer> letters=new TreeMap<Character,Integer>();
        
        char[] chars=str.toCharArray(); 
        int len=chars.length;
        for(int i=0;i<len;i++){
            if(!(chars[i]>='a'&&chars[i]<='z'||chars[i]>='A'&&chars[i]<='Z'))
                 continue;
            
            int count=1;          
            if(letters.containsKey(chars[i]))               
             count=letters.get(chars[i])+1;
            
             letters.put(chars[i], count);
 
        }
       //输出格式
        StringBuffer sb=new StringBuffer();
        Set<Map.Entry<Character, Integer>> set=letters.entrySet();
        Iterator<Entry<Character, Integer>> ite=set.iterator();
        
        while(ite.hasNext()){
            Map.Entry<Character, Integer> entry=ite.next();
            char key=entry.getKey();
            int value=entry.getValue();
            sb.append(key+"("+value+") ");
        }
        System.out.println(str+"\n"+sb);
    }
}

 

 

 

 

       初学者难免错误，欢迎评判指教，持续更正ing...........