数据结构之泛型总结

Java泛型与数据结构应用 本文介绍了Java中类、继承和组合对数据结构可复用性的贡献,详细讲解了泛型方法与类的使用,包括泛型选择排序、比较、链表操作及集合处理。涵盖了类型参数、通配符上界、集合工具类等核心概念,并通过代码示例展示了链表连接、合并有序列表、栈逆序输出单词等功能的实现。 阅读详情

目录

一、泛型类的引出

二、泛型类的定义和使用

三、泛型的编译

四、泛型的上界

五、泛型方法

六、通配符

1.什么是通配符:

2.通配符可以解决的泛型问题:

3.通配符的上界

4.通配符的下界


一、泛型类的引出

1.什么是泛型

一般的类和方法,只能使用具体的类型 : 要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。泛型是在JDK1.5 引入的新的语法,通俗讲,泛型: 就是适用于许多类型 。从代码上讲,就是对类型实现了参数化。
2. 对于泛型的引入和初步认识,我在“数据结构之List”中已经总结过,这里不再重复啰嗦
但是我们要知道一件事情: 泛型的主要目的:就是指定当前的容器,要持有什么类型的对象。让编译 器去做检查。 此时,就需要把类型,作为参数传递。需要什么类型,就传入什么类型。

二、泛型类的定义和使用

1.泛型类的定义

class 泛型类名称<类型形参列表> { 
    // 这里可以使用类型参数 
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ { 
    // 这里可以使用类型参数 
}

举个例子:

class MyArray<T> {
    public T[] array = (T[])new Object[10];//这样写也不好,我们一会儿进行解释
    public T getPos(int pos) { 
        return this.array[pos]; 
    }
    public void setVal(int pos,T val) { 
        this.array[pos] = val; 
    } 
}
public class TestDemo {
    public static void main(String[] args) { 
        MyArray<Integer> myArray = new MyArray<>();//第12行代码
        myArray.setVal(0,10);
        myArray.setVal(1,12); 
        int ret = myArray.getPos(1);
        System.out.println(ret);
        //myArray.setVal(2,"bit");//代码编译报错,此时因为在注释2处指定类当前的类型,此时在注释4处,编译器会在存放元素的时候帮助我们进行类型检查。
    } 
}

 (1)类名后的 <T> 代表占位符,表示当前类是一个泛型类,类型形参一般使用一个大写字母表示,常用的名称有:

  • E 表示 Element
  • K 表示 Key
  • V 表示 Value
  • N 表示 Number
  • T 表示 Type
  • S, U, V 等等 - 第二、第三、第四个类型

(2)不能new泛型类型的数组

即:T[] ts = new T[5];//error

(3)第12行代码处:类型后加入 <Integer> 指定当前类型。泛型只能接受类,所有的基本数据类型必须使用包装类!所以<int>error!

2.泛型类的使用

泛型类<类型实参> 变量名; // 定义一个泛型类引用 

new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

注意:当编译器可以根据上下文推导出类型实参时,可以省略类型实参的填写,如:

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 String

3.裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参,例如 MyArrayList 就是一个裸类型,如:
MyArray list = new MyArray();

注意:我们不要自己去使用裸类型,裸类型是为了兼容老版本的 API 保留的机制

三、泛型的编译

在Powershell窗口中查看“二”中的代码是如何编译的,如图所示:

 通过命令:javap -c 查看字节码文件,所有的T都是Object。

在编译的过程当中,将所有的 T 替换为 Object 这种机制,我们称为: 擦除机制 。 Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。(即泛型只存在于编译的时候)

那么现在问题来了,为什么T[] ts = new T[5]; 是不对的,编译的时候替换为Object,不是相当于Object[] ts = new Object[5]吗?

如下代码所示:

class MyArray<T> {
    //public T[] objects = new T[10];//error   
    public T[] objects = (T[])new Object[10];//理论上说这样也是错的

    public void set(int pos, T val){
        objects[pos] = val;
    }

    public T get(int pos){
        return objects[pos];
    }

    public T[] getArray(){
        return objects;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>();
        String[] ret = myArray.getArray();//第20行代码
    }
}
编译并运行该代码,输出如下:(编译没有报错,运行时报错了)

