黑马程序员——java学习9（毕15-16）——TreeSet、Map、泛型、字符排序

1、TreeSet

package learn;
/*
 * |--TreeSet
 *             可以对Set集合排序
 *             底层数据结构是二叉树
 *             保证数据唯一性的依据：compareTo方法return 0；原序return 1；
 * 
 *         TreeSet排序的第一种方式：让元素子集具备比较性。元素需要实现compareTo接口，覆盖compareTo方法
 *         也称为元素的自然顺序，默认顺序
 *        
 *        TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的
 *                            这是就需要让集合自身具备比较性
 *                            在集合初始化时就有了比较方式 
 * 
 * 
 * 需求：往TreeSet集合中存储自定义对象学生
 * 想按照学生的年龄进行排序
 * 
 * 排序时，主要条件一致，一定要判断次要条件！
 * */
import java.util.Iterator;
import java.util.TreeSet;

import learn.Student;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet();
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi08",19));
//        ts.add(new Student("lisi01",40));

        
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            Student stu=(Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

class Student implements Comparable//该接口强制让学生具备比较性
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s =(Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

1.2、TreeSet的比较器

package learn2;
/*
 * 当元素自身不具备比较性，或者具备的比较性不是所需要的
 * 这时需要让容器自身具备比较性
 * 定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数
 * 当两种排序都存在时，以比较器为主
 B">  8  * 定义了一个类，实现Comparator接口，覆盖compare方法
 * */
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Student implements Comparable//该接口强制让学生具备比较性
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s =(Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
public class TreeSetDemo2 {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet(new MyCompare());
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",19));
//        ts.add(new Student("lisi01",40));

        
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            Student stu=(Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

class MyCompare implements Comparator
{
    public int  compare(Object o1,Object o2)
    {
        Student s1=(Student)o1;
        Student s2=(Student)o2;
        
        int num=s1.getName().compareTo(s2.getName());
        if(num==0)
        {
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;
                */
        }
        return num;
        
    }
}

1.3、TreeSet练习

package Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/*
 * 练习，按照字符串长度排序
 * 字符串本身具备比较性，但是比较方式不是所需要的
 * */
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet(new StrLengthComparator());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");
        
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class StrLengthComparator implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        String s1=(String)o1;
        String s2=(String)o2;
//        if(s1.length()>s2.length())
//            return 1;
//        if(s1.length()==s2.length())
//            return 0;
        int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num==0)
            return s1.compareTo(s2);
        return num;
    }
}

1.4、泛型限定

(1)JDK1.5版本之后出现的新特性，用于解决安全问题，是一个类型安全机制。

作用是希望在定义集合时，标识你要传入的对象的类型，不是这个类型的不让传入。

泛型是给编译器看的，即在编译时不加入泛型指定的类型的元素会发生异常。

但ArrayList<Integer>和ArrayList<String>的对象的字节码形式一样，说明泛型被转换成字节码之后就消失了，

所以可以用反射取得add方法，在ArrayList<Integer>对象中添加String类型的元素，不会发生异常。

(2)没有使用泛型时，不管是什么类型的对象都可以存储进同一个集合中。使用泛型后，可以将一个集合中的元素规定为一个类型，

这个集合中只能存储一种类型的对象，更加安全，并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，

不需要对对象进行强制类型转换，更加方便。泛型就是把原来的类名进行了延长。

而如果将各种不同类型的数据装到一个集合中，编译器会报告unchecked警告。

(3)   格式：

 通过<>来定义要操作的引用数据类型

如：ArrayList<String>//这个集合中只能存入String类型的元素

好处 

(1)   将运行时期出现的问题ClassCastException转移到了编译时期，方便于程序员解决诶问题，让运行时期问题减少，安全

(2)   避免强制转换的麻烦

package learn4;
/*
 * 泛型限定
 * ? 通配符，也可以理解为占位符
 * ? extends E：可以接受E类型或者E的子类型，上限
 * ? super E：可以接收E类型或者E的父类型，下限
 * */
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo6 {
    public static void main(String[] args) {
        /*
        ArrayList<String> al = new ArrayList<String>();
        
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        
        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(4);
        al1.add(7);
        al1.add(1);
        printColl(al);
        printColl(al1);
         */
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
    
        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("abc---1"));
        al1.add(new Student("abc---2"));
        al1.add(new Student("abc---3"));
        printColl(al1);//ArrayList<Person> al = new ArrayList<Student>();
        
        
        
        
    }
    //泛型限定
    public static void printColl(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
    /*
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    */
    
}

class Person
{
    private String name;
    Person(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

//class Student implements Comparable<Person>
//{
//    public int compareTo(Person s)
//    {
//        this.getName();
//    } 
//}

//class Comp implements Comparator<Student>
//{
//    public int  compare(Student s1,Student s2)
//    {
//        Person s1 = new Student("abc1");
//        return s1.getName().compareTo(s2.getName());
//    }
//}
//
//TreeSet<Student> ts = new TreeSet<Student>();
//ts.add(new Student("abc1"));
//ts.add(new Student("abc2"));
//ts.add(new Student("abc3"));

1.4.2、泛型限定2

用于泛型扩展

package learn5;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;



class Person
{
    private String name;
    Person(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}

class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}

public class GenericDemo7 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("abc03"));
        ts.add(new Student("abc02"));
        ts.add(new Student("abc06"));
        ts.add(new Student("abc01"));
        
        Iterator<Student> it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
        ts1.add(new Worker("wabc03"));
        ts1.add(new Worker("wabc02"));
        ts1.add(new Worker("wabc06"));
        ts1.add(new Worker("wabc01"));
        Iterator<Worker> it1 = ts1.iterator();
        while(it1.hasNext())
        {
            System.out.println(it1.next().getName());
        }
        
        
        
    }
}
/*
class StuComp implements Comparator<Student>
{
    public int compare(Student s1,Student s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}

class WorkerComp implements Comparator<Worker>
{
    public int compare(Worker s1,Worker s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}
*/

class Comp implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}

