1、Redis和nosql简介,api调用

14.1/ nosql介绍

NoSQL：一类新出现的数据库(not only sql)，它的特点：

1、不支持SQL语法

2、存储结构跟传统关系型数据库中的那种关系表完全不同，nosql中存储的数据都是KV形式

3、 NoSQL的世界中没有一种通用的语言，每种nosql数据库都有自己的api和语法，以及擅长的业务场景

4、 NoSQL中的产品种类相当多：

a) Mongodb 文档型nosql数据库，擅长做CMS系统（内容管理系统）

b) Redis 内存数据库，数据结构服务器，号称瑞士军刀（精巧），只要你有足够的想象力，它可以还给你无限惊喜

c) Hbase hadoop生态系统中原生的一种nosql数据库，重量级的分布式nosql数据库，用于海量数据的场景

d) Cassandra hadoop生态系统中原生的一种分布式nosql数据库，后起之秀

NoSQL和SQL数据库的比较：

1、适用场景不同：sql数据库适合用于关系特别复杂的数据查询场景，nosql反之

2、“事务”特性的支持：sql对事务的支持非常完善，而nosql基本不支持事务

3、两者在不断地取长补短，呈现融合趋势

14.2/ redis介绍

14.2.1 简述

Redis是一个高性能的kv对缓存和内存数据库(存的不像mysql那样的表)

Redis的存储结构就是key-value，形式如下：

注： redis中的value内部可以支持各种数据结构类型，比如可以存入一个普通的string，还可以存list，set，hashmap，sortedSet（有序的set）

14.2.2 redis应用场景

A、用来做缓存(ehcache/memcached)——redis的所有数据是放在内存中的（内存数据库）

B、可以在某些特定应用场景下替代传统数据库——比如社交类的应用

C、在一些大型系统中，巧妙地实现一些特定的功能：session共享、购物车

只要你有丰富的想象力，redis可以用在可以给你无限的惊喜…….

14.2.3 redis的特性

1、redis数据访问速度快（数据在内存中）

2、redis有数据持久化机制（持久化机制有两种：1、定期将内存数据dump到磁盘；2、aof(append only file)持久化机制——用记日志的方式记录每一条数据更新操作，一旦出现灾难事件，可以通过日志重放来恢复整个数据库）

3、redis支持集群模式（容量可以线性扩展）

4、redis相比其他缓存工具（ehcach/memcached），有一个鲜明的优势：支持丰富的数据结构

14.3.Redis的api客户端连接

新建一个maven工程，导入jedis的maven依赖坐标

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<scope>compile</scope>

</dependency>

然后写一个类用来测试服务器跟客户端的连通性:

public class RedisClientConnectionTest {

public static void main(String[] args) {

// 构造一个redis的客户端对象

Jedis jedis = new Jedis("pinshutang.zicp.net", 6379);

String ping = jedis.ping();

System.out.println(ping);

}

15、Redis数据功能（String类型的数据处理）

15.1 String类型的数据

(常作为缓存使用)

1/插入和读取一条string类型的数据

redis notrue-centos:6379> set sessionid-0001 "zhangsan"

redis notrue-centos:6379> get sessionid-0001

"zhangsan"

2/对string类型数据进行增减（前提是这条数据的value可以看成数字）

192.168.106.80:6379> DECR key

(integer) -1

192.168.106.80:6379> DECR key

(integer) -2

192.168.106.80:6379> DECR key

(integer) -3

192.168.106.80:6379> INCR key

(integer) -2

192.168.106.80:6379> INCR key

(integer) -1

192.168.106.80:6379> DECRBY key 4

(integer) -5

192.168.106.80:6379> DECRBY key -7

(integer) 2

192.168.106.80:6379> INCRBY key 2

(integer) 4

192.168.106.80:6379> INCRBY key -9

(integer) -5

3/一次性插入或者获取多条数据

192.168.106.80:6379> MSET key1 1 key2 2 key3 3

192.168.106.80:6379> MGET key1 key2 key3

1) "1"

2) "2"

3) "3"

4/在插入一条string类型数据的同时为它指定一个存活期限