 数组和泛型之间的一个重要区别是它们如何强制执行类型检查。具体来说,数组在运行时存储和检查类型信息。然而,泛型在编译时检查类型错误。

也就是说返回的 Object 数组里面,可能存放的是任何的数据类型,可能是 String ,可能是 Person ,运行的时候,直接转给String类型的数组,编译器认为是不安全的。(所以可以把第20行的String[]换成Object[])
我们可以通过反射来new一个泛型数组,我会在后续博客中总结,这里简单的写一下如何new这么的一个泛型数组
import java.lang.reflect.Array;
class MyArray<T> {
    public T[] array;
    public MyArray() {}

    public MyArray(Class<T> clazz, int capacity) { 
        array = (T[])Array.newInstance(clazz, capacity); 
    }
    public T getPos(int pos) { 
        return this.array[pos]; 
    }
    public void setVal(int pos,T val) { 
        this.array[pos] = val; 
    }
    public T[] getArray() { 
        return array; 
    } 
}
public static void main(String[] args) { 
    MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10); 
    Integer[] integers = myArray1.getArray(); 
}

四、泛型的上界

在定义泛型类时,有时需要对传入的类型变量做一定的约束,可以通过类型边界来约束。
class 泛型类名称<类型形参 extends 类型边界> {
    ...
}

例如:

class MyArray<T extends Number> {//T只能是Number或者Number的子类
    public T[] objects = (T[])new Object[10];

    public void set(int pos, T val){
        objects[pos] = val;
    }

    public T get(int pos){
        return objects[pos];
    }

    public T[] getArray(){
        return objects;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>();//第18行代码
        MyArray<Integer> myArray2 = new MyArray<>();
    }
}

第18行代码从编译开始就出错了,因为String 不是 Number 的子类型,但是Integer是。

注意:

(1)泛型只有上界,没有下界

(2)没有指定边界时,默认边界为Object

class MyArray<T>{//默认边界为Object
......
}

一个比较复杂的例子:写一个泛型类,求出数组当中的最大值

class Alg<T extends Comparable<T>>{//此时传入的T一定要实现该接口   此处不是继承
    public T findMax(T[] array){
        T max = array[0];
        for(int i = 1; i < array.length; i++){
            if(max.compareTo(array[i]) < 0){//①max<array[i]//error 泛型传入的类型均为类类型,不能直接用><=比较
                                            //②也不能用equals方法,它只能比较true和false,比较不了大小关系。两个引用比较大小,要用CompareTo方法
                max = array[i];
            }
        }
        return max;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] array = {1,22,3,4};
        System.out.println(alg.findMax(array));
    }
}

编译并运行该代码,输出如下:

22

注意Integer是实现了Comparable<>接口的,如图所示:

该代码有一个不好的地方,我们每次想调用findMax方法时,必须要new一个对象;我们对其进行优化一下

五、泛型方法

1.

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { 
    ... 
}

优化如下:

class Alg2/*<T extends Comparable<T>>*/{// "/* */"的这一部分写和不写都是一样的
    public static<T extends Comparable<T>> T findMax(T[] array){//我们发现当我们加一个static后,整个代码都报错了,这是因为加了static后,我们的方法不再依赖
                                       //于对象,我们在使用该方法时不再new对象,但是我们的泛型传参在new对象时传参,所以如果加了一个static的
                                       //的话,相当于没有传参;因此我们在static处加上<T>,但是要用compareTo方法,还是要实现Comparable接口
        T max = array[0];
        for(int i = 1; i < array.length; i++){
            if(max.compareTo(array[i]) < 0){
                max = array[i];
            }
        }
        return max;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Integer[] array = {1,22,3,4};
        System.out.println(alg./*<Integer>*/findMax(array));//"/* */"的这一部分写和不写都是一样的,它会通过array的类型来推导方法中的T是什么类型【类型推导】
    }
}

2.泛型中的父子类关系

public class MyArrayList<E> { 
    ... 
} 
// MyArrayList<Object> Object不是 MyArrayList<Number> 中的Number的父类类型 
// MyArrayList<Number> Number也不是 MyArrayList<Integer> 的Integer父类类型

