Java数据结构2

已于 2024-06-13 11:26:13 修改
阅读量957 收藏 18
点赞数 12
分类专栏： 数据结构 文章标签： java 数据结构 开发语言
于 2024-06-13 11:25:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuiluoi/article/details/139649654
版权

1. 什么是泛型

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

泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数
化（将int，char，byte传过去），意味着可以传指定的类型参数，那么如何实现呢？

2. 引出泛型

首先我们想到的是Object类


class MyArray {
    public Object[] array = new Object[10];
    public void setValue(int pos, Object x) {
        array[pos] = x;
    }

    public Object getVal(int pos) {
        return array[pos];
    }
}


public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setValue(0, 10);
        myArray.setValue(1, 8);
        myArray.setValue(2, "hello");

        //String s = myArray.getVal(2);
        String s = (String) myArray.getVal(2);
        System.out.println(s);
    }
}

2号下标本身就是字符串，但是确编译报错。必须进行强制类型转换

Object不能传参，我们期望的是可以存指定类型的数据，显然这不能满足这一要求，他只是能接收任何类型的数据

我们想要的是给你川什么类型，你就能装什么类型

2.1 语法

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}

class MyArray<T> {
    public Object[] array = new Object[10];
    public void setValue(int pos, T x) {
        array[pos] = x;
    }

    public T getVal(int pos) {
        return (T)array[pos];
    }
}


public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        myArray.setValue(0, 10);
        myArray.setValue(1, 8);
        //myArray.setValue(2, "hello"); 报错了

        //String s = myArray.getVal(2);
        int ret = myArray.getVal(1);
        System.out.println(ret);
    }
}
  1. 每次存储数据的时候，会检查你存入的数据是不是和你指定的类型一样
  2. 此时 r e t ret ret不需要进行强制类型转换，因为我们在放的时候已经严格检查了

**所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。**此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型

运行的时候没有泛型这样的概念

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

  1. 类名后的 代表占位符，表示当前类是一个泛型类
    了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：

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

  2. 不能new泛型类型的数组

    T[] ts = new T[5];//是不对的

  3. 注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

    MyArray<Integer> list = new MyArray<Integer>();

2.2 类型推导(Type Inference)

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

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

3. 裸类型(Raw Type)

3.1 说明

裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型

MyArray list = new MyArray();

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

小结：

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

4. 泛型如何编译的

4.1 擦除机制

那么，泛型到底是怎么编译的？

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

Compiled from "Test.java"
class MyArray<T> {
  public java.lang.Object[] array;

  MyArray();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: bipush        10
       7: anewarray     #2                  // class java/lang/Object
      10: putfield      #7                  // Field array:[Ljava/lang/Object;
      13: return

  public void setValue(int, T);
    Code:
       0: aload_0
       1: getfield      #7                  // Field array:[Ljava/lang/Object;
       4: iload_1
       5: aload_2
       6: aastore
       7: return

  public T getVal(int);
    Code:
       0: aload_0
       1: getfield      #7                  // Field array:[Ljava/lang/Object;
       4: iload_1
       5: aaload
       6: areturn
}

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制

Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息

提出问题：

  1. 那为什么，T[] ts = new T[5]; 是不对的，编译的时候，替换为Object，不是相当于：Object[] ts = new
    Object[5]吗？
  2. 类型擦除，一定是把T变成Object吗？

4.2 为什么不能实例化泛型类型数组

class MyArray<T> {
    public T[] array = (T[])new Object[10];
    public void setValue(int pos, T x) {
        array[pos] = x;
    }

    public T getVal(int pos) {
        return (T)array[pos];
    }

    public T[] getArray() {
        return array;
    }
}


public class Test {
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>();
        String[] strings = myArray.getArray();
    }
}
/*
Exception in thread "main" java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.lang.String; ([Ljava.lang.Object; and [Ljava.lang.String; are in module java.base of loader 'bootstrap')
	at Test.main(Test.java:21) 报错
*/