setex key seconds value

例如：

# bancao这条数据就只会存活10秒钟，过期会被redis自动清除

192.168.106.80:6379> setex bancao 10 testvalue

192.168.106.80:6379> get bancao

"testvalue"

192.168.106.80:6379> get bancao

"testvalue"

192.168.106.80:6379> get bancao

(nil)

192.168.106.80:6379> get bancao

(nil)

案例：

其中maven项目的pom文件的内容如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>cn.toto.redis</groupId>

<artifactId>redistest</artifactId>

<version>0.0.1-SNAPSHOT</version>

<!-- <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId>

<version>2.7.2</version> <type>jar</type> <scope>compile</scope> </dependency> -->

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</dependency>

<groupId>com.google.code.gson</groupId>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

</dependencies>

</project>

代码：

package cn.toto.redis.client;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import org.junit.Before;

import org.junit.Test;

import com.google.gson.Gson;

import cn.toto.redis.bean.ProductInfo;

import redis.clients.jedis.Jedis;

public class StringStructureData {

private Jedis jedis = null;

@Before

public void init() {

//这里的是hadoop2可以用ip地址替换

jedis = new Jedis("hadoop2",6379);

}

@Test

public void testString() {

jedis.set("user02:name", "ruhua");

jedis.set("user03:name", "滑板鞋");

String u02 = jedis.get("user02:name");

String u03 = jedis.get("user03:name");

System.out.println(u02);

System.out.println(u03);

}

@Test

public void testObjectCache() throws Exception {

ProductInfo p = new ProductInfo();

p.setName("username");

p.setDescription("备注信息");

p.setCatelog("unknow");

p.setPrice(10.8);

//将对象序列化成字节数组

ByteArrayOutputStream ba = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(ba);

//用对象序列化流来将p对象序列化，然后把序列化之后的二进制数据写到ba流中

oos.writeObject(p);

//将ba流转成byte数组

byte[] pBytes = ba.toByteArray();

//将对象序列化之后的byte数组存到redis的string结构数组中

jedis.set("product:01".getBytes(), pBytes);

//根据key从redis中取出对象的byte数据

byte[] pBytesResp = jedis.get("product:01".getBytes());

//将byte数据反序列化列出对象

ByteArrayInputStream bi = new ByteArrayInputStream(pBytesResp);

ObjectInputStream oi = new ObjectInputStream(bi);

//从对象读取流中取出对象

ProductInfo pResp = (ProductInfo) oi.readObject();

System.out.println(pResp);

}

@Test

public void testObjectToJsonCache() {

ProductInfo p = new ProductInfo();

p.setName("ABC");

p.setDescription("刘亦菲专用");

p.setCatelog("化妆品");

p.setPrice(10.8);

//利用gson将对象转成json串

Gson gson = new Gson();

String pJson = gson.toJson(p);

//将json串存入redis

jedis.set("prodcut:02", pJson);

//从redis中取出对象的json串

String pJsonResp = jedis.get("prodcut:02");

//将返回的json解析成对象

ProductInfo pResponse = gson.fromJson(pJsonResp, ProductInfo.class);

//显示对象的属性

System.out.println(pResponse);

}

16、List数据结构（及Java调用处理）

16.1 List图示

16.2 List功能演示

#从头部（左边）插入数据

redis>LPUSH key value1 value2 value3

#从尾部（右边）插入数据

redis>RPUSH key value1 value2 value3

#读取list中指定范围的values

redis>LRANGE key start end

redis> lrange task-queue 0 -1 读取整个list

#从头部弹出一个元素

LPOP key

#从尾部弹出一个元素

RPOP key

#从一个list的尾部弹出一个元素插入到另一个list

RPOPLPUSH key1 key2 ## 这是一个原子性操作

例如下面的案例：

#从头部（左边）插入数据

192.168.106.81:6379> lpush task task0 task1 task2

(integer) 3

192.168.106.81:6379> lrange task 0 2

1) "task2"

2) "task1"

3) "task0"

192.168.106.81:6379> lrange task 0 -2

1) "task2"

2) "task1"

