JAVA高级教程Java 泛型（10）

news2024/10/7 10:15:30

三、泛型的使用
- 泛型类
- 泛型接口
- 泛型方法
四、泛型在集合中的使用
- 1、使用泛型来创建set
- 2、使用泛型来创建HashSet
- 3、使用equals，hashCode的使用
- - Person 类
  - HashSet的使用+泛型
  - TreeSet的使用+泛型
  - comparator实现定制比较(比较器)

三、泛型的使用

泛型类
语法类名
T表示类型站位符，表示一种引用数据类型用啥字母都行
泛型只能创建变量，不能实例化对象
好处
1、提高代码重复性
2、防止类型转换异常

泛型类

package MyGeneric;

/**
 * 泛型类
 * 语法 类名<T>
 * T表示类型站位符，表示一种引用数据类型，用啥字母都行
 * 泛型只能创建变量，不能实例化对象
 * @param <T>
 */

public class Generic<T> {
    //使用泛型T
    //创建变量
    T t;

    //泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }

    //泛型作为方法的返回值
    public T getT(){
        return t;
    }


}





# 泛型类的使用
package MyGeneric;

public class TestGeneric {
    public static void main(String[] args) {
        System.out.println("==========类型为Generic<String>==========");
        Generic<String> generic=new Generic<>();
        generic.t="hello";
        generic.show("高考加油");

        String string=generic.getT();
        System.out.println(string);

        System.out.println("==========类型为Generic<Integer>==========");
        Generic<Integer> intgeneric=new Generic<>();
        intgeneric.t=100;
        intgeneric.show(200);
        Integer integer=intgeneric.getT();

    }
}

泛型接口

定义接口

package MyGeneric;

/**
 * 泛型类
 * 语法 类名<T>
 * 不能使用泛型静态常量
 */

public interface GenericInterface<T> {
    String name="张三";
    T server(T t);
}

实现类
GenericInterfaceImp2创建对象的时候来确定类型，这样更加灵活

package MyGeneric;

public class GenericInterfaceImp2<T> implements GenericInterface<T> {

    @Override
    public T server(T t) {
        System.out.println(t);
        return null;
    }
}

使用

package MyGeneric;

public class TestGenericInterfaceImps {
    public static void main(String[] args) {
        
        GenericInterfaceImp2<Integer> impl2=new GenericInterfaceImp2<>();
        impl2.server(1000); //什么类型都可以添加

    }
}

泛型方法

package MyGeneric;

/**
 * 泛型方法
 * 语法： <T> 返回值类型
 */

public class GenericMethod {

    public <T> void show(T t){
        System.out.println("泛型方法"+t);
    }
}

泛型方法的使用

package MyGeneric;
public class TestGenericMethod {
    public static void main(String[] args) {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.show("中国");
        genericMethod.show(1);
        genericMethod.show(3.14);
    }
}

四、泛型在集合中的使用

这里使用set来举例

1、使用泛型来创建set

package Set01;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * set接口的使用
 * 特点：无序。没有下标，不能重复
 */

public class Demo01_set {

    public static void main(String[] args) {
        //创建集合
        Set<String> set=new HashSet<>();

        //添加数据
        set.add("1");
        set.add("2");
        set.add("3");

        //移除数据
        set.remove("1");
        System.out.println(set.toString());


        System.out.println("数据的个数"+set.size());
        System.out.println(set.toString());


        //遍历数据
        System.out.println("====================3.2 增强for循环=====================");
        for(String i:set){
            System.out.println(i);
        }

        System.out.println("====================3.2 Iterator迭代器=====================");
        //3.2 Iterator迭代器
        Iterator<String> it=set.iterator();
        while (it.hasNext()){
            //不能使用Collection删除
            String s=(String)it.next();
            System.out.println(s);
            //it.remove();
        }
        //* 4、判断
        System.out.println(set.contains("张三"));
        System.out.println(set.isEmpty());
    }
}

2、使用泛型来创建HashSet

package Set01;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Demo02_HashSet {
    public static void main(String[] args) {
        //创建集合
        HashSet<String> set=new HashSet<>();

        //添加数据
        set.add("1");
        set.add("2");
        set.add("3");

        //移除数据
        set.remove("1");
        System.out.println(set.toString());


        System.out.println("数据的个数"+set.size());
        System.out.println(set.toString());


        //遍历数据
        System.out.println("====================3.2 增强for循环=====================");
        for(String i:set){
            System.out.println(i);
        }

        System.out.println("====================3.2 Iterator迭代器=====================");
        //3.2 Iterator迭代器
        Iterator<String> it=set.iterator();
        while (it.hasNext()){
            //不能使用Collection删除
            String s=(String)it.next();
            System.out.println(s);
            //it.remove();
        }
        //* 4、判断
        System.out.println(set.contains("张三"));
        System.out.println(set.isEmpty());
    }
}

3、使用equals，hashCode的使用

Person 类

package Set01;

import java.util.Objects;

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

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    //先按性比，在按年龄比
    @Override
    public int compareTo(Person o) {
        int n1=this.getName().compareTo(o.getName());
        int n2=this.getAge()-o.getAge();
        return n1==0?n2:n1;
    }
}

HashSet的使用+泛型

package Set01;

import java.util.HashSet;

/**
 *
 * 存储过程
 * 1、根据hascode计算保存的位置，如果为空，则直接保存，不为空执行第二步
 * 2、在执行equal方法，如果equals方法为true，则认为重复，否则，形成链表
 */

public class Demo03_HashSet {

    public static void main(String[] args) {
        HashSet<Person> peoples=new HashSet<>();
        Person p1=new Person("刘德华",20);
        Person p2=new Person("李小龙",22);
        Person p3=new Person("彭于晏",24);

        peoples.add(p1);
        peoples.add(p2);
        peoples.add(p3);

        //在person中重写hascode和equals方法后，不能添加Person("彭于晏",24)，应为重复了
        peoples.add(new Person("彭于晏",24));

        //如果没重写equals是不能删除的
        peoples.remove(new Person("刘德华",20));

        System.out.println("数据的个数"+peoples.size());
        System.out.println(peoples.toString());
    }
}

TreeSet的使用+泛型

package Set01;

import java.util.HashSet;
import java.util.TreeSet;

/**
 * 元素必须要实现 comparable接口    comparable方法返回为0，认为是重复元素
 */
public class Demo03_TreeSet {
    public static void main(String[] args) {


        TreeSet<Person> peoples=new TreeSet<>();
        Person p1=new Person("刘德华",20);
        Person p2=new Person("李小龙",22);
        Person p3=new Person("彭于晏",24);

        peoples.add(p1);
        peoples.add(p2);
        peoples.add(p3);


        System.out.println("数据的个数"+peoples.size());
        System.out.println(peoples.toString());
    }
}

comparator实现定制比较(比较器)

package Set01;

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

/**
 * comparator实现定制比较(比较器)
 */
public class Demo04_TreeSet {
    public static void main(String[] args) {
        //创建集合，并指定比较规则
        TreeSet<Person> peoples=new TreeSet<>(new Comparator<Person>() {
            //两个对象进行比较
            @Override
            public int compare(Person o1, Person o2) {
                int n1=o1.getAge()-o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
		Person p3=new Person("彭于晏",24);
        Person p1=new Person("刘德华",20);
        Person p2=new Person("李小龙",22);
        

        peoples.add(p1);
        peoples.add(p2);
        peoples.add(p3);


        System.out.println("数据的个数"+peoples.size());
        System.out.println(peoples.toString());
    }

}