小饶学编程之JAVA SE第一部分——JavaSE 核心类库：14集合框架（二）：泛型、集合工具类、TreeMap和TreeSet

淡淡的烟草味﹌ 2022-12-24 15:50 143阅读 0赞

### 泛型 、集合工具类、TreeMap和TreeSet ###

*   *  一.泛型
     *   *  1.泛型类
         *  2.泛型接口
         *  3.泛型方法
         *  4.泛型通配符
     *  二.集合工具类
     *  三.TreeMap和TreeSet

## 一.泛型 ##

Java泛型是jdk 1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

*  引入案例
    
    需求：输出集合中所有的字符串

ArrayList list = new ArrayList();
    list.add("hello");
    list.add("world");
    list.add(666);
    //需求：输出集合中所以的字符串
    for (Object o:list){
        
        //会抛出类型转换异常
        System.out.println((String)o);
    }
    //异常分析：集合中数据类型不统一

*  案例改进
    
    在源头上对数据进行约束，除了字符串，其它类型数据不能放入集合

//增加了泛型对类型进行约束
    ArrayList <String>list = new ArrayList();
    list.add("hello");
    list.add("world");
    list.add(666);//编译不通过
    for (String s:list){
        //直接用String接收，无须强转
        //会抛出类型转换异常
        System.out.println(s);
    }

### 1.泛型类 ###

类的后面定义一个或多个任意类型 ,可以在类的成员属性或方法中使用，例如：

public class Hello<T,A,B,C> {
        
        private T t;
        private A a;
        private B b;
        private C c;
        //省略seter/getter和构造方法
        //应用于方法的形参
        public void fun1(A a){
        
            System.out.println(a);
        }
        public void fun2(B b){
        
            System.out.println(b);
        }
        public void fun3(C c){
        
            System.out.println(b);
        }
    }
    //测试类中，调用构造方法，传入不同的类型作为参数，创建对象。

*  常见应用：List,Set,Map接口

People<String , Double, Integer> people1 = new  People<>("曹操",999.99,26);
     People<String , Boolean, Character> people2 = new  People<>("刘备",false,'男');

### 2.泛型接口 ###

public interface Haha <T> {
        
        void ff(T t);
    }

*  编写实现类，重写ff方法
 *  常见应用：比较器Comparable

### 3.泛型方法 ###

在方法结构上声明一个或多个泛型，可用于方法的返回值或形参。

public <T> void fun1(T t){
        
            System.out.println(t);
     }
     public <T> T fun1(T t){
        
            System.out.println(t);
         return t;
     }

### 4.泛型通配符 ###

<? extends 类型> 表示某个类型或它的任意子类型

<? super 类型> 表示某个类型或它的任意父类型

public static void cal(ArrayList<? extends Animal> s) {
        
    	...
    }

## 二.集合工具类 ##

Collections工具类：是一个主要对List集合进行操作的工具类，里面包含静态方法。只能使用内部比较器

*  随机打乱shuffle
 *  排序sort
 *  交换swap
 *  查找binarySearch:前提是集合中的元素必须按某种规则升序排序

案例：  
1.现有5只猴子（姓名，年龄），将他们存入List集合中，先随机打乱，然后使用工具类，对这一群猴子按照年龄进行排序。

2.交换集合中的第一个和第三个猴子

3.查找名称叫 肉肉 的猴子

下面展示一些 `案例代码片`。

monkey猴子类：

package monkey;
    
    public class Monkey implements Comparable<Monkey> {
        
        private String name;
        private  int age;
    
        @Override
        public int compareTo(Monkey m) {
        
            //包装类才有compareTo方法
            //return this.getAge()-m.getAge();//年龄排序
            return this.getName().compareTo(m.getName());//姓名排序
        }
        @Override
        public String toString() {
        
            return "Monkey{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Monkey() {
        
        }
    
        public Monkey(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;
        }
    }

TestMonkey猴子测试类：

package monkey;
    
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    
    public class TestMonkey {
        
        @Test
        public void Test1(){
        
            ArrayList<Monkey> monkeys = new ArrayList<Monkey>();
            monkeys.add(new Monkey("灰灰",5));
            monkeys.add(new Monkey("白白",3));
            monkeys.add(new Monkey("咕咕",2));
            monkeys.add(new Monkey("肉肉",9));
    
            //随机打乱shuffle
            Collections.shuffle(monkeys);
            System.out.println(monkeys);
    
            //交换swap
            Collections.swap(monkeys,1,2);
            System.out.println(monkeys);
    
            //排序sort
            Collections.sort(monkeys);
            System.out.println(monkeys);
    
          //查找binarySearch：前提是集合中的元素必须按某种规则升序排序
            System.out.println(Collections.binarySearch(monkeys, new Monkey("肉肉", 5)));
        }
    }

下面是运行结果的截图：  
![在这里插入图片描述][20201103184601603.png_pic_center]

## 三.TreeMap和TreeSet ##

1.  Set和Map的关系：
    
    set使用了map的key.
2.  继承关系：
    
    Set接口有一个实现类是HashSet,还有一个子接口是SortedSet,该接口有一个实现类是TreeSet。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70_pic_center]

TreeSet是一个有序集合，会根据自然排序排列或比较器进行排序，且没有重复元素，也没有下标。通过TreeMap实现。

TreeMap中的元素默认按照keys的自然排序排列或比较器进行排序。

*  构造方法

//1.无参构造
    new TreeSet<>();
    new TreeMap<>();
    //2.有参构造
    new TreeSet<>(外部比较器Comparator);
    new TreeMap<>(外部比较器Comparator);

[20201103184601603.png_pic_center]: /images/20221120/6e11f84537364dc1be7c7ea275fc0cfc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/13b3eb4681854956b4a4afa88b5c81f5.png