Java的集合框架和泛型

news2024/12/24 10:25:21

文章目录

  • 集合框架
    • 什么是集合框架
      • 类和接口总览
    • 集合框架的重要性
    • 背后所涉及的数据结构以及算法
      • 什么是数据结构
      • 容器背后对应的数据结构
      • 什么是算法
  • 包装类
    • 基本数据类型和对应的包装类
    • 装箱和拆箱
    • 自动装箱和自动拆箱
  • 泛型
    • 什么是泛型
    • 引出泛型
    • 语法
    • 泛型类
    • 泛型的上界(没有下界)
    • 泛型方法
    • 裸类型(Raw Type)
    • 小结
    • 泛型如何编译的
      • 擦除机制
      • 为什么不能实例化泛型类型数组
    • 通配符
      • 通配符解决什么问题
      • 通配符上界
      • 通配符下界

集合框架

什么是集合框架

Java 集合框架 (Java Collection Framework )，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes 。

其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理 manipulate ，即平时我们俗称的增删查改 CRUD 。

类和接口总览

在这里插入图片描述

集合框架的重要性

  1. 开发中的使用
  • 使用成熟的集合框架，有助于我们便捷、快速的写出高效、稳定的代码
  • 学习背后的数据结构知识，有助于我们理解各个集合的优缺点及使用场景
  1. 笔试及面试题

腾讯-Java后台开发面经

  1. HashMap 了解不，介绍一下，如果一个对象为 key 时，hashCode 和 equals 方法的用法要注意什么？
  2. HashSet 和 HashMap 的区别是什么？
  3. HashMap 是线程安全的么？那需要线程安全需要用到什么？

阿里巴巴-Java后台开发面经

  1. ArrayList 和 LinkedList 的区别是什么？
  2. 有了解过 HashMap 的具体实现么？
  3. HashMap 和 ConcurrentHashMap 哪个效率更高？

今日头条-Java后台开发面经

  1. 编程题：判断一个链表是否是一个回文链表。
  2. Redis 的 zset 类型对应到 java 语言中大致是什么类型？
  3. hashCode 主要是用来做什么用的？

背后所涉及的数据结构以及算法

什么是数据结构

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合

容器背后对应的数据结构

每个容器其实都是对某种特定数据结构的封装

  1. Collection：是一个接口，包含了大部分容器常用的一些方法
  2. List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法
    ArrayList：实现了List接口，底层为动态类型顺序表
    LinkedList：实现了List接口，底层为双向链表
  3. Stack：底层是栈，栈是一种特殊的顺序表
  4. Queue：底层是队列，队列是一种特殊的顺序表
  5. Deque：是一个接口
  6. Set：集合，是一个接口，里面放置的是K模型
    HashSet：底层为哈希桶，查询的时间复杂度为O(1)
    TreeSet：底层为红黑树，查询的时间复杂度为O( l o g 2 N log_2N log2​N ),关于key有序的
  7. Map：映射，是一个接口,里面存储的是K-V模型的键值对
    HashMap：底层为哈希桶，查询时间复杂度为O(1)
    TreeMap：底层为红黑树，查询的时间复杂度为O( l o g 2 N log_2N log2​N )，关于key有序

相关java知识

  1. 泛型 (Generic)
  2. 自动装箱 (autobox) 和自动拆箱 (autounbox)
  3. Object 的 equals 方法
  4. Comparable 和 Comparator 接口

Comparable和Comparator区别参考此文

  • 可以把Comparable理解为内部比较器，而Comparator是外部比较器。
  • Comparable和Comparator都可以用来进行比较、排序。
  • 二者各有优缺点，用Comparable 简单， 实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

什么是算法

算法(Algorithm)就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

基本数据类型和对应的包装类

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

装箱和拆箱

int i = 10;
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

自动装箱和自动拆箱

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

【面试题】
下列代码输出什么，为什么？

public static void main(String[] args) {
	Integer a = 127;
	Integer b = 127;
	Integer c = 128;
	Integer d = 128;
	System.out.println(a == b);
	System.out.println(c == d);
}

在这里插入图片描述
这里只进行了装箱,我们可以打开反汇编看看自动装箱调用了哪个方法

