redis.properties
配置文件内容

redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=3000
redis.pool.testOnBorrow=false
redis.pool.testOnReturn=false


redis.ip=127.0.0.1
redis.port=6379
redis.port1=6380
redis.password=****


package com.szreach.rcrp.redis;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set; import org.apache.log4j.Logger; import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool; public class RedisUtil { private static final Logger log = Logger.getLogger(RedisUtil.class);
private static JedisPool jedisPool = null;
private static ShardedJedisPool shardedJedisPool = null;
/**
* 初始化Redis连接池
*/
static {
try {
// 加载redis配置文件
ResourceBundle bundle = ResourceBundle.getBundle("redis");
if (bundle == null) {
throw new IllegalArgumentException(
"[redis.properties] is not found!");
}
int maxActivity = Integer.valueOf(bundle
.getString("redis.pool.maxActive"));
int maxIdle = Integer.valueOf(bundle
.getString("redis.pool.maxIdle"));
long maxWait = Long.valueOf(bundle.getString("redis.pool.maxWait"));
boolean testOnBorrow = Boolean.valueOf(bundle
.getString("redis.pool.testOnBorrow"));
boolean onreturn = Boolean.valueOf(bundle
.getString("redis.pool.testOnReturn"));
// 创建jedis池配置实例
JedisPoolConfig config = new JedisPoolConfig();
// 设置池配置项值
config.setMaxActive(maxActivity);
config.setMaxIdle(maxIdle); //最大空闲连接数
config.setMaxWait(maxWait);
config.setTestOnBorrow(testOnBorrow);
config.setTestOnReturn(onreturn);
jedisPool = new JedisPool(config, bundle.getString("redis.ip"),
Integer.valueOf(bundle.getString("redis.port")), 10000,
bundle.getString("redis.password"));
// slave链接
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(bundle.getString("redis.ip"), Integer
.valueOf(bundle.getString("redis.port1"))));
shardedJedisPool = new ShardedJedisPool(config, shards);
log.info("初始化Redis连接池success");
} catch (Exception e) {
log.error("初始化Redis连接池 出错!", e);
}
} /**
* 获取Jedis实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
return resource;
} else {
return null;
}
} catch (Exception e) {
log.error("Redis缓存获取Jedis实例 出错!", e);
return null;
}
} /**
* 获取shardedJedis实例
*
* @return
*/
public static ShardedJedis getShardedJedis() {
try {
if (shardedJedisPool != null) {
ShardedJedis resource = shardedJedisPool.getResource();
return resource;
} else {
return null;
}
} catch (Exception e) {
log.error("Redis缓存获取shardedJedis实例 出错!", e);
return null;
}
} /**
* 释放jedis资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
} /**
* 释放shardedJedis资源
*
* @param jedis
*/
public static void returnResource(final ShardedJedis shardedJedis) {
if (shardedJedis != null) {
shardedJedisPool.returnResource(shardedJedis);
}
} /**
* 向缓存中设置字符串内容
*
* @param key
* key
* @param value
* value
* @return
* @throws Exception
*/
public static boolean set(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
if(jedis != null){
jedis.set(key, value);
}
return true;
} catch (Exception e) {
log.error("Redis缓存设置key值 出错!", e);
return false;
} finally {
returnResource(jedis);
}
} /**
* 判断key是否存在
*/
public static boolean exists(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis == null) {
return false;
} else {
return jedis.exists(key);
}
} catch (Exception e) {
log.error("Redis缓存判断key是否存在 出错!", e);
return false;
} finally {
returnResource(jedis);
}
} /**
* 删除缓存中的对象,根据key
* @param key
* @return
*/
public static boolean del(String key) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.del(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} //*******************key-value****************start /**
* 向缓存中设置对象
*
* @param key
* @param value
* @return
*/
public static boolean set(String key, Object value) {
Jedis jedis = null;
try {
String objectJson = JSONObject.fromObject(value).toString();
jedis = getJedis();
if (jedis != null) {
jedis.set(key, objectJson);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 根据key 获取内容
*
* @param key
* @return
*/
public static Object get(String key) {
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
Object value = jedis.get(key);
return value;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
shardedJedisPool.returnResource(jedis);
}
} /**
* 根据key 获取对象
*
* @param key
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T get(String key, Class<T> clazz) {
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
return (T) JSONObject.toBean(JSONObject.fromObject(jedis.get(key)), clazz);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//*******************key-value****************end //*************** 操作list****************start
/**
* 向缓存中设置对象
* @param key
* @param list
* T string calss
* @return
*/
public static <T> boolean setList(String key,List<T> list){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
for (T vz : list) {
if (vz instanceof String) {
jedis.lpush(key, (String) vz);
} else {
String objectJson = JSONObject.fromObject(vz).toString();
jedis.lpush(key, objectJson);
}
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> List<T> getListEntity(String key,Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
List<String> valueJson = jedis.lrange(key, 0, -1);
JSONArray json = new JSONArray();
json.addAll(valueJson);
JSONArray jsonArray = JSONArray.fromObject(json.toString());
return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static List<String> getListString(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
return jedis.lrange(key, 0, -1);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//*************** 操作list****************end //*************** 操作map****************start
public static <K,V> boolean setMap(String key,Map<String,V> map){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
if (kv.getValue() instanceof String) {
jedis.hset(key, kv.getKey(), (String) kv.getValue());
}else if (kv.getValue() instanceof List) {
jedis.hset(key, kv.getKey(), JSONArray.fromObject(kv.getValue()).toString());
} else {
jedis.hset(key, kv.getKey(), JSONObject.fromObject(kv.getValue()).toString());
}
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} public static boolean setMapKey(String key,String mapKey,Object value){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
if (value instanceof String) {
jedis.hset(key, mapKey, String.valueOf(value));
} else if (value instanceof List) {
jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
} else {
jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* seconds key和value 保存的有效时间(单位:秒)
* @return
*/
public static boolean setMapKeyExpire(String key,String mapKey,Object value, int seconds){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
if (value instanceof String) {
jedis.hset(key, mapKey, String.valueOf(value));
} else if (value instanceof List) {
jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
} else {
jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
}
jedis.expire(key, seconds);
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,V> getMap(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
return map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,V> getMapEntityClass(String key,Class<V> clazz){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
map.put(kv.getKey(), (V) JSONObject.toBean(JSONObject.fromObject(kv.getValue()), clazz));
}
return map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,List<V>> getMapList(String key,Class<V> clazz){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
JSONArray jsonArray = JSONArray.fromObject(kv.getValue());
map.put(kv.getKey(), (V) JSONArray.toCollection(jsonArray, clazz));
}
return (Map<String, List<V>>) map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> List<T> getMapKeyListEntity(String key,String mapKey,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
String valueJson = jedis.hget(key, mapKey);
JSONArray jsonArray = JSONArray.fromObject(valueJson);
return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> T getMapKeyEntity(String key,String mapKey,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if(jedis != null){
String valueJson=jedis.hget(key, mapKey);
return (T) JSONObject.toBean(JSONObject.fromObject(valueJson), entityClass);
}else{return null;}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static Object getMapKey(String key,String mapKey){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if(jedis != null){
return jedis.hget(key, mapKey);
}else{return null;}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static boolean delMapKey(String key,String mapKey){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.hdel(key, mapKey);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} public static boolean hexists(String key,String mapKey){
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.hexists(key,mapKey);
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
shardedJedisPool.returnResource(jedis);
}
}
//*************** 操作map****************end //***************计数器应用INCR,DECR****************begin
//Redis的命令都是原子性的,你可以轻松地利用INCR,DECR命令来构建计数器系统 /**
* incr(key):名称为key的string增1操作
*/
public static boolean incr(String key){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.incr(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* incrby(key, integer):名称为key的string增加integer
*/
public static boolean incrBy(String key, int value){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.incrBy(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* decr(key):名称为key的string减1操作
*/
public static boolean decr(String key){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.decr(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* decrby(key, integer):名称为key的string减少integer
*/
public static boolean decrBy(String key, int value){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.decrBy(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
}
//***************计数器应用INCR,DECR****************end //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************begin
/**
* 向名称为key的zset中添加元素member,score用于排序。
* 如果该元素已经存在,则根据score更新该元素的顺序
*/
public static boolean zadd(String key, double score, String member){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.zadd(key, score, member);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 删除名称为key的zset中的元素member
*/
public static boolean zrem(String key, String... members){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.zrem(key, members);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 返回集合中score在给定区间的元素
*/
public static Set<String> zrangeByScore(String key, double min, double max){
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.zrangeByScore(key, min, max);
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************end //***************sorted set 处理***************************************begin
//zset 处理
public static boolean zaddObject(String key, double score, Object value){
Jedis jedis = null;
try {
jedis = getJedis();
String objectJson = JSONObject.fromObject(value).toString();
jedis.zadd(key, score, objectJson);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* score值递减(从大到小)次序排列。
* @param key
* @param max score
* @param min score
* @param entityClass
* @return
*/
@SuppressWarnings("unchecked")
public static <T> List<T> zrevrangeByScore(String key,double max,double min,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
Set<String> set=jedis.zrevrangeByScore(key, max, min);
List<T> list=new ArrayList<T>();
for (String str : set) {
list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} /**
* score值递减(从大到小)次序排列。
* @param key
* @param max score
* @param min score
* @param offset count (类似mysql的 LIMIT)
* @param entityClass
* @return
*/
@SuppressWarnings("unchecked")
public static <T> List<T> zrevrangeByScore(String key,double max,double min,
int offset, int count,Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
Set<String> set=jedis.zrevrangeByScore(key, max, min,offset,count);
List<T> list=new ArrayList<T>();
for (String str : set) {
list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} //得到总记录数
public static long zcard(String key){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
return jedis.zcard(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
} //删除 元素
public static boolean zremObject(String key, Object value){
Jedis jedis = null;
try {
jedis = getJedis();
String objectJson = JSONObject.fromObject(value).toString();
jedis.zrem(key, objectJson);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} //统计zset集合中score某个范围内(1-5),元素的个数
public static long zcount(String key,double min, double max){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
return jedis.zcount(key,min,max);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
} //查看zset集合中元素的score
public static double zscore(String key,Object value){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
String objectJson = JSONObject.fromObject(value).toString();
return jedis.zscore(key,objectJson);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
}
//**************sorted set******************************************end //***********************Redis Set集合操作**************************begin
/**
* sadd:向名称为Key的set中添加元素,同一集合中不能出现相同的元素值。(用法:sadd set集合名称 元素值)
* @param key
* @param value
* @return
*/
public static boolean sadd(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.sadd(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* srem:删除名称为key的set中的元素。(用法:srem set集合名称 要删除的元素值)
*
* @param key
* @param value
* @return
*/
public static boolean srem(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.srem(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* sdiff:返回所有给定key与第一个key的差集。(用法:sdiff set集合1 set集合2)
*
* @param key1
* @param key2
* @return
*/
public static Set<String> sdiff(String key1, String key2) {
Jedis jedis = null;
Set<String> diffList = null;
try {
jedis = getJedis();
diffList = jedis.sdiff(key1, key2);
} catch (Exception e) {
e.printStackTrace();
} finally {
returnResource(jedis);
}
return diffList;
} /**
* sismember:判断某个值是否是集合的元素。(用法:sismember 集合1 指定的元素值)
*
* @param key
* @param value
* @return
*/
public static boolean sismember(String key, String value) {
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.sismember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* smembers(key) :返回名称为key的set的所有元素
*
* @param key
* @return
*/
public static Set<String> smembers(String key) {
Jedis jedis = null;
Set<String> list = null;
try {
jedis = getJedis();
list = jedis.smembers(key);
} catch (Exception e) {
e.printStackTrace();
} finally {
returnResource(jedis);
}
return list;
} //***********************Redis Set集合操作****************************end
}

RedisPool操作Redis,工具类实例的更多相关文章

  1. Java操作Redis工具类

    依赖 jar 包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis< ...

  2. Jedis 操作 Redis 工具类

    配置类 pom.xml pom.xml 里配置依赖 <dependency> <groupId>redis.clients</groupId> <artifa ...

  3. Redis操作Set工具类封装,Java Redis Set命令封装

    Redis操作Set工具类封装,Java Redis Set命令封装 >>>>>>>>>>>>>>>>& ...

  4. Redis操作List工具类封装,Java Redis List命令封装

    Redis操作List工具类封装,Java Redis List命令封装 >>>>>>>>>>>>>>>> ...

  5. Redis操作Hash工具类封装,Redis工具类封装

    Redis操作Hash工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>> ...

  6. Redis操作字符串工具类封装,Redis工具类封装

    Redis操作字符串工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>>& ...

  7. redistemplate优雅地操作redis redis 工具类

    参考:https://www.cnblogs.com/superfj/p/9232482.html redis 工具类 package com.service; import org.springfr ...

  8. redis 工具类 单个redis、JedisPool 及多个redis、shardedJedisPool与spring的集成配置

    http://www.cnblogs.com/edisonfeng/p/3571870.html http://javacrazyer.iteye.com/blog/1840161 http://ww ...

  9. Redis 工具类 java 实现的redis 工具类

    最近了解了一下非关系型数据库 redis 会使用简单的命令 在自己本地电脑 使用时必须先启动服务器端 在启动客户端 redis 简介 Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内 ...

  10. springboot2.2.2企业级项目整合redis与redis 工具类大全

    1.springboot2.2.2整合redis教程很多,为此编写了比较完整的redis工具类,符合企业级开发使用的工具类 2.springboot与redis maven相关的依赖 <depe ...

随机推荐

  1. robotframework自动化系统:操作mysql数据库

    随着项目自动化深入和不断完善,大部分功能都已经能完成了自动化的操作:但是在设备添加的时候,遇到了难题.添加设备的时候mac必须是服务器设备管理中已经存在的mac地址,且是没有关联或绑定用户的设备信息. ...

  2. django-Ajax发送POST请求(csrf跨站请求的三种方式),文件的上传

    第一种 <script> $(".eq").on("click",function () { $.ajax({ url:"/eq/&quo ...

  3. 【转】如何使用Git上传本地项目到github?(mac版)

    原文链接:http://www.cnblogs.com/lijiayi/p/pushtogithub.html 在此假设你已经在 github 上创建好了一个项目,像这样: 并且你已经完成了自己的项目 ...

  4. POJ 1151 Wormholes spfa+反向建边+负环判断+链式前向星

    Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 49962   Accepted: 18421 Descr ...

  5. C++反汇编第四讲,反汇编中识别继承关系,父类,子类,成员对象

    C++反汇编第四讲,反汇编中识别继承关系,父类,子类,成员对象 讲解目录: 1.各类在内存中的表现形式   备注: 主要复习开发知识,和反汇编没有关系,但是是理解反汇编的前提.     2.子类继承父 ...

  6. Python冒号的解释

    1. "没什么首次没有为第二个,跳了三个".它得到的切片序列的每一个第三个项目. 扩展片是你想要的.新在Python 2.3 2. Python的序列切片地址可以写成[开始:结束: ...

  7. Python的Web应用框架--Django

    一:简介 python的web框架有很多,个人查了一下,有Django.Pylons. Tornado.Bottle和Flask等,其中使用人数最多的是Django,而我学习Django也是因为ope ...

  8. ios7 以后准确获取iphone设备的MAC(物理地址)

    通过参考 钉钉 项目,知道是通过wifi拿到路由的MAC地址.那么可不可以拿到iphone 设备的MAC 地址呢? 经过一番搜索,发现所有文章都是针对 ios 7 以前 可以拿到. 而且方法也都是同一 ...

  9. 洛谷 P3928 Sequence

    题目描述 小强喜欢数列.有一天,他心血来潮,写下了三个长度均为n的数列. 阿米巴也很喜欢数列.但是他只喜欢其中一种,波动数列. 阿米巴把他的喜好告诉了小强.小强便打算找出这三个数列内的最长波动数列. ...

  10. day3、Linux快捷键及vim命令快捷键

    Linux命令行快捷键 快捷键: tab键  自动补全路径 目录  名字,  自动不全命令 快捷键: ctrl +l(小写) 清屏 . ctrl +c 取消当前操作 快捷键: ctrl +d(小写) ...