Redis官网https://redis.io/

以下内容未全部验证,如有问题请指出

 //static NewtonsoftSerializer serializer = new NewtonsoftSerializer();
//static StackExchangeRedisCacheClient cacheClient = new StackExchangeRedisCacheClient(serializer);
//private static IDatabase db = cacheClient.Database; private static string connstr = System.Configuration.ConfigurationManager.AppSettings["redisCacheClient"];// "127.0.0.1:6379,allowadmin=true";
private static ConnectionMultiplexer conn = ConnectionMultiplexer.Connect(connstr);
private static IDatabase db = conn.GetDatabase(1); /// <summary>
/// 获取系统的redis key前缀
/// </summary>
/// <param name="resourceid">资源Id</param>
/// <returns></returns>
public static string GetMyKey(string resourceid = "")
{ string Key = "report_";
if (!string.IsNullOrWhiteSpace(resourceid))
{
Key = string.Format("report_res_{0}", resourceid);
}
return Key;
} #region String 可以设置过期时间 同步 /// <summary>
/// 保存单个key value
/// </summary>
/// <param name="key">Redis Key</param>
/// <param name="value">保存的值</param>
/// <param name="expiry">过期时间</param>
/// <returns></returns>
public static bool SetStringKey(string key, string value, TimeSpan? expiry = default(TimeSpan?))
{ return db.StringSet(key, value, expiry);
} /// <summary>
/// 保存多个key value
/// </summary>
/// <param name="arr">key</param>
/// <returns></returns>
public static bool SetStringKey(KeyValuePair<RedisKey, RedisValue>[] arr)
{
return db.StringSet(arr);
} /// <summary>
/// 保存一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static bool SetStringKey<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
{
string json = JsonConvert.SerializeObject(obj);
return db.StringSet(key, json, expiry);
} /// <summary>
/// 获取单个key的值
/// </summary>
/// <param name="key">Redis Key</param>
/// <returns></returns> public static RedisValue GetStringKey(string key)
{
return db.StringGet(key);
} /// <summary>
/// 获取多个Key
/// </summary>
/// <param name="listKey">Redis Key集合</param>
/// <returns></returns>
public static RedisValue[] GetStringKey(List<RedisKey> listKey)
{
return db.StringGet(listKey.ToArray());
} /// <summary>
/// 获取一个key的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static T GetStringKey<T>(string key)
{
return JsonConvert.DeserializeObject<T>(db.StringGet(key));
}
/// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public double StringIncrement(string key, double val = 1)
{
return db.StringIncrement(key, val);
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public double StringDecrement(string key, double val = 1)
{
return db.StringDecrement(key, val);
} #endregion #region String 可以设置过期时间 异步 /// <summary>
/// 保存单个key value
/// </summary>
/// <param name="key">Redis Key</param>
/// <param name="value">保存的值</param>
/// <param name="expiry">过期时间</param>
/// <returns></returns>
public static async Task<bool> SetStringKeyAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
{ return await db.StringSetAsync(key, value, expiry);
} /// <summary>
/// 保存多个key value
/// </summary>
/// <param name="arr">key</param>
/// <returns></returns>
public static async Task<bool> SetStringKeyAsync(KeyValuePair<RedisKey, RedisValue>[] arr)
{
return await db.StringSetAsync(arr);
} /// <summary>
/// 保存一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static async Task<bool> SetStringKeyAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
{
string json = JsonConvert.SerializeObject(obj);
return await db.StringSetAsync(key, json, expiry);
} /// <summary>
/// 获取单个key的值
/// </summary>
/// <param name="key">Redis Key</param>
/// <returns></returns> public static async Task<RedisValue> GetStringKeyAsync(string key)
{
return await db.StringGetAsync(key);
} /// <summary>
/// 获取多个Key
/// </summary>
/// <param name="listKey">Redis Key集合</param>
/// <returns></returns>
public static async Task<RedisValue[]> GetStringKeyAsync(List<RedisKey> listKey)
{
return await db.StringGetAsync(listKey.ToArray());
} /// <summary>
/// 获取一个key的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static async Task<T> GetStringKeyAsync<T>(string key)
{
return JsonConvert.DeserializeObject<T>(await db.StringGetAsync(key));
}
/// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public async Task<double> StringIncrementAsync(string key, double val = 1)
{
return await db.StringIncrementAsync(key, val);
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public async Task<double> StringDecrementAsync(string key, double val = 1)
{
return await db.StringDecrementAsync(key, val);
}
#endregion #region Hash 同步
/// <summary>
/// 存储数据到hash表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool HashSet1<T>(string key, string dataKey, List<T> t)
{
string json = "";
foreach (var item in t)
{
json = JsonConvert.SerializeObject(item);
//listHashEntry.Add(new HashEntry(getModelId(item), json));
}
return db.HashSet(key, dataKey, json); //return await ({
// string json = ConvertJson(t);
// return db.HashSetAsync(key, dataKey, json);
//});
}
/// <summary>
/// 保存一个集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">Redis Key</param>
/// <param name="list">数据集合</param>
/// <param name="getModelId"></param>
public static void HashSet<T>(string key, List<T> list, Func<T, string> getModelId)
{
List<HashEntry> listHashEntry = new List<HashEntry>();
foreach (var item in list)
{
string json = JsonConvert.SerializeObject(item);
listHashEntry.Add(new HashEntry(getModelId(item), json));
}
db.HashSet(key, listHashEntry.ToArray());
} /// <summary>
/// 获取Hash中的单个key的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">Redis Key</param>
/// <param name="hasFildValue">RedisValue</param>
/// <returns></returns>
public static T GetHashKey<T>(string key, string hasFildValue)
{
if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
{
RedisValue value = db.HashGet(key, hasFildValue);
if (!value.IsNullOrEmpty)
{
return JsonConvert.DeserializeObject<T>(value);
}
}
return default(T);
} /// <summary>
/// 获取hash中的多个key的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">Redis Key</param>
/// <param name="listhashFields">RedisValue value</param>
/// <returns></returns>
public static List<T> GetHashKey<T>(string key, List<RedisValue> listhashFields)
{
List<T> result = new List<T>();
if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
{
RedisValue[] value = db.HashGet(key, listhashFields.ToArray());
foreach (var item in value)
{
if (!item.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item));
}
}
}
return result;
} /// <summary>
/// 获取hashkey所有Redis key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> GetHashAll<T>(string key)
{
List<T> result = new List<T>();
RedisValue[] arr = db.HashKeys(key);
foreach (var item in arr)
{
if (!item.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item));
}
}
return result;
} /// <summary>
/// 获取hashkey所有的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> HashGetAll<T>(string key)
{
List<T> result = new List<T>();
HashEntry[] arr = db.HashGetAll(key);
foreach (var item in arr)
{
if (!item.Value.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item.Value));
}
}
return result;
} /// <summary>
/// 删除hasekey
/// </summary>
/// <param name="key"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public static bool DeleteHase(RedisKey key, RedisValue hashField)
{
return db.HashDelete(key, hashField);
} #endregion #region Hash 异步
/// <summary>
/// 存储数据到hash表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="t"></param>
/// <returns></returns>
public static async Task<bool> HashSetAsync<T>(string key, string dataKey, List<T> t)
{
string json = "";
foreach (var item in t)
{
json = JsonConvert.SerializeObject(item);
}
return await db.HashSetAsync(key, dataKey, json); } /// <summary>
/// 获取Hash中的单个key的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">Redis Key</param>
/// <param name="hasFildValue">RedisValue</param>
/// <returns></returns>
public static async Task<T> GetHashKeyAsync<T>(string key, string hasFildValue)
{
if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
{
RedisValue value = await db.HashGetAsync(key, hasFildValue);
if (!value.IsNullOrEmpty)
{
return JsonConvert.DeserializeObject<T>(value);
}
}
return default(T);
} /// <summary>
/// 获取hash中的多个key的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">Redis Key</param>
/// <param name="listhashFields">RedisValue value</param>
/// <returns></returns>
public static async Task<List<T>> GetHashKeyAsync<T>(string key, List<RedisValue> listhashFields)
{
List<T> result = new List<T>();
if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
{
RedisValue[] value = await db.HashGetAsync(key, listhashFields.ToArray());
foreach (var item in value)
{
if (!item.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item));
}
}
}
return result;
} /// <summary>
/// 获取hashkey所有Redis key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static async Task<List<T>> GetHashAllAsync<T>(string key)
{
List<T> result = new List<T>();
RedisValue[] arr =await db.HashKeysAsync(key);
foreach (var item in arr)
{
if (!item.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item));
}
}
return result;
} /// <summary>
/// 获取hashkey所有的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static async Task<List<T>> HashGetAllAsync<T>(string key)
{
List<T> result = new List<T>();
HashEntry[] arr =await db.HashGetAllAsync(key);
foreach (var item in arr)
{
if (!item.Value.IsNullOrEmpty)
{
result.Add(JsonConvert.DeserializeObject<T>(item.Value));
}
}
return result;
} /// <summary>
/// 删除hasekey
/// </summary>
/// <param name="key"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public static async Task<bool> DeleteHaseAsync(RedisKey key, RedisValue hashField)
{
return await db.HashDeleteAsync(key, hashField);
} #endregion #region key 同步 /// <summary>
/// 删除单个key
/// </summary>
/// <param name="key">redis key</param>
/// <returns>是否删除成功</returns>
public static bool KeyDelete(string key)
{
return db.KeyDelete(key);
} /// <summary>
/// 删除多个key
/// </summary>
/// <param name="keys">rediskey</param>
/// <returns>成功删除的个数</returns>
public static long keyDelete(RedisKey[] keys)
{
return db.KeyDelete(keys);
} /// <summary>
/// 判断key是否存储
/// </summary>
/// <param name="key">redis key</param>
/// <returns></returns>
public static bool KeyExists(string key)
{
return db.KeyExists(key);
} /// <summary>
/// 重新命名key
/// </summary>
/// <param name="key">就的redis key</param>
/// <param name="newKey">新的redis key</param>
/// <returns></returns>
public static bool KeyRename(string key, string newKey)
{
return db.KeyRename(key, newKey);
} /// <summary>
/// 设置Key的时间
/// </summary>
/// <param name="key">redis key</param>
/// <param name="expiry"></param>
/// <returns></returns>
public static bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
{
return db.KeyExpire(key, expiry);
}
#endregion #region key 异步 /// <summary>
/// 删除单个key
/// </summary>
/// <param name="key">redis key</param>
/// <returns>是否删除成功</returns>
public static async Task<bool> KeyDeleteAsync(string key)
{
return await db.KeyDeleteAsync(key);
} /// <summary>
/// 删除多个key
/// </summary>
/// <param name="keys">rediskey</param>
/// <returns>成功删除的个数</returns>
public static async Task<long> keyDeleteAsync(RedisKey[] keys)
{
return await db.KeyDeleteAsync(keys);
} /// <summary>
/// 判断key是否存储
/// </summary>
/// <param name="key">redis key</param>
/// <returns></returns>
public static async Task<bool> KeyExistsAsync(string key)
{
return await db.KeyExistsAsync(key);
} /// <summary>
/// 重新命名key
/// </summary>
/// <param name="key">就的redis key</param>
/// <param name="newKey">新的redis key</param>
/// <returns></returns>
public static async Task<bool> KeyRenameAsync(string key, string newKey)
{
return await db.KeyRenameAsync(key, newKey);
} /// <summary>
/// 设置Key的时间
/// </summary>
/// <param name="key">redis key</param>
/// <param name="expiry"></param>
/// <returns></returns>
public static async Task<bool> KeyExpireAsync(string key, TimeSpan? expiry = default(TimeSpan?))
{
return await db.KeyExpireAsync(key, expiry);
}
#endregion #region List 同步 /// <summary>
/// 移除指定ListId的内部List的值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListRemove<T>(string key, T value)
{
db.ListRemove(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 获取指定key的List
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<T> ListRange<T>(string key)
{
var values = db.ListRange(key);
List<T> result = new List<T>();
foreach (var item in values)
{
var model = JsonConvert.DeserializeObject<T>(item);
result.Add(model);
}
return result;
} /// <summary>
/// 入队
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListRightPush<T>(string key, T value)
{
db.ListRightPush(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 出队
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T ListRightPop<T>(string key)
{
var value = db.ListRightPop(key);
return JsonConvert.DeserializeObject<T>(value);
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public long ListLength(string key)
{
return db.ListLength(key);
} #endregion 同步方法 #region List 异步 /// <summary>
/// 移除指定ListId的内部List的值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<long> ListRemoveAsync<T>(string key, T value)
{
return await db.ListRemoveAsync(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 获取指定key的List
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<List<T>> ListRangeAsync<T>(string key)
{
var values =await db.ListRangeAsync(key);
List<T> result = new List<T>();
foreach (var item in values)
{
var model = JsonConvert.DeserializeObject<T>(item);
result.Add(model);
}
return result;
} /// <summary>
/// 入队
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<long> ListRightPushAsync<T>(string key, T value)
{
return await db.ListRightPushAsync(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 出队
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public async Task<T> ListRightPopAsync<T>(string key)
{
var value = await db.ListRightPopAsync(key);
return JsonConvert.DeserializeObject<T>(value);
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<long> ListLengthAsync(string key)
{
return await db.ListLengthAsync(key);
} #endregion 异步方法 #region SortedSet 同步 /// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="score"></param>
public static bool SortedSetAdd<T>(string key, T value, double score)
{
return db.SortedSetAdd(key, JsonConvert.SerializeObject(value), score);
} /// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static bool SortedSetRemove<T>(string key, T value)
{
return db.SortedSetRemove(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 获取全部
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> SortedSetRangeByRank<T>(string key)
{
var values = db.SortedSetRangeByRank(key); List<T> result = new List<T>();
foreach (var item in values)
{
var model = JsonConvert.DeserializeObject<T>(item);
result.Add(model);
}
return result;
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static long SortedSetLength(string key)
{
return db.SortedSetLength(key);
} #endregion 同步方法 #region SortedSet 异步 /// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="score"></param>
public static async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
{
return await db.SortedSetAddAsync(key, JsonConvert.SerializeObject(value), score);
} /// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
{
return await db.SortedSetRemoveAsync(key, JsonConvert.SerializeObject(value));
} /// <summary>
/// 获取全部
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
{
var values = await db.SortedSetRangeByRankAsync(key);
List<T> result = new List<T>();
foreach (var item in values)
{
var model = JsonConvert.DeserializeObject<T>(item);
result.Add(model);
}
return result;
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static async Task<long> SortedSetLengthAsync(string key)
{
return await db.SortedSetLengthAsync(key);
} #endregion 异步方法 /// <summary>
/// 追加值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public static void StringAppend(string key, string value)
{
////追加值,返回追加后长度
long appendlong = db.StringAppend(key, value);
}

功能比较全的StackExchange.Redis封装帮助类(.Net/C#)的更多相关文章

  1. [C#] 使用 StackExchange.Redis 封装属于自己的 Helper

    使用 StackExchange.Redis 封装属于自己的 Helper 目录 核心类 ConnectionMultiplexer 字符串(String) 哈希(Hash) 列表(List) 有序集 ...

  2. [C#] 使用 StackExchange.Redis 封装属于自己的 RedisHelper

    使用 StackExchange.Redis 封装属于自己的 RedisHelper 目录 核心类 ConnectionMultiplexer 字符串(String) 哈希(Hash) 列表(List ...

  3. 使用 StackExchange.Redis 封装属于自己的 RedisHelper

    目录 核心类 ConnectionMultiplexer 字符串(String) 哈希(Hash) 列表(List) 有序集合(sorted set) Key 操作 发布订阅 其他 简介 目前 .NE ...

  4. StackExchange.Redis 封装

    博主最近开始玩Redis啊~~ 看了很多Redis的文章,感觉有点云里雾里的,之前看到是ServiceStack.Redis,看了一些大佬封装的Helper类,还是懵懵的QAQ 没办法啊只能硬着**上 ...

  5. c#使用 StackExchange.Redis 封装 RedisHelper

    公司一直在用.net自带的缓存,大家都知道.net自带缓存的缺点,就不多说了,不知道的可以查一查,领导最近在说分布式缓存,我们选的是redis,领导让我不忙的时候封装一下,搜索了两天,选了选第三方的插 ...

  6. PHP 操作redis 封装的类 转的

    <?php/** * Redis 操作,支持 Master/Slave 的负载集群 * * @author jackluo */class RedisCluster{           // ...

  7. DotNet Core 使用 StackExchange.Redis 简单封装和实现分布式锁

    前言 公司的项目以前一直使用 CSRedis 这个类库来操作 Redis,最近增加了一些新功能,会存储一些比较大的数据,内测的时候发现其中有两台服务器会莫名的报错 Unexpected respons ...

  8. redis的安装、启动、主从配置,以及.Net下StackExchange.Redis的使用

    开门见山,Linux下配个环境真是苦逼死了,这里记录一下,囧 一.环境 服务端:Ubuntu16.04 LTS(虚拟机,redis官方没有window发布版本,而且在Linux下运行更稳定) 客户端: ...

  9. C# StackExchange.Redis 用法总结

    安装 StackExchange.Redis 在 NuGet 中搜索 StackExchange.Redis 和 Newtonsoft.Json,直接点击按钮安装即可. StackExchange.R ...

随机推荐

  1. 小甲鱼Python第十八讲课后习题

    笔记: 1.函数与过程:过程(procedure)是简单的,特殊且没有返回值的:函数(Function)有返回值 Python严格来说只有函数没有过程 2.局部变量:在局部生效如在函数中定义的变量 3 ...

  2. Linux下的文件切割和文件合并

    linux下文件分割可以通过split命令来实现,可以指定按行数分割和按大小分割两种模式.Linux下文件合并可以通过cat命令来实现. 在Linux下用split进行文件分割: ①:指定分割后文件行 ...

  3. Git 简单入门(一)

    Git 简介 Git 是目前世界上最先进的分布式版本控制系统 分布式和集中式 集中式版本控制系统 版本库放在中央服务器,干活之前先从中央服务器取得最新版本,然后开始干活,活干完后将自己干的成果推送给中 ...

  4. javascript对象序列化(对象与JSON字符串的互换)

    前一段时间用到h5的本地存储---需要把某个js对象存储在浏览器的本地存储中,用到了javascript对象的序列化与反序列化 所谓的序列化就是将对象的状态信息转换为可以存储或传输的形式的过程,基本上 ...

  5. 解决Tomcatt下连接数据库的classNoFount问题

    在数据库连接单独使用的时候.即作为一个独立类建立在mian方法中,可以正确的使用.例:连接MySql数据库 import java.sql.*; public class SQLtest { // J ...

  6. python发送短信验证码

    业务: 手机端点击发送验证码,请求发送到python端,由python调用第三方平台(我们使用的是榛子云短信http://smsow.zhenzikj.com)的短信接口,生成验证码并发送. SDK下 ...

  7. 加密传输:每位数字+6,然后用除以9的余数代替该数字, 在把第一位和第四位交换,第二位和第三位交换,例如3276->3840

    /** * @author:(LiberHome) * @date:Created in 2019/3/6 10:00 * @description: * @version:$ */ /*今日目标:5 ...

  8. Kruskal模板

    Kruskal模板 struct Edge { int from,to,v; }edge[maxn*10]; int fa[maxn]; int n,m; int find(int x) { retu ...

  9. treesoft,couchDB,

    下载 docker 镜像:docker pull docker.io/lu566/treesoft:1.0启动容器:docker run -d -p 127.0.0.1:18080:8080 dock ...

  10. [Day19]Collection接口中的子类(List集合、Set集合)

    1.List接口 1.1API总结 (1)是一个元素存取有序的集合 (2)是一个带有索引的集合,通过索引可以精确的操作集合中的元素 (3)集合中有可以重复的元素,通过元素的equals方法,来比较是否 ...