找到目录下的字节码文件(idea是在out目录中)
在上面输入cmd回车
在这里插入图片描述

查看汇编的命令：javap -c

在这里插入图片描述
问题出在Integer.valueOf()上,我们看下源码
在这里插入图片描述
我们发现如果参数 >=IntegerCache.low 并且 <= IntegerCache.high时
返回IntegerCache.cache这个缓存数组中的一个值
在数组中的值没有new一个对象,是一样的
在这里插入图片描述

泛型

什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。这种刻板的限制对代码的束缚就会很大。—— 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

引出泛型

思路：

  1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
  2. 所有类的父类，默认为Object类。数组是否可以创建为Object?

代码示例：

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);//整型可以存放
        myArray.setVal(1,"汤姆猫");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错
        System.out.println(ret);
    }
}

问题：

  1. Object任何类型数据都可以存放
  2. 1下标对应的值就是字符串，但是取出来会编译报错。必须进行强制类型转换

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型, 而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

语法

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

class ClassName<T1, T2, ..., Tn> {
}

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

class ClassName<T1, T2, ..., Tn> extends ParentClass<T1,..., Tn> {
	// 可以只使用部分类型参数
}

上述代码进行改写如下：

class MyArray<T> {
    public T[] array = (T[])new Object[10];//1
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();//2
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        int ret = myArray.getPos(1);//3
        System.out.println(ret);
        myArray.setVal(2,"灰太狼");//4:编译报错
    }
}

代码解释：

  1. 类名后的 < T > 代表占位符，表示当前类是一个泛型类

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

  • E 表示 Element
  • K 表示 Key
  • V 表示 Value
  • N 表示 Number
  • T 表示 Type
  • S, U, V 等等 —— 第二、第三、第四个类型
  1. 注释1处，不能new泛型类型的数组
T[] ts = new T[5];//是不对的

因为泛型是编译时期的机制,也意味着运行的时候没有泛型的概念,JVM没有泛型的概念

  1. 注释2处，类后面加入 < Integer > 指定当前类型
  2. 注释3处，不需要进行强制类型转换
  3. 注释4处，代码编译报错，因为在注释2处指定类为Integer，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。

泛型类

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

示例

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

注意：泛型的参数只能是类，所有的基本数据类型必须使用包装类！

MyArray<int> list = new MyArray<>()//是不对的

类型推导(Type Inference)

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

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

泛型的上界(没有下界)

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

语法

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

示例1

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

只接受 Number 的子类型或者Number本身作为 E 的类型实参

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

在这里插入图片描述
PS:如果没有指定类型边界 ，可以视为 E extends Object
示例2

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

E必须是实现了Comparable接口的
引用类不能直接比较,需要实现接口

class Person implements Comparable<Person>{
    @Override
    public int compareTo(Person o) {
        return 0;
    }
}
class Alg<T extends Comparable<T>> {
    public T findMaxVal(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) {
        Integer[] array = {1,4,3,8,7,5};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMaxVal(array));
        Alg<Person> alg2 = new Alg<>();
    }
}
  • 类型实参T实例化为自定义类Person时,需要实现Comparable< T >或Comparator< T >接口
  • 而Integer类本身就实现了Comparable接口,不用我们自己重写

泛型方法

语法

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

举个栗子

class Alg {
    public<T extends Comparable<T>> T findMaxVal(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,4,3,8,7,5};
        //不使用类型推导
        alg.<Integer>findMaxVal(array);
        //类型自动推导
        alg.findMaxVal(array);
    }
}

可以写成静态方法,这样不用实例化类对象也能使用

class Alg {
    public static <T extends Comparable<T>> T findMaxVal(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) {
        Integer[] array = {1,4,3,8,7,5};
        //不使用类型推导
        Alg.<Integer>findMaxVal(array);
        //类型自动推导
        Alg.findMaxVal(array);
    }
}

裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参

MyArray list = new MyArray();

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

小结

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

泛型如何编译的

擦除机制

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

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;
    }
}

在这里插入图片描述

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
有关泛型擦除机制的文章介绍

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

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 T[] getArray() {
        return array;
    }
}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>();
        Integer[] arr = myArray1.getArray();
    }
}

