Java基础（六）——TreeSet、Comparable、泛型、Map、Collections

TreeSet集合

TreeSet集合特点

• 元素有序，这里的顺序不是指存储和取出的顺序,而是按照一定的规则进行排序，具体排序方式取决于构造方法

  • TreeSet():根据其元素的自然排序进行排序
  • TreeSet(Comparator comparator) :根据指定的比较器进行排序

• 没有带索引的方法，所以不能使用普通for循环遍历

• 由于是Set集合,所以不包含重复元素的集合

 

自然排序Comparable的使用

●存储学生对象并遍历， 创建TreeSet集合使用无参构造方法
要求:按照年龄从小到大排序,年龄相同时，按照姓名的字母顺序排序

• public interface Comparable<T>
  

  该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。

  Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。 实现该接口的对象，可以使用如在键sorted map或作为在元件sorted set ，而不需要指定一个comparator 。

  一类C的自然顺序被说成是与equals一致当且仅当e1.compareTo(e2) == 0对每一个e1和C类e2相同的布尔值e1.equals(e2)。 请注意， null不是任何类的实例， e.compareTo(null)应该抛出一个NullPointerException即使e.equals(null)返回false 。

例子：

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //重写接口Comparable的方法，为了集合中能够按照年龄进行排序
    @Override
    public int compareTo(Student o) {
        //年龄从小到大来排序
        int num = this.age - o.age;
        //年龄相同时，按字母的顺序进行排序
        int num2 = num==0?this.name.compareTo(o.name):num;
        return num2;
    }
}

public class SetDemo {
    public static void main(String[] args) {
        TreeSet<Student> st = new TreeSet<Student>();

        Student s1 = new Student("zhangsan",32);
        Student s2 = new Student("lisi",31);
        Student s3 = new Student("hejin",37);
        Student s4 = new Student("daoming",35);
        Student s5 = new Student("xiaohan",27);
        Student s6 = new Student("feizi",31);

        st.add(s1);
        st.add(s2);
        st.add(s3);
        st.add(s4);
        st.add(s5);
        st.add(s6);
        for(Student i:st){
            System.out.println(i.getName() + ":" + i.getAge());
        }

    }
}

效果：

 

结论

• 用TreeSet集合存储自定义对象， 无参构造方法使用的是自然排序对元素进行排序的
• 自然排序， 就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
• 重写方法时， - 定要注意排序规则必须按照要求的主要条件和次要条件来写
  

实现不重复的随机数

public class ListDemo {
    public static void main(String[] args) {
//        Set<Integer> s = new HashSet<Integer>();
        //会自然排序
        Set<Integer> s = new TreeSet<Integer>();
        //随机数对象
        Random r = new Random();
        //集合数量不大于10
        while (s.size()<10){
            int num = r.nextInt(21);
            s.add(num);
        }
        for (int i:s) {
            System.out.println(i);
        }
    }
}

 

泛型

泛型概述

泛型:是JDK5中引入的特性,它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数， 最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：

• <类型>: 指定一种类型的格式。这里的类型可以看成是形参
• <类型1,类型2...>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
• 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型

例子：

Collection c = new ArrayList();
//使用泛型解决int和string混杂集合
Collection<String> c = new ArrayList<String>();

泛型的好处:

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

 

泛型类

例子：

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

public class ListDemo {
    public static void main(String[] args) {
        Generic<String> s = new Generic<>();
        s.setT("水浒");
        System.out.println(s.getT());

        Generic<Integer> n = new Generic<>();
        n.setT(100);
        System.out.println(s.getT());
    }
}

结果：

 

泛型方法

public class Generic {
    public <T> void show(T t){
        System.out.println(t);
    }
}

public class ListDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("李牧");
        g.show(100);
        g.show(true);
        g.show(12.56);
    }
}

结果：

 

类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符： <?>
• List<?>：表示元素类型未知的List,它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类, 可以使用类型通配符的上限

