java语言入门（四）java 泛型与收集API（6）

最新推荐文章于 2022-11-24 21:13:16 发布

你可拉倒吧

最新推荐文章于 2022-11-24 21:13:16 发布

阅读量243

点赞数

文章标签： java泛型集合 map

本文链接：https://blog.csdn.net/qq_35794278/article/details/80069846

版权

java基础专栏收录该内容

21 篇文章 1 订阅

订阅专栏

本文详细介绍了Java泛型的使用方法及其好处，包括泛型类、接口和方法等概念，并通过实例演示了泛型如何提高代码的类型安全性和复用性。此外，还深入探讨了Collection API中的Set与List接口特性及其主要实现类的特点。

摘要由CSDN通过智能技术生成

1.0 java 泛型

1.1 泛型的使用

泛型的本质是参数化类型也就是说什么类型是由你输入决定的，泛型可以用在类，接口，方法。分别叫做泛型类，

泛型接口，泛型方法，在我看来，类似C++里的模板

用法：<>之间定义形式类型参数

package aggregate;

public class FX <T>{
    private T a;

    public T getA() {
        return a;
    }

    public void setA(T a) {
        this.a = a;
    }

    public String toString(){
        return "这个参数的类型是"+a.getClass().getName()+"  "+"值为："+a;
    }

    public static void main(String[] args) {
        FX<Integer> fx = new FX<Integer>();
        /**
            上面的代码还可以这么写
            FX fx = new FX();
            不指定泛型类型 由参数类型直接决定
        */
        fx.setA(10);
        System.out.println(fx);
    }
}

结果:
这里写图片描述

几点说明：

泛型的类型参数只能是类类型，包括自定义类型也就是说FX< Integer> fx = new FX< Integer>(); <>里不能是int
泛0型的类型参数可以有多个例如 Map< K,V >
类型参数说的是定义阶段
参数类型说的是使用阶段
参数类型可以使用继承语句表示限定参数的范围例如 public class FX < T extends Number> //限定T的类型<=Number
泛型的参数类型还可以是通配符类型例如ArrayList

/*
泛型的好处
    编译时确定类型，保证类型安全,避免类型转换异常。
    避免了强制类型转换。
    代码利于重用，增加通用性。

泛型的限制和规则
    泛型的类型参数只能是引用类型，不能使用值类型。
    泛型的类型参数可以有多个。
    泛型类不是真正存在的类，不能使用instanceof运算符。
    泛型类的类型参数不能用在静态申明。
    如果定义了泛型，不指定具体类型，泛型默认指定为Ojbect类型。
    泛型使用？作为类型通配符，表示未知类型，可以匹配任何类型。因为是未知，所以无法添加元素。
    类型通配符上限：<? extends T>，?代表是T类型本身或者是T的子类型。常用于泛型方法，避免类型转换。
    类型通配符下限。<? super T>，?代表T类型本身或者是T的父类型。
    除了通配符可以实现限制，类、接口和方法中定义的泛型参数也能限制上限和下限。

*/

//通配符的使用
package aggregate;

public class QQ {
    //因为不知道要传入泛型是什么，所以用通配符表示任何的类型  因为泛型不是类 所以不能用Object
    public void Test001(FX<?> as){
        System.out.println(as);
    }
}

1.2 comparable< T> 接口与comparator< T>接口

一个类实现了comparable接口，这个类就是可以比较的，这个类组成的集合就可以进行排序
看例子

package aggregate;

import java.lang.reflect.Array;
import java.util.*;

public class Compara implements Comparable<Compara>{
    private int age;
    private String name;
    public Compara(int age,String name){
        this.age =age;
        this.name =name;
    }
    @Override
    public int compareTo(Compara o) {
        // TODO Auto-generated method stub
        return this.age - o.age;
    }

    @Override
    public String toString(){
        return "这个人叫 "+name+"  这个人的年龄是 "+age;
    }
    public static void main(String[] args) throws Exception {
        Compara compara0 = new Compara(100, "xyd");
        Compara compara1 = new Compara(10, "xyd");
        Compara compara2 = new Compara(15, "xyd");
        System.out.println(compara0.compareTo(compara1));//比较这两个对象
        Compara compara[] = {compara0,compara1,compara2};
        Arrays.sort(compara);//数组排序
        for(Compara a:compara){
            System.out.println(a);
        }

    }
}

结果：
90
这个人叫 xyd 这个人的年龄是 10
这个人叫 xyd 这个人的年龄是 15
这个人叫 xyd 这个人的年龄是 100

我在测试的时候使用的是JDk1.8 找不到 Arrays类应该是Eclipse版本太低的原因换成1.7解决问题

comparator接口常用与以下

类的设计时没有考虑比较的问题，这时候我们就可以自己实现比较了
排序的时候需要升序逆序啥的

package aggregate;
//要对这个类排序
public class NOCompara {
    private int age;
    public NOCompara(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }

    public String toString(){
        return "age = "+age;
    }
}

//写排序的类
package aggregate;

import java.util.Arrays;
import java.util.Comparator;

public class ComparatorImp implements Comparator<NOCompara> {

    @Override
    public int compare(NOCompara o1, NOCompara o2) {
        // o2-o1 是降序排列   o1-o2 是升序排列
        return o2.getAge()  - o1.getAge();
    }

        public static void main(String[] args) {
            NOCompara as[]  = {new NOCompara(7),new NOCompara(700),new NOCompara(100)};
            Arrays.sort(as,new ComparatorImp());

            for (NOCompara noCompara : as) {
                System.out.println(noCompara);
            }
        }
}