因为在编译的时候它们都被擦除了

举个例子:

class Alg<T extends Comparable<T>>{
    public T findMax(T[] array){
        T max = array[0];
        for(int i = 1; i < array.length; i++){
            if(max.compareTo(array[i]) < 0){
                max = array[i];
            }
        }
        return max;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Alg<Integer> alg1 = new Alg<>();
        Alg<Integer> alg2 = new Alg<>();
        System.out.println(alg1);
        System.out.println(alg2);
    }
}

编译并运行该代码,输出如下:

我们发现打印的内容中不存在<>,这说明它们被擦除了

六、通配符

1.什么是通配符:

? 用于在泛型的使用,即为通配符

2.通配符可以解决的泛型问题:

通配符是用来解决泛型无法协变的问题的,协变指的就是如果 Student 是 Person 的子类,那么 List<Student> 也应该是 List<Person> 的子类。但是泛型是不支持这样的父子类关系的

泛型 T 是确定的类型,一旦你传了我就定下来了,而通配符则更为灵活或者说是不确定,更多的是用于扩充参数的范围( 或者我们可以这样理解:泛型T就像是个变量,等着你将来传一个具体的类型,而通配符则是一种规定, 规定你能传哪些参数 ),如下代码所示:
class Alg3{
    public static<T> void print(ArrayList<T> list){
        for(T x:list){
            System.out.println(x);
        }
    }
    //此时代码的参数是T,此时的T一定是将来指定的一个泛型参数
    public static<T> void print2(ArrayList<?> list){
        for(Object x:list){
            System.out.println(x);
        }
    }
    //代码中使用了统配符,和代码1相比,此时传入printList2的,具体是什么数据类型,我们是不清楚的。这就是通配符。
}

3.通配符的上界

(Ⅰ)语法

与泛型上界类似,<? extends 上界>;如:<? extends Number>//可以传入的实参类型是Number或者Number的子类

举个例子:假设有如下关系:

Animal
Cat extends Animal
Dog extends Animal   根据该关系,写一个方法,打印一个存储了 Animal 或者 Animal 子类的 list
(1)
public static void print(List<Animal> list) { 
    ......
}
这样不可以解决问题,因为 print 的参数类型是 List<Animal> list ,就不能接收 List<Cat> list 。
(2)
public static <T extends Animal> void print2(List<T> list) { 
    for (T animal : list) { 
        System.out.println(animal); 
    } 
}
此时 T 类型是 Animal 的子类或者自己。该方法可以实现
(3)
public static void print3(List<? extends Animal> list) { 
    for (Animal ani : list) { 
        System.out.println(ani);//传过来是谁,就调用谁的toString方法 (发生了向上转型)
    } 
}
通配符实现,该方法也可以达到效果

区别如下:

①对于泛型实现的print2方法, <T extends Animal> 对T进行了限制,只能是Animal的子类 比如:传入Cat,那么类型就是Cat

②对于通配符实现的print3方法,首先不用再static后使用尖括号,其次相当于对Animal进行了规定,允许你传入Animal 的子类。具体哪个子类,此时并不清楚。比如:传入了Cat,实际上声明的类型是Animal,使用多态才能调用Cat的toString方法

(Ⅱ)通配符上界的父子类关系

// 需要使用通配符来确定父子类型
MyArrayList<? extends Number> 是 MyArrayList <Integer>或者 MyArrayList<Double>的父类类型
MyArrayList<?> 是 MyArrayList<? extends Number> 的父类型

(Ⅲ)通配符的上界的特点

通配符的上界不适合写入数据

public class TestDemo {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        ArrayList<Double> arrayList2 = new ArrayList<>();
        List<? extends Number> list = arrayList1;
        list.add(0,1);
        list.add(1,10.9);
    }
}

这样子写编译时是不会通过的,因为此时list的引用的子类对象有很多,再添加的时候,任何子类型都可以,为了安全,java不让这样进行添加操作。

(添加任何类型的数据都不可以,无法确定到底是哪种类型。)