• 类型通配符上限: <? extends类型>
• List<? extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符 下限: <?super 类型>
• List<? super Number>:它表示的类型是Number或者其父类型

 

例子：

public class ListDemo {
    public static void main(String[] args) {
        //类型通配符： <?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        //类型通配符上限: <? extends类型>
        List<? extends Number> list4 = new ArrayList<Integer>();
        //类型通配符 下限: <?super 类型>
        List<? super Number> list5 = new ArrayList<Object>();
    }
}

 

可变参数

可变参数又称参数个数可变,用作方法的形参出现，那么方法参数个数就是可变的了

• 格式:修饰符返回值类型方法名(数据类型..变量名{ }
• 范例: public static int sum(int...a){ }

例子：

public class ListDemo {
    public static void main(String[] args) {
        System.out.println(Sum(10,20));
        System.out.println(Sum(10,20,30));
        System.out.println(Sum(10,20,30,40,50));
    }
    public static int Sum(int ...a){
        //将数据变成了一个数组,输出a是数组地址
        System.out.println(a);
        int sum=0;
        for(int i:a){
            sum+=i;
        }
       return sum;
    }
}

结果：

 

Map

• public interface Map<K,V>
  

  将键映射到值的对象。 地图不能包含重复的键; 每个键可以映射到最多一个值。

  这个接口取代了Dictionary类，它是一个完全抽象的类而不是接口。

  Map界面提供了三个集合视图 ，允许将映射内容视为一组键，值集合或键值映射集合。 地图的顺序被定义为其中在地图上的集合视图迭代返回元素的顺序。 一些地图实现，如TreeMap课程，对他们的订单做出了具体的保证; 其他人，像HashMap班，不要。

  注意：如果使用可变对象作为地图键，必须非常小心。 如果对象的值以影响equals比较的方式更改，而对象是地图中的键，则不会指定地图的行为。 这个禁令的一个特殊情况是，地图不允许将自己包含在内。 虽然地图可以将其本身作为一个值，但建议您非常小心： equals和hashCode方法在这样的地图上已经不太明确。

  所有通用映射实现类应提供两个“标准”构造函数：一个创建空映射的void（无参数）构造函数，以及一个具有类型为Map的单个参数的构造函数 ，它创建一个具有相同键值的新映射映射作为参数。 实际上，后一个构造函数允许用户复制任何地图，产生所需类的等效地图。 没有办法强制执行此建议（因为接口不能包含构造函数），而JDK中的所有通用映射实现都符合要求。

创建Map集合的对象

• 多态的方式
• 具体的实现类HashMap

 

例子：（注意在map中键是唯一的）

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

public class MapDemo {
    public static void main(String[] args) {
        //创建map集合对象
        Map<String,String> map = new HashMap<String,String>();

        //添加对象使用put方法
        map.put("map1","天地");
        map.put("map2","玄黄");
        map.put("map3","宇宙");
        map.put("map4","洪荒");
        System.out.println(map);
    }
}

结果：

Map集合的遍历：

1. 获取所有键值对对象的集合

   1. Set<Map. Entry<K,V>> entrySet(): 获取所有键值对对象的集合

2. 遍历键值对对象的集合，得到每一个键值对对象

   1. 用增强for实现，得到每一个Map.Entry

3. 根据键值对对象获取键和值

   1. 用getKey()得到键
   2. 用getValue()得到值

例子：

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

public class MapDemo {
    public static void main(String[] args) {
        //创建map集合对象
        Map<String,String> map = new HashMap<String,String>();

        //添加对象使用put方法
        map.put("map1","天地");
        map.put("map2","玄黄");
        map.put("map3","宇宙");
        map.put("map4","洪荒");
        //获取所有键值集合的对象
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        //遍历键值对象的集合，得到每一个简直对象
        for(Map.Entry<String,String> i:entrySet){
            //根据键值对象获取键和值
            String key = i.getKey();
            String value = i.getValue();
            System.out.println(key+":"+value);
        }
    }
}

结果：

HashMap嵌套ArrayList

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

public class MapDemo {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
        //创建Arraylist集合，并添加元素
        ArrayList<String> sgyy = new ArrayList<String>();
        sgyy . add( "诸葛亮");
        sgyy. add("赵云");
        //把ArrayL ist作为元素添加到HashMap集合
        hm. put("三国演义" ,sgyy);
        ArrayList<String> xyj = new ArrayList<String>();
        xyj. add("唐僧");
        xyj. add("孙悟空");
        //把ArrayL ist作为元素添加到HashMap集合
        hm. put("西游记",xyj);
        ArrayList<String> shz = new ArrayList<String>();
        shz . add("武松");
        shz.add("鲁智深");
        //把ArrayL ist作为元素添加到HashMap集合
        hm. put("水浒传",shz);
        //遍历HashMap集合
        Set<String> keySet = hm. keySet();
        for(String key : keySet) {
            System.out.println(key);
            ArrayList<String> value = hm.get(key);
            for (String s : value) {
                System.out.println("\t" + s);
            }
        }
    }
}