192.168.106.81:6379> lrange task 0 -1

1) "task2"

2) "task1"

3) "task0"

#从尾部（右边）插入数据

192.168.106.81:6379> rpush ids id0 id1 id2

(integer) 3

192.168.106.81:6379> lrange ids 0 -1

1) "id0"

2) "id1"

3) "id2"

192.168.106.81:6379> lpop ids

"id0"

192.168.106.81:6379> lpop ids

"id1"

192.168.106.81:6379> rpop task

"task0"

192.168.106.81:6379> rpoplpush task ids

"task1"

192.168.106.81:6379> lrange ids 0 -1

1) "task1"

2) "id2"

192.168.106.81:6379>

16.3 List的应用案例demo

1 需求描述

任务调度系统：

生产者不断产生任务，放入task-queue排队

消费者不断拿出任务来处理，同时放入一个tmp-queue暂存，如果任务处理成功，则清除tmp-queue，否则，将任务弹回task-queue

2 代码实现

1/生产者

——模拟产生任务

package cn.toto.redis.productAndCustomer;

import java.util.Random;

import java.util.UUID;

import redis.clients.jedis.Jedis;

public class TaskProducer {

//获取一个redis的客户端连接对象

public static Jedis getRedisConnection(String host,int port) {

Jedis jedis = new Jedis(host,port);

return jedis;

}

public static void main(String[] args) {

Jedis jedis = getRedisConnection("hadoop3", 6379);

Random random = new Random();

//生成任务

while(true) {

try {

//生成任务的速度有一定的随机性，在1-2秒之间

Thread.sleep(random.nextInt(1000) + 1000);

//生成一个任务

String taskid = UUID.randomUUID().toString();

//往任务队列"task-queue"中插入，第一次插入时，"task-queue"还不存在

//但是lpush方法会在redis库中创建一条新的list数据

jedis.lpush("task-queue", taskid);

System.out.println("向任务队列中插入了一个新的任务:" + taskid);

} catch (Exception e) {

e.printStackTrace();

}

2/消费者

——模拟处理任务，并且管理暂存队列

package cn.toto.redis.productAndCustomer;

import java.util.Random;

import redis.clients.jedis.Jedis;

public class TaskConsumer {

public static void main(String[] args) {

Jedis jedis = new Jedis("hadoop3",6379);

Random random = new Random();

while(true) {

try {

//从task-queue中取一个任务，同时放入tmp-queue

String taskid = jedis.rpoplpush("task-queue", "tmp-queue");

//模拟处理任务

Thread.sleep(1000);

//模拟有成功又有失败的情况

int nextInt = random.nextInt(13);

if (nextInt % 7 == 0) {//模拟失败的情况

//在失败的情况下，需要将任务从tmp-queue弹回"task-queue"

jedis.rpoplpush("tmp-queue", "task-queue");

System.out.println("----任务处理失败:" + taskid);

} else {//模拟成功的情况

//成功的情况下，将任务从"tmp-queue"清除

jedis.rpop("tmp-queue");

System.out.println("任务处理成功:" + taskid);

}

} catch (Exception e) {

e.printStackTrace();

}

上述机制是一个简化版，真实版的任务调度系统会更加复杂，如下所示：

（增加了一个专门用来管理暂存队列的角色，以便就算消费者程序失败退出，那些处理失败的任务依然可以被弹回task-queue）

17、Hash数据结构

17.1 Hash图示

Redis中的Hashes类型可以看成具有String Key和String Value的map容器

17.2 Hash功能演示

1、往redis库中插入一条hash类型的数据

redis> HSET key field value

举例：

redis 127.0.0.1:6379> hset user001:zhangsan iphone 6

(integer) 1

redis 127.0.0.1:6379> hset user001:zhangsan xiaomi 7

(integer) 1

redis 127.0.0.1:6379> hset user001:zhangsan meizu 8

(integer) 1

在redis库中就形成了这样一条数据：

2、从redis库中获取一条hash类型数据的value

ü 取出一条hash类型数据中所有field-value对

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "iphone"

2) "6"

3) "xiaomi"

4) "7"

5) "meizu"

6) "8"

ü 取出hash数据中所有fields

redis 127.0.0.1:6379> HKEYS user001:zhangsan

1) "iphone"