原因：

Object类是所有类的父类

但是，Object[] 不是所有数组的父类

Object[] 不是String[]的父类

无法进行类型转换，强制类型转换也不行

5. 泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束

5.1 语法

class 泛型类名称<类型形参 extends 类型边界> {
...
}

5.2 示例

public class MyArray<E extends Number> {
...
}

只接受 Number 的子类型作为 E 的类型实参，或者是Number自己

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

error: type argument String is not within bounds of type-variable E
MyArrayList<String> l2;
^
where E is a type-variable:
E extends Number declared in class MyArrayList

5.3 复杂示例

public class MyArray<E extends Comparable<E>> {
...
}

E必须是实现了Comparable接口的

class Alg<T extends Comparable<T>> {
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0){
                max = array[i];
            }
        }
        return max;
    }
}

只有实现了Comparable接口才能比较，因为T（包装类）是引用数据类型

6. 泛型方法

6.1 语法

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

6.2 示例

class Alg {
    public <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i].compareTo(max) > 0){
                max = array[i];
            }
        }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Alg alg = new Alg();
        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
        //                    不使用类型推导     使用类型推导
        Integer x = alg.<Integer>findMax(array);//<Integer>可以省略
        System.out.println(x);
    }
}

7. 什么是List

在集合框架中，List是一个接口，继承自Collection

在这里插入图片描述

Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：

在这里插入图片描述

Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：

在这里插入图片描述

站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删
改查以及变量等操作

8. List常见接口介绍

List中提供了好的方法，具体如下：

在这里插入图片描述

虽然方法比较多，但是常用方法如下：

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)截取部分 list

9. List的使用

注意：List是个接口，并不能直接用来实例化
如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和LinkedList都实现了List接口

10. 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储

在这里插入图片描述

11. 顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成
数据的增删查改

11.1 接口的实现

import  java.util.Arrays;

public class MyArraylist {
    public int[] elem;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArraylist() {
        this.elem = new int[DEFAULT_SIZE];
    }