结果：

案例: 统计字符串中每个字符出现的次数

需求:键盘录入一个字符串,要求统计字符串中每个字符串出现的次数。
举例:键盘录入"aababcabcdabcde"
在控制台输出: "a(5)b(4)c(3)d(2)e(1)"
思路：

• ①键盘录入一个字符串

• ②创建HashMap集合,键是Character, 值是Integer

• ③遍历字符串，得到每一个字符

• ④拿得到的每一个字符作为键 到HashMap集合中去找对应的值，看其返回值

  • 如果返回值是null:说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
  • 如果返回值不是null:说明该字符在HashMap集合中存在,把该值加1,然后重新存储该字符和对应的值

• ⑤遍历HashMap集合，得到键和值，按照要求进行拼接

• ⑥输出结果

代码：

public class MapDemo {
    public static void main(String[] args) {
        //键盘录入一个字符串
        Scanner sc = new Scanner(System. in);
        System.out.println("请输入一个字符串: ");
        String line = sc.nextLine();
        //创建HashMap集合，键是Character, 值是Integer
        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();
        //遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
            Integer value = hm.get(key);
            if (value == null) {
                //如果返回值是null: 说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key, 1);
            } else {
                //如果返回值不是null:说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key, value);
            }
        }

        //遍历HashMap集合，得到键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for(Character key : keySet) {
            Integer value = hm. get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        System.out.println(sb);
    }
}

结果：

 

Collections

• public class Collections
  extends Object
  

  此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。

  如果提供给它们的集合或类对象为null，则此类的方法都抛出一个NullPointerException 。

  该类中包含的多态算法的文档通常包括实现的简要说明 。 这些描述应被视为实施说明 ，而不是说明书的一部分 。 只要规范本身得到遵守，实现者就可以随意替代其他算法。 （例如，sort使用的算法不一定是一个mergeesort，但它必须是稳定的 。）

Collections类的概述

• 是针对集合操作的工类

Collections类的常用方法

• public static <T extends Comparable<? super T>> void sort(List<T> list): 将指定的列表按升序排序
• public static void reverse(List<?> list): 反转指定列表中元素的顺序
• public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表

例子：

public class MapDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        //public static <T extends Comparable<? super T>> void sort (List<T> list): 将指定的列表按升序排序
        Collections.sort(list);
        //public static void reverse (List<?> list): 反转指定列表中元素的顺序
        Collections.reverse(list);
        //public static void shuffle (List<?> list): 使用默认的随机源随机排列指定的列表
        //Collections.shuffle(list);
        System.out.println(list);
    }
}

结果：

 

 

 

 

 

一起学习，一起进步 -.- ，如有错误，可以发评论