2) "xiaomi"

3) "meizu"

ü 取出hash数据中所有的value

redis 127.0.0.1:6379> hvals user001:zhangsan

1) "6"

2) "7"

3) "8"

ü 取出hash数据中一个指定field的值

redis 127.0.0.1:6379> hget user001:zhangsan xiaomi

"8"

ü 为hash数据中指定的一个field的值进行增减

redis 127.0.0.1:6379> HINCRBY user001:zhangsan xiaomi 1

(integer) 8

ü 从hash数据中删除一个字段field及其值

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "iphone"

2) "6"

3) "xiaomi"

4) "7"

5) "meizu"

6) "8"

redis 127.0.0.1:6379> HDEL user001:zhangsan iphone

(integer) 1

redis 127.0.0.1:6379> hgetall user001:zhangsan

1) "xiaomi"

2) "7"

3) "meizu"

4) "8"

18、Set数据结构功能

集合的特点：无序、无重复元素

1、插入一条set数据

redis 127.0.0.1:6379> sadd frieds:zhangsan bingbing baby fengjie furong ruhua tingting

(integer) 6

redis 127.0.0.1:6379> scard frieds:zhangsan

(integer) 6

redis 127.0.0.1:6379>

2、获取一条set数据的所有members

redis 127.0.0.1:6379> smembers frieds:zhangsan

1) "fengjie"

2) "baby"

3) "furong"

4) "bingbing"

5) "tingting"

6) "ruhua"

3、判断一个成员是否属于某条指定的set数据

redis 127.0.0.1:6379> sismember frieds:zhangsan liuyifei #如果不是，则返回0

(integer) 0

redis 127.0.0.1:6379> sismember frieds:zhangsan baby #如果是，则返回1

(integer) 1

4、求两个set数据的差集

#求差集

redis 127.0.0.1:6379> sdiff frieds:zhangsan friends:xiaotao

1) "furong"

2) "fengjie"

3) "ruhua"

4) "feifei"

#求差集，并将结果存入到另一个set

redis 127.0.0.1:6379> sdiffstore zhangsan-xiaotao frieds:zhangsan friends:xiaotao

(integer) 4

#查看差集结果

redis 127.0.0.1:6379> smembers zhangsan-xiaotao

1) "furong"

2) "fengjie"

3) "ruhua"

4) "feifei"

5、求交集，求并集

#求交集

redis 127.0.0.1:6379> sinterstore zhangsan:xiaotao frieds:zhangsan friends:xiaotao

(integer) 2

redis 127.0.0.1:6379> smembers zhangsan:xiaotao

1) "bingbing"

2) "baby"

#求并集

redis 127.0.0.1:6379> sunion frieds:zhangsan friends:xiaotao

1) "fengjie"

2) "tangwei"

3) "liuyifei"

4) "bingbing"

5) "ruhua"

6) "feifei"

7) "baby"

8) "songhuiqiao"

9) "furong"

10) "yangmi"

案例代码：

package cn.toto.redis.hashcart;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.junit.Before;

import org.junit.Test;

import redis.clients.jedis.Jedis;