但是通配符的上界适合读取数据:

public class TestDemo {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        ArrayList<Double> arrayList2 = new ArrayList<>();
        List<? extends Number> list = arrayList1;
        Number o = list.get(0);
        //Integer i = list.get(1);//error     类型太多,不一定是Integer(你怎么知道,获取的就是Integer呢?),所以读取时一定要用Number类型来接收
    }
}

4.通配符的下界

(Ⅰ)语法

<? super 下界> 

<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

(Ⅱ)通配符下界的父子类关系

MyArrayList<? super Integer> 是 MyArrayList<Integer>的父类类型
MyArrayList<?> 是 MyArrayList<? super Integer>的父类类型
(Ⅲ)通配符的下界的特点
public class TestDemo {
    public static void main(String[] args) {
        ArrayList<? super Person> arrayList1 = new ArrayList<>();
        //ArrayList<? super Person> arrayList2 = new ArrayList<>(student);//error  arrayList2只能引用Person或者Person父类类型的list
        arrayList1.add(new Person());//为添加元素的时候,我们知道list引用的对象肯定是Person或者Person的父类的集合,我们能够确定此时存储元素的最小粒度比Person小的都可以。
        //Student s = arrayList1.get(0);//error   读取的时候,我们不知道是读取到的是哪个子类
        Object s2 = arrayList1.get(0);//可以
        //Person s3 = arrayList1.get(0);//error
    }
}

通配符的下界适合写入数据,不适合读取数据

Java 泛型中的通配符详解 可以使用上界通配符来放宽对变量的限制。例如,你想编写一个方法,该方法适用于List, List 和 List;就可以通过使用上界通配符来实现这一点。声明一个上界通配符,需要使用通配符 ('?'),跟上 extends 关键字,然后再跟它的上界。比如,编写用于 Number 列表和 Number 子类型(如 Integer、Double 和 Float)的方法,可以指定 List 阅读详情

相关推荐

【玩转数据结构】数组——使用泛型

【玩转数据结构】数组——使用泛型 第一章 数组的基础构造以及属性 第二章 数组的基本操作:增删改查 第三章 使用泛型——增加数组的可能性 文章目录【玩转数据结构】数组——使用泛型本章导论一、泛型的定义二、修改我们的数组,使之可以承载泛型2.1首先从构造函数开始修改2.1 获取数组的固有属性2.3 增删改查第一步——增加(Create)2.4 增删改查第二步——查找(Retrieve)2.5 增删改查第三步——修改(Update)2.6 增删改查第四步——删除(Delete)三、测试四、加入自定义类,测试

weixin_43619860的博客 1844

泛型和通配符

泛型,泛型是如何编译的,泛型的上界,泛型方法,通配符,通配符的上界,通配符的下界

Fighting!!! 1060

java泛型常用通配符实例解析

主要介绍了java泛型常用通配符实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

泛型&通配符

