详解Redisson

第1章：Redisson简介

大家好，我是小黑，咱们今天来聊聊Redisson，Redisson不只是简单地对Redis进行了封装，它还提供了一系列高级的分布式Java数据结构，像是分布式锁、原子长整型这种。

首先，Redisson的核心特点是什么呢？它提供了对Redis的各种操作的高层封装，这让咱们在使用Redis时更加方便、高效。再加上Redisson支持多种编码模式，比如JSON、Avro、Smile等，使得它非常灵活。

再说说应用场景。Redisson在Java中的应用非常广泛，无论是做缓存、实现分布式锁，还是构建消息队列，Redisson都能派上用场。尤其在处理高并发、数据一致性这些问题时，Redisson表现得尤为出色。

那Redisson究竟如何使用呢？来看个简单的例子。比如咱们要连接Redis服务器，用Redisson来操作一下：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonDemo {
    public static void main(String[] args) {
        // 创建配置对象
        Config config = new Config();
        // 指定使用单节点部署方式
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        // 创建Redisson客户端实例
        RedissonClient redisson = Redisson.create(config);
        
        // 这里可以进行相关操作，比如...
        
        // 最后关闭Redisson客户端
        redisson.shutdown();
    }
}

这段代码展示了如何用Redisson连接到Redis服务器。咱们通过Config对象设置了Redis服务器的地址，然后创建了一个RedissonClient实例。这就是Redisson的基本用法，简单明了。

第2章：Redisson的架构与原理

接下来，咱们深入了解一下Redisson的架构和原理。Redisson的架构设计得相当巧妙，它利用了Redis的高性能特性，提供了一套丰富的Java并发工具。

Redisson的工作原理是这样的：它在Redis的基础上实现了Java的java.util.concurrent包中的接口，比如Lock、AtomicLong等。这意味着咱们可以像使用Java的并发工具那样，直接使用Redisson提供的这些工具，而底层的数据实际上是存储在Redis中的。

举个例子，来看看Redisson如何实现分布式锁：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class DistributedLockDemo {
    public static void main(String[] args) {
        RedissonClient redisson = ... // 假设这是已经配置好的Redisson客户端

        // 获取一个锁对象，这个锁在Redis中的名字叫做"myLock"
        RLock lock = redisson.getLock("myLock");

        // 尝试获取锁
        lock.lock();
        try {
            // 执行一些操作...
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}

这段代码演示了Redisson如何实现一个分布式锁。通过getLock方法，咱们获得了一个名为"myLock"的锁对象。接着，使用lock方法来加锁，完成操作后，再通过unlock方法释放锁。

第3章：Redisson的基本使用

连接Redis

要使用Redisson，咱们需要先连接到Redis服务器。这个步骤之前已经展示过了，但为了让内容完整，小黑再次演示一遍：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class ConnectRedis {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redisson = Redisson.create(config);
        
        // 在这里执行操作...
        
        redisson.shutdown();
    }
}
基本操作

来看看基本操作。比如咱们想操作一个字符串：

import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;

public class StringOperation {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 获取一个字符串对象，这里的"name"就是Redis中的key
        RBucket<String> bucket = redisson.getBucket("name");
        bucket.set("Redisson"); // 设置key对应的value为"Redisson"
        String value = bucket.get(); // 获取key对应的value
        
        System.out.println("获取到的值：" + value);
    }
}

高级数据结构操作

Redisson还支持许多高级的数据结构，比如队列、映射等。下面小黑给大家展示一下如何操作一个队列：

import org.redisson.api.RQueue;
import org.redisson.api.RedissonClient;

public class QueueOperation {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 获取一个队列
        RQueue<String> queue = redisson.getQueue("myQueue");
        queue.add("一条消息"); // 往队列添加元素
        String item = queue.poll(); // 从队列获取并移除一个元素
        
        System.out.println("从队列中获取的元素：" + item);
    }
}

分布式锁的使用