2、Map

package learn5;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/*
 * Map集合，双列集合，该集合存储键值对，一对一对往里存，而且要保证键的唯一性
 *1、添加
 *    put(Key k,Value v);
 *    putAll(Map<? extends K, ?extends V>m)
 *
 *2、删除
 *    clear()
 *
 *3、判断
 *    containsValue(Object value);
 *    containsKey(Object key);
 *    isEmpty();
 *
 *4、获取 
 *    get(Object key);
 *    size()
 *    value()
 *    entrySet();
 *    keySet();
 *
 *Map
 *    |--Hashtable: 底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步 JDK1.0
 *    |--HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的 JDK1.2 效率高
 *    |--TreeMap：底层是二叉树结构，线程不同步，可以用于给Map集合中的键排序。
 *    Set底层调用的就是map
 * */
public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        //添加元素,如果出现添加是相同的键，后添加的值会覆盖原有的键对应的值，并返回被覆盖的值
        System.out.println("put: "+map.put("01","zhangsan1"));
        System.out.println("put: "+map.put("01", "lsii2"));
        
        map.put("02", "zhangsan2");
        map.put("03", "zhangsan3");
        System.out.println("contansKey: "+map.containsKey("022"));
//        System.out.println("remove: "+map.remove("02"));
        System.out.println("get: "+map.get("02"));
        System.out.println(map);
        //null可以作为键存在
        map.put("04", null);
        System.out.println("get: "+map.get("04"));
        //可以通过get方法返回值来判断一个键是否存在,通过返回null来判断
        //获取map集合中所有的值
        Collection<String> coll = map.values();
        System.out.println(coll);
        System.out.println(map);
        
    }
    
}

2.1、Map集合的两种取出方式

package learn5;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 * Map集合的两种取出方式
 * 1.Set<key> keySet:将map中所有的键存入到Set集合，因为Set具备迭代器
 *     所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值
 *     map集合取出原理：将map集合转成Set集合，再通过迭代器输出
 * 2、Set<Map.Entry<k,v>>entrySet: 将map集合中的映射关系存到了set集合中，这个关系的类型:Map.Entry
 * 
 * Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口
 * interface Map
 * {
 *         public static interface Map.Entry
 *         {
 *             public abstract Object getKey();    
 *             public abstract Object getValue();
 *         }
 * }
 * class HashMap implements Map
 * .Entry
 * {
 *         class haha implements Map.Entry
 *         {
 *             public  Object getKey(){}    
 *             public  Object getValue(){}    
 *         }
 * }
 * */
public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("01","zhangsan1");
        map.put("04","zhangsan4");
        //将Map集合中的映射关系取出，存入到Set集合中
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<String, String> me=it.next();
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"");
        }
        
        
        
//        //先获取map集合中所有键的Set集合，keySet();
//        Set<String> keySet = map.keySet();
//        //有了Set集合就可以获取迭代器
//        Iterator<String> it = keySet.iterator();
//        while(it.hasNext())
//        {
//            String key=it.next();
//            //有了键可以通过map集合的get方法获取其对应的值
//            String value = map.get(key);
//            System.out.println("key: "+key);
//        }
    }
}

2.2、TreeMap

package Test2;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;



/*
 * 需求：对学生对象的年龄进行升序排序
 * 因为数据是以键值对形式存在的
 * 所以要使用可以排序的Map集合，TreeMap。
 * */
class StuNameComparator 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;
    }
}
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int compareTo(Student s)
    {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
    public int hashCode()
    {
        return name.hashCode()+age*34;
    }
    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;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()
    {
        return name+":"+age;
    }
}
public class MapTest2 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
        tm.put(new Student("blisi3",23),"Nanjing");
        tm.put(new Student("lisi1",21),"Beijing");
        tm.put(new Student("alisi4",24),"Wuhan");
        tm.put(new Student("lisi1",21),"tianjin");
        tm.put(new Student("lisi2",22),"Shanghai");        
    
        Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
        Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<Student,String> me = it.next();
            Student stu = me.getKey();
            String addr = me.getValue();
            System.out.println(stu+"..."+addr);
        }
    }
}