public class BuyCartServiceImpl {

private Jedis jedis = null;

private static final String CART_PRIFIX = "cart:";

@Before

public void init() {

jedis = new Jedis("hadoop3",6379);

}

/**

* 添加商品到购物车

@Test

public void testAddItemToCart() {

jedis.hset(CART_PRIFIX + "user02", "上衣", "2");

jedis.hset(CART_PRIFIX + "user02", "鞋子", "1");

jedis.hset(CART_PRIFIX + "user02", "毛衣", "3");

jedis.hset(CART_PRIFIX + "user02", "羽绒服", "4");

jedis.close();

}

/**

* 查看购物车信息，当本类中的其它单元测试执行完成之后，可以通过执行这个单元测试方法查看内容

* @author toto

* @date 2017-1-14

* @note begin modify by 涂作权 2017-1-14 原始创建

@Test

public void testGetCartInfo() {

Map<String, String> cart = jedis.hgetAll(CART_PRIFIX + "user02");

Set<Entry<String, String>> entrySet = cart.entrySet();

for(Entry<String, String> ent : entrySet) {

System.out.println(ent.getKey() + ":" + ent.getValue());

}

jedis.close();

}

/**

* 编辑缓存中的内容

@Test

public void editCart() {

//给蜡烛商品项的数量加1

jedis.hincrBy(CART_PRIFIX + "user02", "羽绒服", 1);

jedis.close();

}

/**

* 删除内存中上衣这个内容

@Test

public void delItemFromCart() {

jedis.hdel(CART_PRIFIX + "user02", "上衣");

jedis.close();

}

生产者消费者：

生产者：

package cn.toto.redis.listqueue;

import java.util.Random;

import java.util.UUID;

import redis.clients.jedis.Jedis;

public class TaskProducer {

private static Jedis jedis = null;

public static void main(String[] args) throws Exception {

jedis = new Jedis("hadoop2",6379);

Random random = new Random();

while(true) {

int nextInt = random.nextInt(1000);

Thread.sleep(1000 + nextInt);

//生成一个任务的id

String taskid = UUID.randomUUID().toString();

jedis.lpush("task-queue", taskid);

System.out.println("生成了一个任务:" + taskid);

}

消费者：

package cn.toto.redis.listqueue;

import java.util.Random;

import redis.clients.jedis.Jedis;

/**

* @brief TaskProcessor.java 任务处理模块

public class TaskProcessor {

private static Jedis jedis = null;

public static void main(String[] args) throws Exception {

Random random = new Random();

jedis = new Jedis("hadoop2",6379);

while(true) {

Thread.sleep(1500);

//从任务队列中取出一个任务，同时放入到暂存队列中

String taskid = jedis.rpoplpush("task-queue", "tmp-queue");

//处理任务

if (random.nextInt(19) % 9 == 0) {

//模拟失败

//失败的情况下，需要将任务从暂存队列弹回任务队列

jedis.rpoplpush("tmp-queue", "task-queue");

System.out.println("该任务处理失败:" + taskid);

} else {

//模拟成功

//成功的情况下，只需要将任务从暂存队列清除

jedis.rpop("tmp-queue");

System.out.println("任务处理成功:" + taskid);

}

Set的案例：

package cn.toto.redis.set;

import java.util.Set;

import redis.clients.jedis.Jedis;

public class TestSet {

public static void main(String[] args) {

Jedis jedis = new Jedis("hadoop2",6379);

jedis.sadd("friends:shuangshuang", "dandan","lulu","lili");

jedis.sadd("friends:laobi", "laowang","laodu","laoli","lili","lulu");

//判断一个成员是否属于指定的集合

Boolean isornot = jedis.sismember("friends:laobi", "shuangshuang");

System.out.println(isornot);

//求两个集合的差并交集

Set<String> ssDiffbb = jedis.sdiff("friends:shuangshuang","friends:laobi");

Set<String> ssUnionbb = jedis.sunion("friends:shuangshuang","friends:laobi");

Set<String> ssInterbb = jedis.sinter("friends:shuangshuang","friends:laobi");

//打印结果

for (String mb : ssUnionbb) {

System.out.println(mb);

}

19、sortedSet（有序集合）数据结构

19.1 sortedSet图示

sortedset中存储的成员都有一个附带的分数值

而redis就可以根据分数来对成员进行各种排序（正序、倒序）

1、 sortedSet存储内容示意图：

19.2 SortedSet功能演示

1、往redis库中插入一条sortedset数据

redis 127.0.0.1:6379> zadd nansheng:yanzhi:bang 70 liudehua 90 huangbo 100 weixiaobao 250 yangwei 59 xiaotao

(integer) 5

2、从sortedset中查询有序结果

#正序结果

redis 127.0.0.1:6379> zrange nansheng:yanzhi:bang 0 4

1) "xiaotao"

2) "liudehua"

3) "huangbo"

4) "weixiaobao"

5) "yangwei"

#倒序结果

redis 127.0.0.1:6379> zrevrange nanshen:yanzhi:bang 0 4

1) "yangwei"

2) "weixiaobao"

3) "huangbo"

4) "liudehua"

5) "xiaotao"

3、查询某个成员的名次

#在正序榜中的名次

redis 127.0.0.1:6379> zrank nansheng:yanzhi:bang xiaotao

(integer) 0

#在倒序榜中的名次

redis 127.0.0.1:6379> zrevrank nansheng:yanzhi:bang xiaotao

(integer) 4

4、修改成员的分数

redis 127.0.0.1:6379> zincrby nansheng:yanzhi:bang 300 xiaotao

"359"

redis 127.0.0.1:6379> zrevrank nansheng:yanzhi:bang xiaotao

(integer) 0

案例：

下面的这个先运行：

package cn.toto.redis.sortedset;

import java.util.Random;

import redis.clients.jedis.Jedis;

public class LolBoxPlayer {

public static void main(String[] args) throws Exception {

Jedis jedis = new Jedis("hadoop2",6379);

Random random = new Random();

String[] heros = {"易大师","德邦","剑姬","盖伦","阿卡丽","金克斯","提莫","猴子","亚索"};

while(true) {

int index = random.nextInt(heros.length);

//选择一个英雄

String hero = heros[index];

//开始玩游戏

Thread.sleep(1000);

//给集合中的该英雄的出场次数加1

//第一次添加的时候，集合不存在，zincrby方法会创建

jedis.zincrby("hero:ccl:phb", 1, hero);

System.out.println(hero + "出场了......");

}

下面的这个后运行：

package cn.toto.redis.sortedset;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.Tuple;

public class LolBoxViewer {

public static void main(String[] args) throws Exception {

Jedis jedis = new Jedis("hadoop2",6379);

int i = 1;

while(true) {

//每隔3秒查看一次榜单

Thread.sleep(3000);

System.out.println("第" + i + "次查看榜单-----------");

//从redis中查询榜单的前N名

Set<Tuple> topHeros = jedis.zrevrangeWithScores("hero:ccl:phb", 0, 4);

for (Tuple t : topHeros) {

System.out.println(t.getElement() + " " + t.getScore());

}

i++;

System.out.println("");

}

Redis和nosql简介,api调用；Redis数据功能（String类型的数据处理）；List数据结构（及Java调用处理）；Hash数据结构；Set数据结构功能；sortedSet（有序集合）数

1、Redis和nosql简介,api调用

14.1/ nosql介绍

14.2/ redis介绍

14.2.1 简述

14.2.2 redis应用场景

14.2.3 redis的特性

14.3.Redis的api客户端连接

15、Redis数据功能（String类型的数据处理）

15.1 String类型的数据

16、List数据结构（及Java调用处理）

16.1 List图示

16.2 List功能演示

16.3 List的应用案例demo

1 需求描述

2 代码实现

17、Hash数据结构

17.1 Hash图示

17.2 Hash功能演示

18、Set数据结构功能

19、sortedSet（有序集合）数据结构

19.1 sortedSet图示

19.2 SortedSet功能演示

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Redis和nosql简介,api调用；Redis数据功能（String类型的数据处理）；List数据结构（及Java调用处理）；Hash数据结构；Set数据结构功能；sortedSet（有序集合）数

1、Redis和nosql简介,api调用

14.1/ nosql介绍

14.2/ redis介绍

14.2.1 简述

14.2.2 redis应用场景

14.2.3 redis的特性

14.3.Redis的api客户端连接

15、Redis数据功能（String类型的数据处理）

15.1 String类型的数据

16、List数据结构（及Java调用处理）

16.1 List图示

16.2 List功能演示

16.3 List的应用案例demo

1 需求描述

2 代码实现

17、Hash数据结构

17.1 Hash图示

17.2 Hash功能演示

18、Set数据结构功能

19、sortedSet（有序集合）数据结构

19.1 sortedSet图示

19.2 SortedSet功能演示

热门文章

最新文章

相关课程

相关电子书

相关实验场景