Redisson的分布式锁也是它的一大特色。看看如何使用：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class LockOperation {
    public static void main(String[] args) throws InterruptedException {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        RLock lock = redisson.getLock("myLock");
        lock.lock(); // 获取锁
        try {
            // 在这里执行同步操作...
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

通过这些例子，咱们可以看到，Redisson提供了一种非常直观和简洁的方式来操作Redis。不论是简单的键值操作，还是复杂的数据结构，Redisson都能让咱们轻松应对。而且，分布式锁的使用也变得非常简单，这对于处理分布式系统中的并发问题来说，简直是一大利器。

第4章：Redisson的高级特性

分布式数据结构

Redisson的一个亮点是提供了丰富的分布式数据结构，比如映射、集合、队列等。这些数据结构都是线程安全的，非常适合分布式系统中使用。

来看看如何使用分布式映射（Map）：

import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;

public class DistributedMapExample {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 创建一个分布式映射
        RMap<String, String> map = redisson.getMap("myMap");
        map.put("key1", "值1");
        map.put("key2", "值2");

        String value = map.get("key1");
        System.out.println("获取到的值：" + value);
    }
}

在这个例子中，咱们创建了一个名为myMap的分布式映射，并进行了简单的操作。这样的映射是跨多个Redisson实例的，也就是说，任何一个实例对映射的更改都会立即反映到其他实例上。

发布/订阅模型

Redisson还支持Redis的发布/订阅模型。这个功能非常适合构建消息系统，比如聊天室、实时通知等。

来看看怎么使用：

import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.api.listener.MessageListener;

public class PubSubExample {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 订阅主题
        RTopic topic = redisson.getTopic("myTopic");
        topic.addListener(String.class, new MessageListener<String>() {
            @Override
            public void onMessage(CharSequence channel, String msg) {
                System.out.println("收到消息：" + msg);
            }
        });

        // 发布消息
        topic.publish("Hello Redisson!");
    }
}

在这段代码中，咱们先订阅了一个名为myTopic的主题，然后发布了一条消息。当消息被发布时，所有订阅了这个主题的客户端都会收到这条消息。

延迟队列与阻塞队列

Redisson还提供了延迟队列和阻塞队列的实现，这对于构建复杂的消息系统或者任务调度系统非常有用。

import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;

import java.util.concurrent.TimeUnit;

public class QueueExample {
    public static void main(String[] args) throws InterruptedException {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 创建一个阻塞队列
        RBlockingQueue<String> blockingQueue = redisson.getBlockingQueue("myQueue");
        // 创建一个延迟队列
        RDelayedQueue<String> delayedQueue = redisson.getDelayedQueue(blockingQueue);

        // 往延迟队列添加元素，5秒后过期
        delayedQueue.offer("延迟消息", 5, TimeUnit.SECONDS);

        // 从阻塞队列中取元素，如果队列为空，则等待
        String element = blockingQueue.take();
        System.out.println("从队列中获取的元素：" + element);
    }
}

第5章：Redisson的分布式服务

分布式锁的实现与应用

在分布式系统中，处理并发问题是个大挑战。Redisson提供的分布式锁就是为了解决这个问题。我们先来回顾一下之前的分布式锁的例子，然后深入理解它的原理和应用。

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public class DistributedLockExample {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        RLock lock = redisson.getLock("myLock");
        lock.lock();
        try {
            // 执行同步操作
        } finally {
            lock.unlock();
        }
    }
}

在这个例子中，getLock方法获取了一个分布式锁。当多个实例尝试获取同一把锁时，只有一个实例能成功获得锁，并执行锁定的代码块。这保证了在分布式环境中操作的原子性和一致性。

分布式集合与映射

Redisson还提供了分布式集合和映射，这些数据结构在多个Redisson节点间是同步的。

import org.redisson.api.RList;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;

public class DistributedCollectionsExample {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 分布式列表
        RList<String> list = redisson.getList("myList");
        list.add("元素1");
        list.add("元素2");

