JAVA高级教程Java 泛型（10）

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量55 收藏
点赞数
分类专栏： # java高级学习 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Leoon123/article/details/133969673
版权

目录


三、泛型的使用

  • 泛型类
  • 语法 类名
  • 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());
    }

}

可以看出，年龄从小到大排列

Leoon123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java高级-泛型
weixin_45900005的博客
10-26 963
12.泛型 1.泛型的概念 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参)。 12.1.为什么要用泛型 泛型与File中使用泛型举例 泛型的使用 泛型即传入实际的参数类型,也称类型实参 1.jdk5.0新增的特性 2.在集合中使用泛型: 总结: ①集合接口或集合类在jdk5.0时都修改为带泛型的就够. ②在实例化集合类时
详解Java中的 枚举与泛型
08-31
虽然枚举和泛型在概念上有所不同，但它们可以一起使用，以实现更高级的功能。例如，你可以创建一个泛型方法，接受任何类型的枚举作为参数，或者定义一个泛型类，其中的字段是枚举类型。这样可以确保类型安全，并利用...
Java高级编程——泛型
qq_61524266的博客
06-12 698
Java高级编程——泛型
java 高级泛型_Java 泛型高级
weixin_39997443的博客
02-13 83
1、限制泛型可用类型在定义泛型类别时，预设可以使用任何的类型来实例化泛型中的类型，但是如果想要限制使用泛型的类别时，只能用某个特定类型或者其子类型才能实例化该类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口。如下Codepublic class ListGenericFlag {private T[] flagArray;public T[] getFlagArray...
java 高级泛型_java泛型的高级应用
weixin_30467861的博客
02-25 273
展开全部在上面的例子中，由于没有限制class GenericsFoo类型持有者T的范围，实际上这里32313133353236313431303231363533e59b9ee7ad9431333339666666的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：class GenericsFoo，这样类中的泛型T只能是Coll...
Java高级--泛型
Dumpling_skin的博客
07-14 335
Java高级之泛型，泛型的概念，引入，以及泛型的使用
java泛型的高级用法
wsrzsfgst的博客
03-06 546
Java 泛型提供了强大的泛型机制，可以在编译时检查类型安全，并且可以编写通用的代码，使得代码更加灵活和重用。这些是一些常见的高级泛型用法，通过灵活运用泛型机制，可以使代码更加通用和安全。：在 Java 中创建泛型数组是不合法的，但是可以使用通配符或 Array.newInstance() 方法来创建泛型数组。：类似于泛型类，泛型接口可以定义一种通用类型，可以在接口的方法中使用泛型类型。：泛型类也可以进行继承，子类可以继承父类的泛型类型，并可以添加自己的泛型类型。通配符可以用在泛型类、方法、接口等地方。
java高级篇--泛型
Xzh_java的博客
07-14 495
java高级篇 --泛型详解
【Java】java高级之泛型
qq_62361050的博客
07-26 364
泛型可以在编译的时候检查类型安全，并且所有的强制类型转换都是自动和隐式的。泛型的原理就是“数据的参数化”，即把类型看作整数。也就是说把所要操作的数据类型看作参数，就像方法的形式参数是运行时传递的值的占位符一样。简单的说，类型变量扮演的角色就如同一个参数，它提供给编译器用来类型检查的信息。泛型可以提高代码的扩展性和重用性。Ta;returna;}}...
java 高级泛型_高级教程
weixin_31942999的博客
02-25 124
Java 泛型如果我们只写一个排序方法，就能够对整型数组、字符串数组甚至支持排序的任何类型的数组进行排序，这该多好啊。Java泛型方法和泛型类支持程序员使用一个方法指定一组相关方法，或者使用一个类指定一组相关的类型。Java泛型(generics)是JDK 5中引入的一个新特性,泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。使用Java泛型的概念，我们可以写一个泛型方...
Java的高级篇--泛型和注解
Ysuhang的博客
07-14 368
其实我们再使用集合时就用过泛型List 创建一个List对象List list=new ArrayList();它就是泛型。例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。 但是:如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。但是它违背了我们设计的要求，这就是我们提到的数据类型安全问题。如何解决数据类型安全问题?可以使用泛型来解决。 注意: 上面的泛型类型必须都是引用类型。不能是基本类型。使用泛型就保证了数据类型安全问题。泛型......
Java高级之—泛型的使用
12-21
Java泛型是自JDK 5.0版本引入的一种强大的编程工具，它允许开发者在类、接口以及方法中声明类型参数，从而提高了代码的类型安全性、重用性和可读性。下面将详细介绍泛型的概念、使用方法以及自定义泛型结构。 **一...
Java高级编程实用教程
05-30
Java高级编程实用教程是针对已经掌握了Java基础的开发者们深入学习的一门课程，旨在提升他们的编程技巧和解决复杂问题的能力。本教程将涵盖多个关键领域，包括多线程、网络编程、I/O流、反射、异常处理、集合框架、...
Java高级特性 第一章 集合框架和泛型
10-23
"Java高级特性：集合框架和泛型" Java高级特性系列第一章：集合框架和泛型 Collections Framework是Java语言中一个基础的数据结构.framework，它提供了多种类型的数据结构，包括List、Set、Map等，帮助开发者更...
完整版 Java高级教程 Java语言程序设计 第4章 Java泛型（共10页）.ppt
12-19
Java泛型是自Java 1.5版本引入的一项重要特性，它允许我们在编程时指定类型参数，从而增强代码的类型安全性和重用性。泛型的主要目标是消除强制类型转换，减少ClassCastException的风险，并提高代码的可读性和可维护...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 449
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 244
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 620
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 278
集合之Map
Java语言教程： LinkedList 泛型类常用方法解析
"这篇教程是关于Java编程的，特别是针对LinkedList类的一些常用方法。Java是一种广泛应用的编程语言，因其平台无关性、面向对象、多线程和安全性等特性而受到欢迎。它起源于1995年，由Sun公司的James Gosling领导的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Leoon123

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值