在这里插入图片描述
将Object[]分配给Integer[]引用，程序报错的原因：

  • Object可以强转为Integer,因为有继承关系,是确定的,而数组是没有继承关系的,是不确定的(可能存在其他类型的元素)
  • 返回的Object数组里面，存放的可能是其他数据类型，可能是String，可能是自定义类Person，运行的时候，直接转给Integer类型的数组，编译器认为是不安全的。

正确的方式：

import java.lang.reflect.Array;
class MyArray<T> {
    public T[] array;
    public MyArray() {
    }
    /**
     * 通过反射创建，指定类型的数组
     * @param clazz
     * @param capacity
     */
    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 class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);
        Integer[] integers = myArray1.getArray();
    }
}

反射我也不太会,目前还是用

class MyArray<T> {
    public Object[] array = new Object[10];
    public T getPos(int pos) {
        return (T)array[pos];
    }
    public void setVal(int pos,T val) {
        array[pos] = val;
    }
}

通配符

? 用在泛型，即为通配符

通配符解决什么问题

示例:

class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test {
    public static void main(String[] args) {
        Message<String> message = new Message<>() ;
        message.setMessage("光头强");
        fun(message);
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

以上程序会带来新的问题，如果泛型的类型不是String，而是Integer.

public class Test {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(99);
        fun(message); // 出现错误，只能接收String
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

解决方案：可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理

public class Test {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(55);
        fun(message);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<?> temp){
    	//temp.setMessage(100); 无法修改！
        System.out.println(temp.getMessage());
    }
}

在"?"的基础上又产生了两个子通配符：

  • ? extends 类：设置通配符上限
  • ? super 类：设置通配符下限

通配符上界

语法：

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Message<T> { // 设置泛型
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class Test {
    public static void main(String[] args) {
        Message<Apple> message = new Message<>() ;
        message.setMessage(new Apple());
        fun(message);
        Message<Banana> message2 = new Message<>() ;
        message2.setMessage(new Banana());
        fun(message2);
    }
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void fun(Message<? extends Fruit> temp){
        //temp.setMessage(new Banana()); //仍然无法修改！
        //temp.setMessage(new Apple()); //仍然无法修改！
        System.out.println(temp.getMessage());
        Fruit fruit = temp.getMessage();
        //Apple apple = temp.getMessage();//报错,因为不知道是哪个子类,但是父类可以接收
    }
}

无法在fun函数中对temp进行修改，因为temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定。所以会报错！但是可以获取元素。

通配符的上界，不能进行写入数据，只能进行读取数据

通配符下界

语法:

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

示例

class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Plate<T> {
    private T plate ;
    public T getPlate() {
        return plate;
    }
    public void setPlate(T plate) {
        this.plate = plate;
    }
}
public class Test {
    public static void main(String[] args) {
        Plate<Fruit> plate1 = new Plate<>();
        plate1.setPlate(new Fruit());
        fun(plate1);
        Plate<Food> plate2 = new Plate<>();
        plate2.setPlate(new Food());
        fun(plate2);
    }
    public static void fun(Plate<? super Fruit> temp){
        // 此时可以修改！！添加的是Fruit 或者Fruit的子类
        temp.setPlate(new Apple());//这个是Fruit的子类
        temp.setPlate(new Fruit());//这个是Fruit的本身
        //Fruit fruit = temp.getPlate(); 不能接收，这里无法确定是哪个父类
        System.out.println(temp.getPlate());//只能直接输出
    }
}

通配符的下界，不能进行读取数据，只能写入数据。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1452127.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Vue2学习第三天

Vue2学习第三天

Vue2 学习第三天 1. 计算属性 computed 计算属性实现 定义&#xff1a;要用的属性不存在&#xff0c;要通过已有属性计算得来。 原理&#xff1a;底层借助了Objcet.defineproperty方法提供的getter和setter。 get函数什么时候执行&#xff1f; 初次读取时会执行一次。当依赖…
阅读更多...
知识图谱：py2neo将csv文件导入neo4j

知识图谱：py2neo将csv文件导入neo4j

文章目录 安装py2neo创建节点-连线关系图导入csv文件删除重复节点并连接边 安装py2neo 安装python中的neo4j操作库&#xff1a;pip install py2neo 安装py2neo后我们可以使用其中的函数对neo4j进行操作。 图数据库Neo4j中最重要的就是结点和边&#xff08;关系&#xff09;&a…
阅读更多...
数字经济政策 | ZF工作报告-60个文本词频

数字经济政策 | ZF工作报告-60个文本词频

根据各省政府工作报告&#xff0c;参考金灿阳(2022)和陶长琪(2022)&#xff0c;借助Python软件&#xff0c;统计数字经济相关的关键词词频&#xff0c;分别记为数字经济政策词频A、数字经济政策词频B A文献参考 B文献参考 年度趋势 一、数据介绍 数据名称&#xff1a; 政府工…
阅读更多...
OpenAI首个文生视频模型亮相，你觉得咋样？

OpenAI首个文生视频模型亮相，你觉得咋样？

2月16日凌晨&#xff0c;OpenAI再次扔出一枚深水炸弹&#xff0c;发布了首个文生视频模型Sora。据介绍&#xff0c;Sora可以直接输出长达60秒的视频&#xff0c;并且包含高度细致的背景、复杂的多角度镜头&#xff0c;以及富有情感的多个角色。 目前官网上已经更新了48个视频d…
阅读更多...
QGIS004:【08图层工具箱】-导出到电子表格、提取图层范围

QGIS004:【08图层工具箱】-导出到电子表格、提取图层范围

摘要&#xff1a;QGIS图层工具箱常用工具有导出到电子表格、提取图层范围等选项&#xff0c;本文介绍各选项的基本操作。 实验数据&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1ZK4_ShrQ5BsbyWfJ6fVW4A?pwdpiap 提取码&#xff1a;piap 一、导出到电子表格 工具…
阅读更多...
集团企业大数据应用：突破痛点，释放数据价值

集团企业大数据应用：突破痛点，释放数据价值

在数字经济日益崛起的背景下&#xff0c;集团企业以其管理范围广泛、业务领域多元化和分支机构复杂化的特性&#xff0c;在市场竞争中扮演着重要角色。为了维持和提升这种竞争力&#xff0c;大数据应用成为了集团企业不可或缺的战略工具。然而&#xff0c;在实际应用中&#xf…
阅读更多...
图表示学习 Graph Representation Learning chapter1 引言

图表示学习 Graph Representation Learning chapter1 引言

图表示学习 Graph Representation Learning chapter1 引言 前言1.1图的定义1.1.1多关系图1.1.2特征信息 1.2机器学习在图中的应用1.2.1 节点分类1.2.2 关系预测1.2.3 聚类和组织检测1.2.4 图分类、回归、聚类 前言 虽然我并不研究图神经网络&#xff0c;但是我认为图高效的表示…
阅读更多...
javascript+css+html购物车案例

javascript+css+html购物车案例

javascript代码部分主要实现三部分功能 1、商品数量增加&#xff08;减少&#xff09;同时小计增加&#xff08;减少&#xff09; 这部分主要是通过for循环给增加&#xff08;减少&#xff09;按钮绑定点击事件 1&#xff09;点击后计数器自增&#xff08;自减&#xff09;…
阅读更多...
【深度学习：开源数据注释】开源数据注释完整指南

【深度学习：开源数据注释】开源数据注释完整指南

【深度学习&#xff1a;Automated Data Annotation】开源数据注释完整指南 什么是开源数据标注工具&#xff1f;您会使用开源标签工具做什么&#xff1f;主要的开源数据标注工具有哪些&#xff1f;CVATMONAI LabelLabelMeRIL-ContourSefexa 使用开源注释工具的优点和缺点是什么…
阅读更多...
Sora：将文本转化为视频的创新之旅

Sora：将文本转化为视频的创新之旅

一.能力 我们正致力于让 AI 掌握理解和模拟物理世界动态的能力&#xff0c;旨在培养能够协助人们解决现实世界互动问题的模型。 介绍 Sora——我们开发的文本到视频转换模型。Sora 能够根据用户的输入提示&#xff0c;生成最长达一分钟的高质量视频内容。 目前&#xff0c;Sora…
阅读更多...
Gitee入门之工具的安装

Gitee入门之工具的安装

一、gitee是什么&#xff1f; Gitee&#xff08;码云&#xff09;是由开源中国社区在2013年推出的一个基于Git的代码托管平台&#xff0c;它提供中国本土化的代码托管服务。它旨在为个人、团队和企业提供稳定、高效、安全的云端软件开发协作平台&#xff0c;具备代码质量分析、…
阅读更多...
揭开Markdown的秘籍：引用|代码块|超链接

揭开Markdown的秘籍：引用|代码块|超链接

&#x1f308;个人主页&#xff1a;聆风吟 &#x1f525;系列专栏&#xff1a;Markdown指南、网络奇遇记 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 &#x1f4cb;前言一. ⛳️Markdown 引用1.1 &#x1f514;引用1.2 &#x1f514;嵌套引用1.3 &…
阅读更多...
【Python---六大数据结构】

【Python---六大数据结构】

&#x1f680; 作者 &#xff1a;“码上有前” &#x1f680; 文章简介 &#xff1a;Python &#x1f680; 欢迎小伙伴们 点赞&#x1f44d;、收藏⭐、留言&#x1f4ac; Python---六大数据结构 往期内容前言概述一下可变与不可变 Number四种不同的数值类型Number类型的创建i…
阅读更多...
【Spring篇】Spring的创建与使用

【Spring篇】Spring的创建与使用

目录 一 . 创建Spring项目 二 . Bean 对象存放到 Spring 三 . 从Spring中读到Bean 经过前⾯的学习我们已经知道了&#xff0c;Spring 就是⼀个包含了众多⼯具⽅法的 IoC 容器。既然是容器那么 它就具备两个最基本的功能&#xff1a; 将对象存储到容器&#xff08;Spring&am…
阅读更多...
optee CA/TA flow

optee CA/TA flow

以 TEEC_InvokeCommand 为例 CA—normal world EL0 //imx-optee-client\libteec\src\tee_client_api.c TEEC_InvokeCommandioctl(session->ctx->fd, TEE_IOC_INVOKE, &buf_data)通过syscall陷入内核态driver linux driver—normal world EL1 tee_ioctl // drive…
阅读更多...
一些方便的记录

一些方便的记录

如何在ubutun上安装qq 在QQ官网选择QQ Linux版本&#xff0c;然后选择X86下的deb类型文件进行下载 sudo dpkg -i linuxqq_3.2.5-21453_amd64.deb64 根据下载的版本不同对其进行更改 运行上述命令后显示应用程序可以看到安装后的QQ面板如何卸载安装在gnuradio的lora组件 - 进入…
阅读更多...
php基础学习之可变函数（web渗透测试关键字绕过rce和回调函数）

php基础学习之可变函数（web渗透测试关键字绕过rce和回调函数）

可变函数 看可变函数的知识点之前&#xff0c;蒟蒻博主建议你先去看看php的可变变量&#xff0c;会更加方便理解&#xff0c;在本篇博客中的第五块知识点->php基础学习之变量-CSDN博客 描述 当一个变量所保存的值刚好是一个函数的名字&#xff08;由函数命名规则可知该值必…
阅读更多...
Eclipse Version: 2023-03 (4.27.0) JDK19 Tomcat10.2

Eclipse Version: 2023-03 (4.27.0) JDK19 Tomcat10.2

Eclipse Version: 2023-03 (4.27.0) JDK19 Tomcat10.2
阅读更多...
电子元器件基础5---二极管

电子元器件基础5---二极管

除了电阻、电容和电感等线性元器件之外，还有二极管、三极管这些常用的非线性器件广泛应用于日常生活中。那么今天我们来介绍以下二极管这一常用的电子元器件。 一、二极管概念 二极管是用半导体材料(硅、硒、锗等)制成的一种电子器件 。二极管有两个电极，正极，又叫阳极；负…
阅读更多...
07-k8s中secret资源02-玩转secret

07-k8s中secret资源02-玩转secret

一、回顾secret资源的简单实用 第一步&#xff1a;将想要的数据信息【key&#xff1a;value】中的value值&#xff0c;使用base64编码后&#xff0c;写入secret资源清单中&#xff1b; 第二步&#xff1a;创建secret资源&#xff1b; 第三步&#xff1a;pod资源引用secret资源&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023