        // 分布式映射
        RMap<String, String> map = redisson.getMap("myMap");
        map.put("键1", "值1");
        map.put("键2", "值2");
    }
}

在这段代码中，咱们操作了一个分布式列表和一个分布式映射。无论在哪个节点对这些数据结构进行操作，所有的更改都会反映到每个节点。

分布式计数器与原子操作

Redisson还提供了分布式计数器和原子操作，这对于在分布式系统中进行计数或同步更新是非常有用的。

import org.redisson.api.RAtomicLong;
import org.redisson.api.RedissonClient;

public class DistributedAtomicLongExample {
    public static void main(String[] args) {
        RedissonClient redisson = ...; // 这是已经配置好的Redisson客户端

        // 分布式原子长整型
        RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong");
        atomicLong.set(0);
        atomicLong.incrementAndGet(); // 自增并获取新值
        System.out.println("当前值：" + atomicLong.get());
    }
}

在这个例子中，getAtomicLong方法创建了一个分布式的原子长整型。这个计数器在所有Redisson实例之间是同步的，因此它可以在分布式系统中作为一个可靠的计数器使用。

第6章：Redisson与Spring Boot的整合

配置与依赖管理

首先，要在Spring Boot项目中使用Redisson，需要添加Redisson的依赖。在pom.xml中加入以下依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>最新版本</version>
</dependency>

接下来，配置Redisson。在application.yml或者application.properties文件中，添加Redis服务器的相关配置：

spring:
  redis:
    host: localhost
    port: 6379
缓存与事务管理

Redisson可以与Spring Boot的缓存抽象无缝整合。这意味着咱们可以非常简单地将Redisson作为Spring Boot应用的缓存解决方案。

例如，使用@Cacheable注解来缓存方法的结果：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable(value = "itemCache", key = "#id")
    public Item findItemById(Long id) {
        // 这里是模拟数据库查询操作
        return new Item(id, "Item名称");
    }
}

在这个例子中，findItemById方法的结果会被缓存起来。当相同的id再次调用该方法时，就会直接从缓存中获取结果，而不需要重新执行方法。

应用示例与最佳实践