    /**
     * 打印顺序表:
     *   根据usedSize判断即可
     */
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        if (isFull()){
            this.elem = Arrays.copyOf(this.elem, this.elem.length*2);
        }
        this.elem[usedSize] = data;
        this.usedSize++;
    }

    /**
     * 判断当前的顺序表是不是满的！
     * @return true:满   false代表空
     */
    public boolean isFull() {
        return this.usedSize >= this.elem.length;
    }


    private void checkPosInAdd(int pos) throws PosNotLegalException{
        if (pos < 0 || pos > this.usedSize) {
            throw new PosNotLegalException("pos位置不合法！");

        }
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        try {
            checkPosInAdd(pos);
        } catch (PosNotLegalException e){
            e.printStackTrace();
        }
        if (isFull()){
            this.elem = Arrays.copyOf(this.elem, this.elem.length*2);
        }
        for (int i = this.usedSize-1; i >= pos ; i--) {
            this.elem[i+1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;

    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

    private void checkPosInGetAndSet(int pos) throws PosNotLegalException{
        if (pos < 0 || pos >= this.usedSize) {
            throw new PosNotLegalException("GetAndSet的pos位置不合法！");

        }
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        try {
            checkPosInGetAndSet(pos);
        } catch (PosNotLegalException e){
            e.printStackTrace();
        }
        return this.elem[pos];
    }

    private boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        }
        return false;
    }
    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, int value) {
        try {
            checkPosInGetAndSet(pos);
        } catch (PosNotLegalException e){
            e.printStackTrace();
        }
        this.elem[pos] = value;
    }

    /**
     * 删除第一次出现的关键字key
     * @param key
     */
    public void remove(int key) {
        int pos = indexOf(key);
        if (pos == -1) {
            return;
        }
        for (int i = pos; i < this.usedSize-1; i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
    }

    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }

    // 清空顺序表
    public void clear() {
        this.usedSize = 0;
    }
}
zhuiluoi
关注
专栏目录
Java数据结构01——栈
qq_64037280的博客
02-04 4120
java java数据结构 栈
Java数据结构—树
Green_756的博客
09-05 3950
java、数据结构、树
Java中常用数据结构及方法
Liususiu的秃头日记
12-18 2909
记录总结Java中常用的结构和方法。
java数据结构——树的实现
Ez4Sterben的博客
03-27 5965
一、为什么需要树这样数据结构、 1.数组存储方式分析 优点：通过下表方式访问元素，速度快。对于有序数组没还可以使用二分查找提高检索速度。 缺点：如果要检索某一个具体值，效率比较低下 2.链式存储方式分析 优点：在一定程度上对数组存储方式进行优化（比如插入一个节点，只需要将插入节点，链接到链表当中可删除的效率也很好）。 缺点：在进行检索时，效率仍然比较低，比如（检索某个数值，需要从头结点开始遍历） 3.树存储方式分析 能提高数据存储，读取的效率，比如利用二叉排序树，既可以保证数据的检索速度。同时也可以保证数据
Java数据结构与算法——队列
★★光亭★★
03-13 5360
Java数据结构与算法——队列
Java数据结构与算法——双向链表
★★光亭★★
03-11 6147
Java数据结构与算法——双向链表
数据结构与算法（java版）
Y2483490891的博客
12-25 1694
数据结构是指在计算机中组织和存储数据的方式。它关注数据的逻辑关系、操作和存储方式，以及如何有效地访问和修改数据。常见的数据结构包括数组、链表、栈、队列、树、图等。算法是解决问题的一系列步骤或规则。它描述了如何通过输入数据来产生所需的输出结果。算法可以用来执行各种计算任务，如排序、搜索、图形处理等。好的算法应该具有正确性、可读性、高效性和健壮性。数据结构和算法之间存在密切的关系。选择合适的数据结构可以提高算法的效率，而好的算法可以更好地利用数据结构的优势。
JAVA基本数据结构
08-27 1万+
名称 底层结构 线性安全 有序性 值唯一性 Vector 数组 安全 有 不 HashTable 数组+链表 安全 无 不为空，唯一 LinkedList 双...
Java数据结构————List
qq_45559559的博客
09-16 3090
在集合框架中，List是一个接口，继承自Collection，并不能直接用来实例化。站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作。Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，
Java数据结构及原理实现
热门推荐
jackhuang17的博客
07-21 1万+
程序设计主要是数据结构+算法，而数据结构在面向对象思维里是“容器”的意思，数据结构主要负责数据的添加，删除，修改，查找及对数据的其他操作。编程里面对着不同问题场景，选择哪种数据结构进行操作就非常重要。试想：如果谷歌是以数组来存储数据的话，还会有那么快的搜索速度？所以下面就简单介绍java数据结构的体系和部分原理实现java集合体系结构图集合父接口Collection，Map和集合工具类Collect
Java 数据结构
01-03
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 枚举（Enumeration） 位集合（BitSet） 向量（Vector） 栈（Stack） 字典（Dictionary） 哈希表（Hashtable） 属性...
Java 数据结构详细教程
12-21
JavaJava 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java ...
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
java 数据结构 PPT课件
07-25
第2章 线性表(java版） 第3章 栈与队列(java版） 第4章 串与数组(Java版) 第5章 树与二叉树(java版） 第6章 图(Java版) 第7章 排序(Java版) 第8章 查找(Java版)
Java版数据结构与算法
06-26
该资源包含使用Java实现的绝大部分基础算法和数据结构，包含视频教程，使得算法学习更加容易，该资源从网络收集回来，仅供学习使用
工厂模式的介绍及实现
户伟伟的博客
09-25 109
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1063
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 354
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 877
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值