2.3、字符排序

package Test2;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*练习
 * "sdfgzxcvasdfxvdf"获取该字符串中字母出现的次数
 * 希望打印结果a(1)c(2)；
 * 
 * 通过结果发现，每一个字母都有对应的次数
 * 说明字母和次数之间都有映射关系
 * 注意，当发现有映射关系时，可以选择map集合
 * 因为map集合中存放的就是映射关系
 * 
 * 何时使用mao集合？
 * 当数据之间存在着映射关系时，就可以使用map集合
 * 
 * 思路：
 * 1、字符串转换成字符数组，因为要对每一个字符进行操作
 * 2、定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合
 * 3、遍历字符数组
 *         将每一个字母作为键去查map集合
 *         如果返回null,将该字母和1存入到map集合中
 *         如果返回不是null,说明该字母在mao集合中已经存在，并有对应的次数，
 *         那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原有键所对应的值，
 * 4、将map集合中的数据变成指定的字符串形式返回。
 * */
public class MapTest3 {
    public static void main(String[] args)
    {
        String s = charCount("aabcdabcdefa");
        System.out.println(s);
    }
    public static String charCount(String str)
    {
        char[] chs=str.toCharArray();
        //字母作为键，次数作为值，泛型里接收的都是引用数据类型，转换成基本包装类
        //排序依赖Character 实现了Comparable,所以默认了字符排序
        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        int count=0;
        for(int x=0; x<chs.length;x++)
        {
            
            if(!(chs[x]>='a'&&chs[x]<='z'||chs[x]>='A'&&chs[x]<='Z'))
                continue;
            //字母作为键找集合
            Integer value = tm.get(chs[x]);
            if(value!=null)        
                count=value;
            count++;
            tm.put(chs[x], count);
            count=0;
//            if(value==null)
//            {
//                tm.put(chs[x], 1);
//            }
//            else
//            {
//                value = value + 1;
//                tm.put(chs[x], value);
//            }
        }
//        System.out.println(tm);
        //缓冲区存
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<Character,Integer>>entrySet = tm.entrySet();
        Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<Character,Integer> me = it.next();
            Character ch = me.getKey();
            Integer value=me.getValue();
            sb.append(ch+"("+value+")");
            
            
        }
        //返回值为String类型，sb是builder
        return sb.toString();
    }
}

2.4、集合中套集合

一对多

package learn6;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;



/*map扩展知识
 * map被使用是因为具备映射关系
 * "yureban" "01" "zhangsan";
 * "yureban" "02" "lisi";
 * "jiuyeban" "01" "wangwu";
 * "jiuyeban" "02" "zhaoliu";
 * 
 * 一个学校有多个教室，每个教室有多个学生
 * */
class Student
{
    private String id;
    private String name;
    Student(String name,String id)
    {
        this.id=id;
        this.name=name;
    }
    public String toString()
    {
        return id+":::"+name;
    }
}
public class MapDemo3 {
    public static void demo(){
        HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
        List<Student> yure = new ArrayList<Student>();
        List<Student> jiuye = new ArrayList<Student>();
        czbk.put("yureban",yure);
        czbk.put("jiuyeban",jiuye);
        yure.add(new Student("01","zhangsan"));
        yure.add(new Student("04","wangwu"));
        jiuye.add(new Student("01","zhaoqi"));
        jiuye.add(new Student("01","zhaoqi"));
        
        Iterator<String> it = czbk.keySet().iterator();
        while(it.hasNext())
        {
            String roomName = it.next();
            List<Student> room = czbk.get(roomName);
            System.out.println(roomName);
            getInfos(room);
        }
        
        
    }
    public static void getInfos(List<Student> list)
    {
        Iterator<Student> it = list.iterator();
        while(it.hasNext())
        {
            Student s=it.next();
            System.out.println(s);
        }
    }
    
    
    
    public static void main(String[] args) {
        demo();
//        HashMap<String,HashMap<String,String>> czbk = new HashMap<String, HashMap<String,String>>();
//        HashMap<String,String> yure = new HashMap<String,String>();        
//        HashMap<String,String> jiuye = new HashMap<String,String>();
//        
//        czbk.put("yureban", yure);
//        czbk.put("jiuye", jiuye);
//        
//        yure.put("01", "zhangsan");
//        yure.put("02", "lisi");
//        
//        jiuye.put("01", "wangwu");
//        jiuye.put("02", "zhaoliu");    
//        
//        //遍历传智播客
//        Iterator<String> it = czbk.keySet().iterator();
//        while(it.hasNext())
//        {
//            String roomName = it.next();
//            HashMap<String,String> room = czbk.get(roomName);
//            System.out.println(roomName);
//            getStudentInfo(room);
//        }
        
//        getStudentInfo(yure);
    }
    public static void getStudentInfo(HashMap<String,String> roomMap)
    {    
        Iterator<String> it = roomMap.keySet().iterator();
        while(it.hasNext())
        {
            String id= it.next();
            String name = roomMap.get(id);
            System.out.println(id+":"+name);
        }
    }
}