现在来看一个具体的应用实例。假设咱们需要实现一个简单的基于Redis的分布式锁，来控制对共享资源的访问。

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class DistributedLockManager {

    @Autowired
    private RedissonClient redissonClient;

    public void performTaskWithLock(String lockName) {
        RLock lock = redissonClient.getLock(lockName);
        try {
            // 尝试获取锁，最多等待10秒，锁定后10秒自动解锁
            if (lock.tryLock(10, 10, TimeUnit.SECONDS)) {
                try {
                    // 执行业务操作
                } finally {
                    lock.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这个例子中，我们通过注入的RedissonClient来获取一个分布式锁。通过tryLock方法来尝试获取锁，如果成功，就执行业务操作。

第7章：Redisson的性能优化与调优

参数调整与优化建议

在Redisson中，有几个关键参数是影响性能的：

  • 连接池大小：Redisson允许咱们配置连接池的大小。一个合理的连接池大小可以有效地提高资源利用率，减少因连接创建和销毁带来的开销。

  • 超时设置：合理的超时设置可以在网络延迟或者Redis服务器繁忙时避免应用挂起。但设置得太短可能会导致频繁的超时异常。

  • 序列化方式：Redisson支持多种序列化方式，比如JSON、Avro等。选择合适的序列化方式，可以减少网络传输的数据量，提高效率。

故障排查与解决方案

在使用Redisson时，可能会遇到一些问题，比如连接异常、性能下降等。这时，需要及时进行故障排查。

一般来说，排查步骤包括：

  • 查看日志：检查Redisson和应用的日志，看是否有异常信息。

  • 监控Redis服务器：使用Redis自带的监控工具，比如INFO命令，观察Redis的性能指标。

  • 网络问题：有时候问题可能是由网络引起的，这时可以使用网络监控工具进行检测。

为了更具体地理解，小黑举个例子。比如咱们发现Redisson的响应时间不稳定，经过排查发现是因为连接池太小。这时可以通过调整配置文件来增加连接池的大小：

spring:
  redis:
    redisson:
      single-server-config:
        connection-pool-size: 64 # 调整连接池大小

在进行调优时，建议逐步调整参数，并且持续进行性能测试，以确保每次调整都能带来正向的效果。

第8章：Redisson的实战案例分析

案例1：电商平台的库存管理

在电商平台中，库存管理是个大挑战。尤其在大促销时，高并发下的库存更新会非常复杂。

挑战：确保在高并发情况下，库存的准确性和一致性。

解决策略：使用Redisson的分布式锁来控制对库存的访问。当用户尝试购买商品时，先获取分布式锁，然后更新库存，最后释放锁。

代码示例：

public class InventoryService {

    private final RedissonClient redissonClient;

    public InventoryService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    public boolean purchaseItem(String itemId) {
        RLock lock = redissonClient.getLock("inventory:" + itemId);
        try {
            if (lock.tryLock(10, 2, TimeUnit.SECONDS)) {
                // 检查并更新库存
                // ...
                return true;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
        return false;
    }
}

教训与经验：在高并发环境下，分布式锁是处理共享资源竞争的有效手段。但同时也要注意锁的粒度和超时时间，以免造成性能瓶颈。

案例2：实时消息推送系统

在一个需要实时消息推送的系统中，消息的及时传递至关重要。

挑战：如何高效地向大量用户推送实时消息。

解决策略：利用Redisson的发布/订阅功能实现消息的即时推送。当有消息需要推送时，将消息发布到特定的主题，所有订阅该主题的用户都能立刻收到消息。

代码示例：

public class MessagePublisher {

    private final RedissonClient redissonClient;

    public MessagePublisher(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    public void publishMessage(String topic, String message) {
        RTopic rTopic = redissonClient.getTopic(topic);
        rTopic.publish(message);
    }
}

教训与经验：发布/订阅模型非常适合实现实时消息系统，但要注意消息的序列化和网络延迟对性能的影响。

案例3：分布式定时任务

在分布式系统中，定时执行任务也是一个常见需求。

挑战：如何确保定时任务在分布式环境下的正确执行。

解决策略：使用Redisson的分布式定时任务功能。可以安排任务在指定时间执行，而且在多个节点中只会执行一次。

代码示例：

public class SchedulerService {

    private final RedissonClient redissonClient;

    public SchedulerService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    public void scheduleTask(Runnable task, long delay, TimeUnit timeUnit) {
        RScheduledExecutorService executorService = redissonClient.getExecutorService("myScheduler");
        executorService.schedule(task, delay, timeUnit);
    }
}

教训与经验：分布式定时任务解决了在分布式系统中任务调度的难题，但需要注意任务执行的可靠性和失败重试机制。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

02_Collection

02_Collection

文章目录 集合Java的集合类 Collectioniterator方法 集合 在Java中&#xff0c;指的就是存放数据的容器&#xff0c;是一个载体&#xff0c;可以一次容纳多个对象。 解决Bug的两种方法&#xff1a; 打印 System.out.println();log.info(); debug 检查数据 Java的集合类 Co…
阅读更多...
项目管理十大知识领域之项目干系人管理

项目管理十大知识领域之项目干系人管理

一、项目干系人管理的概念解析 项目干系人管理是指在项目执行过程中&#xff0c;对项目相关方的需求进行识别、分析和管理的过程。项目干系人管理的核心在于有效地沟通、协调和满足各方的需求&#xff0c;以确保项目能够顺利实施并达到预期的成果。在现代项目管理实践中&#…
阅读更多...
conda国内加速

conda国内加速

1、配置国内源 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ 2、显示源地址 conda config --set show_channel_urls yes
阅读更多...
Python实现GEE嵌套协方差结构仿真模型(GEE算法)项目实战

Python实现GEE嵌套协方差结构仿真模型(GEE算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 广义估计方程&#xff08;Generalized Estimating Equations, GEE&#xff09;是一种用于分析具有重复…
阅读更多...
CC工具箱使用指南：【按条件选择排序】

CC工具箱使用指南：【按条件选择排序】

一、简介 此工具来自一个群友的需求&#xff0c;做完想想可能会有同样需求的人用得到&#xff0c;就稍改了一下做成公共版本。 具体需求是这样的&#xff1a; 1、按条件选择对部分图斑进行排序&#xff0c;比如说在所有地类中&#xff0c;只想对地类名称为【林地】的图斑进行…
阅读更多...
【Elasticsearch】索引恢复（recovery）流程梳理之副本分片数据恢复

【Elasticsearch】索引恢复（recovery）流程梳理之副本分片数据恢复

replica shard重启具体流程 replica shard node &#xff08;generic threadpool&#xff09; 也是因为应用新的集群状态触发recovery&#xff0c;进入index阶段进入translog 阶段。先尝试重放本地的translog到global checkpoint向primary shard发起start recovery的请求&…
阅读更多...
C++参悟：正则表达式库regex

C++参悟：正则表达式库regex

正则表达式库regex 一、概述二、快速上手Demo1. 查找字符串2. 匹配字符串3. 替换字符串 三、类关系梳理1. 主类1. basic_regex 2. 算法1. regex_match2. regex_search3. regex_replace 3. 迭代器4. 异常5. 特征6. 常量1. syntax_option_type2. match_flag_type3. error_type 一…
阅读更多...
【Linux】第三十站：进程间通信

【Linux】第三十站：进程间通信

文章目录 一、是什么二、为什么三、怎么办四、管道1.什么是管道2.管道的原理3.接口4.编码实现5.管道的特征6.管道的四种情况 一、是什么 两个或者多个进程实现数据层面的交互 因为进程独立性的存在&#xff0c;导致进程通信的成本比较高 通信是有成本的&#xff0c;体现在要打破…
阅读更多...
集美大学“第15届蓝桥杯大赛(软件类)“校内选拔赛 D矩阵选数

集美大学“第15届蓝桥杯大赛(软件类)“校内选拔赛 D矩阵选数

经典的状态压缩DP int dp[15][(1<<14)10]; int a[15][15]; void solve() {//dp[i][st]考虑到了第i行 并且当前考虑完第i行以后的选择状态是st的所有方案中的最大值for(int i1;i<13;i)for(int j1;j<13;j)cin>>a[i][j];for(int i1;i<13;i){for(int j0;j<…
阅读更多...
conda修改默认环境安装位置

conda修改默认环境安装位置

conda修改默认环境安装位置 文章目录 conda修改默认环境安装位置查看conda配置信息创建.condarc&#xff08;conda runtime controlling)配置文件没有.condarc怎么办 即使创建正确放置了.condarc创建环境时还是默认指定C盘目录写权限目录修改权限 查看conda配置信息 conda con…
阅读更多...
Flutter 页面嵌入 Android原生 View

Flutter 页面嵌入 Android原生 View

前言 文章主要讲解Flutter页面如何使用Android原生View&#xff0c;但用到了Flutter 和 Android原生 相互通信知识&#xff0c;建议先看完这篇讲解通信的文章 Flutter 与 Android原生 相互通信&#xff1a;BasicMessageChannel、MethodChannel、EventChannel-CSDN博客 数据观…
阅读更多...
1027 打印沙漏 (20)

1027 打印沙漏 (20)

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”&#xff0c;要求按下列格式打印 ************ *****所谓“沙漏形状”&#xff0c;是指每行输出奇数个符号&#xff1b;各行符号中心对齐&#xff1b;相邻两行符号数差2&#xff1b;符号数先从大到小顺序递…
阅读更多...
数据结构：顺序表 模拟实现及详解

数据结构：顺序表 模拟实现及详解

目录 一、线性表 二、顺序表 2.1顺序表的概念及结构 2.1.1静态顺序表 2.2.2动态顺序表 2.2动态顺序表接口实现 一、线性表 线性表&#xff08; linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见…
阅读更多...
如何使用iPhone或iPad上的二维码共享Wi-Fi密码？这里有详细步骤

如何使用iPhone或iPad上的二维码共享Wi-Fi密码？这里有详细步骤

你有没有想过在不泄露网络密码的情况下与客人共享你的家庭或工作Wi-Fi？你肯定不是第一个这样想的人，我们很高兴地通知你，多亏了以下这个的变通方法，你现在可以使用iPhone或iPad做到这一点。 通常，如果你想让其他人访问网络，你需要共享你的Wi-Fi密码。苹果通过引入与任何…
阅读更多...
Jetpack Compose -＞ 分包 自定义Composable

Jetpack Compose -＞ 分包 自定义Composable

前言 上一章我们讲解了 Compose 基础UI 和 Modifier 关键字&#xff0c;本章主要讲解 Compose 分包以及自定义 Composable&#xff1b; Compose 如何分包 我们在使用 Button 控件的时候&#xff0c;发现如果我们想给按钮设置文本的时候&#xff0c;Button 函数并没有直接提供…
阅读更多...
读书笔记-《数据结构与算法》-摘要8[桶排序]

读书笔记-《数据结构与算法》-摘要8[桶排序]

桶排序和归并排序有那么点点类似&#xff0c;也使用了归并的思想。大致步骤如下&#xff1a; 设置一个定量的数组当作空桶。Divide - 从待排序数组中取出元素&#xff0c;将元素按照一定的规则塞进对应的桶子去。对每个非空桶进行排序&#xff0c;通常可在塞元素入桶时进行插入…
阅读更多...
C#中ArrayList运行机制及其涉及的装箱拆箱

C#中ArrayList运行机制及其涉及的装箱拆箱

C#中ArrayList运行机制及其涉及的装箱拆箱 1.1 基本用法1.1.1 属性1.1.2 方法 1.2 内部实现1.3 装箱1.4 拆箱1.5 object对象的相等性比较1.6 总结1.7 其他简单结构类 1.1 基本用法 命名空间&#xff1a; using System.Collections; 1.1.1 属性 Capacity&#xff1a;获取或设…
阅读更多...
【代码随想录10】20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

【代码随想录10】20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

目录 20. 有效的括号题目描述参考代码 1047. 删除字符串中的所有相邻重复项题目描述参考代码 150. 逆波兰表达式求值题目描述参考代码 20. 有效的括号 题目描述 给定一个只包括 (&#xff0c;)&#xff0c;{&#xff0c;}&#xff0c;[&#xff0c;] 的字符串 s &#xff0c;…
阅读更多...
语音模块学习——LSYT201B模组（深圳雷龙科技）

语音模块学习——LSYT201B模组（深圳雷龙科技）

目录 引子 处理器 外设 音频 蓝牙 模组展示 引子 关注我的老粉们应该知道我之前用过语音模块做东西&#xff0c;那个比较贵要50多。 今天这个淘宝20元左右比那个便宜&#xff0c;之前那个内核是51的&#xff0c;一个8位机。 后面我做东西的时候语音模块可能会换成这个&…
阅读更多...
【51单片机】动态数码管

【51单片机】动态数码管

0、前言 参考&#xff1a; 普中51单片机开发攻略–A2.pdf 1、数码管介绍 上一章我们主要是介绍一位数码管的内部结构及控制原理。下面我们再来介 绍下多位数码管及动态显示原理的相关知识。 1.1 多位数码管简介 2、74HC245 和 74HC138 芯片介绍 2.1 74HC245 芯片简介 2.2 7…
阅读更多...
最新文章

Copyright @ 2022~2023