一般的类和方法,只能使用具体的类型: 要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍泛型是在JDK1.5引入的新的语法,通俗的讲,泛型就是适用于许多类型。从代码上讲,就是对类型实现了参数化。方法限定符 返回值类型 方法名称(形参列表) {...

kim的博客 1767

GE Proficy Historian8.0历史数据库部署与配置全攻略

本文提供了GE Proficy Historian 8.0历史数据库的详细部署与配置指南。内容涵盖安装前的系统环境、权限与依赖检查,服务器安装的关键步骤与类型选择,采集器的安装配置与数据接入,以及客户端工具的使用与数据分析实战。旨在帮助用户规避常见陷阱,实现一次部署成功,构建稳定高效的工业数据归档平台。

silver的专栏 769

l0phtcrack 7(爆破管理员密码)使用教程

l0phtcrack7简称lc7,是爆破计算机管理员密码的软件,早期是网络安全管理员用来检测系统用户是否使用了不安全的密码,后被黑客用于用户口令破解 功能:该工具支持远程破解,理论上能破解所有密码,但对复杂度比较高的密码,破解时间很长 使用前提:1.登录了需要破解的计算机 2.知道需要破解的计算机的一个管理员的账户,密码 ** 也许你会疑惑,我都知道了一个管理员账户密码了,还要另外的管理员密码...

Xiongcanne的博客 2万+

泛型通配符详解

为什么要用通配符呢? 在java中,数组是可以协变的,比如dog extends Animal,那么Animal[] 与dog[]是兼容的。而集合是不能协变的,也就是说List<Animal>不是List<dog>的父类,这时候就可以用到通配符了。 一、基本概念: 在学习Java泛型的过程中, 通配符是较难理解的一部分. 主要有以下三类: 1. 无边界的通配符(Unb...

jarniyy的博客 5468

银河麒麟高级服务器操作系统V10SP2(X86)PXE无人值守批量部署实战指南

本文详细介绍了银河麒麟高级服务器操作系统V10SP2(X86)PXE无人值守批量部署的实战指南。通过PXE网络引导技术,实现全自动化、高效率的系统部署,特别适用于企业级数据中心和国产化替代项目。文章涵盖基础环境准备、关键服务配置、Kickstart高级定制及部署测试等核心内容,帮助用户快速掌握批量部署技巧。

weixin_42525637的博客 385

数据结构之泛型

上述代码改进: 定义泛型类的时候,可以传入多个参数: ✅关于泛型的注意点: 三,泛型的使用 3.1,语法 【类型推导:】 3.2,裸类型 四,泛型的编译 通过查看我们的字节码文件,可以看到我们的占位符T都会被替换成Object。那既然说将泛型T会替换成Object,那么就会有几个问题了? 程序运行结果:所以,最为正确的定义数组的方法如下: 程序运行截图:现在你再返回数组接收就没有任何的问题了,通过这种方式定义出来的数组它的类型就是指定了的,不再是Object类型的数组。我们泛型

qq_61688804的博客 1222

SAP FICO 银企直连

银企直联或者自动付款的目的是和银行做一个接口,把SAP中的到期应付款(也包括预付款)按照一定格式(银行要求的)在审批后发送给银行,请银行按照这个付款指定进行付款,并跟踪付款状态的过程,这个过程在SAP中如何实现呢?根据个人项目经验,客户需求可分为如下三种: 1. 第一种是完全不自动方式,仅批量生成付款凭证,实际的付款还是通过原来的流程执行,和银行没有任何接口; 2. 第二种是半自动方式,这种方式下需要按照银行的要求的格式生成付款条件,然后把付款文件下载下来,通过企业版的网银接口把付款文件进行上载,提交后

IamRunjiang的博客 9295

用yolov8训练自己的模型并调取摄像头实时检测,新手小白超友好教程!逻辑梳理,从0开始逐步实操❤

帮新手小白学会用yolov8,包含多篇高质量博客整理

Lhhhhds的博客 2942

泛型,数据结构,集合

介绍了泛型,数据结构和集合的内容

m0_69266818的博客 1111

SAP 消息号T-CODE

SAP消息号修改汇总 确实有很多消息是可以修改的 FI: oBA5|oFMG|oFPM MM: oMRM|oKZZ|oMT4|oMCQ|o04C| SD: oVAH(V4)|oVM1(VL) CO:  oPR4_ACT|oPR4_CK|oPR4_CKML|oPR4_CKPF|oPR4_KKA|oPR4_KKP|oPR4_KKS| oPR4_KKS1|oPR4_P

heng0757的专栏 1万+

数据结构、泛型

一. 数据结构 数据结构 : 数据用什么样的方式组合在一起。 1.1 常见数据结构 数据存储的常用结构有:栈、队列、数组、链表和红黑树。 1.1.1 栈 stack,又称堆栈,它是运算受限的线性表,其限制是仅允许在标的一端进行插入和删除操作,不允许在其他任何位置进行添加、查找、删除等操作。 特点: 1.先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。 例如,子弹压进弹夹...

weixin_44079478的博客 446

AMDGPU驱动中Doorbell与Event机制简要对比

摘要:AMDGpu驱动中,Doorbell和Event是两种异步通知机制。Doorbell是CPU→GPU的单向硬件通知,通过写MMIO寄存器触发GPU拉取任务,延迟低且无需内核介入,适用于队列任务提交。Event是GPU→CPU的双向同步通知,基于中断和内核事件对象,支持阻塞等待,用于任务完成或异常上报。核心区别在于方向、用途和实现方式:Doorbell侧重任务触发,Event侧重状态反馈。两者配合实现高效的任务下发与完成通知流程。

图形/计算GPU的驱动与虚拟化技术分享园地 1865

[Bug已解决] CUDA error 尽管 CUDA 可用且 GPU 受支持-通用排查 RuntimeError 解决方案

[Bug已解决] CUDA error 尽管 CUDA 可用且 GPU 受支持-通用排查 RuntimeError 解决方案

一键难忘的博客 2416

【Java数据结构】—泛型编程,让我们一起领略泛型的魅力

【Java数据结构】—泛型编程,让我们一起领略泛型编程的魅力吧~~~

一年,我很需要这一年 1402

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Java 数据结构 泛型

MyArray< Integer> l1, 正常,Integer是Number的子类。MyArray< String > l2,报错,String不是Number的子类。泛型的上界指的时它本身(Number)和它的子类。

的博客 532

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【用Java学习数据结构系列】初识泛型

好久没有更新文章了,大概断更了20天,想着今天就写一下文章吧!最近也是又温习了一下数据结构,其实之前我写过关于数据结构的一个专栏那个专栏是写了顺序表,链表,栈和队列,但是那时是用C语言实现的,虽然数据结构不局限于语言,但是总归在语言的使用上有所不同,毕竟面向不同,一个是面向过程的C语言,一个是面向对象的Java。所以这次我打算起一个数据结构的Java专栏,当然由于之前已经写过有些地方会写得简洁一点,模糊的话大家可以去看一下前面得文章哦。今天是关于泛型的哦!

2302_81249757的博客 3861

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

[ 数据结构 ] 泛型 (上)

本文介绍了Java包装类和泛型的核心概念。包装类部分详细讲解了基本数据类型的包装类、装箱拆箱操作、自动转换机制及Integer缓存机制。泛型部分重点阐述了泛型类定义语法、类型推导、类型擦除机制和通配符使用(包括无界、上界和下界通配符),并提供了泛型方法的定义示例。全文通过代码实例演示了包装类和泛型在实际编程中的应用,帮助理解Java类型系统的特性和实现机制。

Boop_wu的博客 849

【Go 快速入门】泛型 | 类型约束 | 泛型接口 | 通用数据结构

【Go 快速入门】泛型 | 类型约束 | 泛型接口 | 通用数据结构

Cauchy的博客 2200

【AI驱动的泛型数据结构:智能计算的核心】

泛型(可将类型作为参数进行传递)的意义: 1.在编译的时候检查数据类型是否正确。 2.在编译时期辅助进行类型转换。

“路漫漫其修远兮,吾将上下求索。” 1948

数据结构:泛型

数据结构:泛型

gdswsj的博客 777

【无标题】Java数据结构基础和泛型

栈结构先进后出队列结构先进先出数组结构查询快、增删慢链表结构(每一个节点都是独立的对象,在内存中是不连续的,每个节点包含数值值和下一个节点的地址。)(还有双链表,有前后地址值,首尾操作极快)查询慢、增删快核心步骤:创建ArrayList对象的时候,他在底层先创建了一个长度为0的数组。数组名字:elementDate,定义变量size。size这个变量有两层含义: ①:元素的个数,也就是集合的长度 ②:下一个元素的存入位置添加元素,添加完毕后,size++扩容时机一:当存满时候,会创建一个新的数组,新数组的长

qq_63880346的博客 1409

Java数据结构(泛型)

一般的类和方法,只能使用具体的类型: 要么是基本类型,要么是自定义的类。如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大。

qq_40599849的博客 840

数据结构-泛型

1. 泛型是将数据类型参数化,进行传递2. 使用 <T> 表示当前类是一个泛型类。3. 泛型目前为止的优点:数据类型参数化,编译时自动进行类型检查和转换。

M7777777777777的博客 608
上一篇: 数据结构之排序
下一篇: 数据结构之Map和Set总结
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值