数组的增删改查操作
做批量数据录入时需要对json内的数组进行增删改查操作，splice还是很强大的记录一下使用方法。
var lang = ["php","java","javascript"];
var removed = lang.splice(2,1);
console.log(lang); //php,javascript
//console.log(removed); //java ,返回删除的项
var insert = lang.splice(0,0,""); //从第0个位置开始插入
//alert(insert); //返回空数组
console.log(lang); //asp,php,javascript
var replace = lang.splice(1,1,"","ruby"); //删除一项，插入两项
//alert(lang); //asp,c#,ruby
console.log(replace); //php,返回删除的项
另外，json多项的增删改查也贴上，备用：
* Json对象操作，增删改查
* @author lellansin
* @version 0.1
* 解决一些常见的问题
* get/set 解决获取和设置时，无节点中断的问题
可以创建多级节点，若存在则覆盖新值
删除节点及其子节点
* print_r 格式化输出对象（调试用）
* 实例见底部
function Json() {
* 获取Json对象中的某个节点
* 例如：json.get(Data, 'country', 'province', 'city');
* 结果则返回 Data['country']['province']['city']
* 无则返回false
Json.prototype.get = function(obj, key) {
var args = this.get.
var result =
for (var i = 1; i < args. i++) {
result = result[args[i]];
if (result === undefined) {
* 设置Json对象中的某个节点
* 例如：obj.set(data, "ENTRY", "FA_TOKEN_INVALID", 1234);
* 将 data['ENTRY']['FA_TOKEN_INVALID'] 设置为1234
* 成功true, 失败false
Json.prototype.set = function(obj, key) {
var args = this.set.
if (ergodic_set(obj, args, 1)) {
* 在Json对象中创建节点(若存在则覆盖值)
* 例如：obj.create(data, 'add', 'hello', 'test', 120);
* 添加 data['create']['hello']['test'] 节点并设置值为 120
* 成功true, 失败false
Json.prototype.create = function(obj, key) {
var args = this.create.
if (ergodic_create(obj, args, 1)) {
* 在Json对象中删除节点
* 例如：obj.delete(prods, 'grade', 'math');
* 成功true, 失败false
Json.prototype.delete = function(obj, key) {
var args = this.delete.
if (ergodic_delete(obj, args, 1)) {
* 返回Json对象的字符串形式（封装 ECMAScript 库函数）
Json.prototype.getStr = function(obj) {
return JSON.stringify(obj);
* 解析字符串返回Json对象（封装 ECMAScript 库函数）
Json.prototype.getJson = function(str) {
return JSON.parse(str);
* 格式化输出Json对象
Json.prototype.print_r = function(obj) {
console.log("{")
ergodic_print(obj, "");
console.log("}")
function ergodic_print(obj, indentation) {
var indent = " " +
if (obj.constructor == Object) {
for (var p in obj) {
if (obj[p].constructor == Array || obj[p].constructor == Object) {
console.log(indent + "[" + p + "] => " + typeof(obj) + "");
console.log(indent + "{");
ergodic_print(obj[p], indent);
console.log(indent + "}");
} else if (obj[p].constructor == String) {
console.log(indent + "[" + p + "] => '" + obj[p] + "'");
console.log(indent + "[" + p + "] => " + obj[p] + "");
function ergodic_set(obj, args, floor) {
if (obj.constructor == Object) {
for (var tmpKey in obj) {
if (tmpKey == args[floor]) {
if (floor < args.length - 2) {
return ergodic_set(obj[tmpKey], args, floor + 1);
// 此时参数floor为倒数第二个，加1值为最后一个
obj[tmpKey] = args[floor + 1];
console.log("成功设置，返回true");
function ergodic_create(obj, args, floor) {
if (obj.constructor == Object) {
for (var tmpKey in obj) {
if (tmpKey == args[floor]) {
if (floor < args.length - 2) {
return ergodic_create(obj[tmpKey], args, floor + 1);
obj[tmpKey] = args[floor + 1];
// 节点不存在，创建新节点
if (floor < args.length - 1) {
var jsonstr = getJsonFormat(args[args.length - 1]);
for (var i = args.length - 2; i > i--) {
jsonstr = '{"' + args[i] + '":' + jsonstr + '}';
// 使用eval解析第三方Json数据时，可能会执行恶意代码
// var node = eval('(' + jsonstr + ')');
var node = JSON.parse(jsonstr);
obj[args[floor]] =
function ergodic_delete(obj, args, floor) {
if (obj.constructor == Object) {
for (var tmpKey in obj) {
if (tmpKey == args[floor]) {
if (floor < args.length - 1) {
return ergodic_delete(obj[tmpKey], args, floor + 1);
delete obj[tmpKey];
function getJsonFormat(param) {
if (param.constructor == String) {
return '"' + param + '"';
* 使用实例
var data = {};
var prods = {
'name': 'Alan',
'grade': {
'Chinese': 120,
'math': 130,
'competition': {
'NOI': 'First prize'
var json = new Json();
console.log("获取Json中节点");
console.log(json.get(data));
console.log(json.create(data, "0",""));
console.log(json.set(data, "0", prods));
console.log(json.create(data, "1",""));
console.log(json.set(data, "1", prods));
console.log(json.create(data, "2",""));
console.log(json.set(data, "2", prods));
console.log(json.get(data));
json.print_r(data);*/
console.log(json.get(data, "OK")); // 200
console.log(json.get(data, "ENTRY", "FA_TOKEN_INVALID"));
console.log(json.get(data, "TEST", "获取没有的节点")); // false 没有的节点返回 false
console.log("设置Json中节点");
console.log(json.set(data, "ENTRY", "FA_TOKEN_INVALID", 1234));
console.log(json.get(data, "ENTRY", "FA_TOKEN_INVALID"));
获取刚设置的节点
console.log(json.set(data, "ENTRY", "测试设置没有的节点", 1234)); // false
console.log("创建新的Json节点");
var prods = {
'name': 'Alan',
'grade': {
'Chinese': 120,
'math': 130,
'competition': {
'NOI': 'First prize'
console.log(json.create(prods, 'create', 'hello', 'test', 120));
console.log(json.create(prods, 'create', 'hello', 'test2', '通过')); // true
console.log("格式化输出节点");
json.print_r(prods);
console.log("删除节点");
console.log(json.delete(prods, 'grade', 'math')); // true
console.log(json.delete(prods, 'grade', 'competition'));
console.log(json.delete(prods, 'grade', '删除没有的节点')); // false
json.print_r(prods);
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'学生信息的增删改查(java)_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
学生信息的增删改查(java)
上传于|0|0|文档简介
&&java做的,对学生信息进行增删改查,并连接access数据库。
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩3页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢安全检查中...
请打开浏览器的javascript，然后刷新浏览器
1398.org 浏览器安全检查中...
还剩 5 秒&java增删改查_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！Redis之java增删改查 - 推酷
Redis之java增删改查
jedis是java的redis客户端实现，要使用jedis需要添加jedis的maven依赖：
&dependency&
&groupId&redis.clients&/groupId&
&artifactId&jedis&/artifactId&
&version&2.4.2&/version&
&/dependency&redis最简单的使用：Jedis jedis = new Jedis(&localhost&);//使用redis默认端口6379
jedis.set(&foo&, &bar&);
String value = jedis.get(&foo&);但是jedis对象不是线程安全的，在多线程环境下会傻逼，所以官方提供了一个线程安全的连接池:JedisPool pool = new JedisPool(new JedisPoolConfig(), &localhost&);可以直接设置成静态的全局变量。因为一直使用spring，配置一个：&bean id=&jedisPoolConfig& class=&redis.clients.jedis.JedisPoolConfig&&
&property name=&maxTotal& value=&${redis.maxTotal}&/&
&property name=&maxIdle& value=&${redis.maxIdle}&/&
&property name=&maxWaitMillis& value=&${redis.maxWaitMillis}&/&
&property name=&testOnBorrow& value=&true&/&
&property name=&testOnReturn& value=&true&/&
&bean id=&jedisPool& class=&redis.clients.jedis.JedisPool&&
&constructor-arg index=&0& ref=&jedisPoolConfig&/&
&constructor-arg index=&1& value=&${redis.hostname}& /&
&constructor-arg index=&2& value=&${redis.port}& /&
&/bean&ok，可以开始干活了：Jedis jedis = jedisPool.getResource();
/// ... do stuff here ... for example
jedis.set(&foo&, &bar&);
String foobar = jedis.get(&foo&);
jedis.zadd(&sose&, 0, &car&); jedis.zadd(&sose&, 0, &bike&);
Set&String& sose = jedis.zrange(&sose&, 0, -1);
} catch (JedisConnectionException e) {
// returnBrokenResource when the state of the object is unrecoverable
if (null != jedis) {
pool.returnBrokenResource(jedis);
} finally {
/// ... it's important to return the Jedis instance to the pool once you've finished using it
if (null != jedis)
pool.returnResource(jedis);
/// ... when closing your application:
pool.destroy();//如果不destroy的话，连接池中的connection将会一直连着，直到超时为止，所以在spring容器写一个destroy方法还是有必要的redis事务支持(transactions)。说白了就是：我要同时干好几件事，期间不能干别的，我就把这几件事放同一个事物里。Transaction t = jedis.multi();
t.set(&aaa&, &111&);
t.set(&bbb&, &222&);
t.exec();分布式客户端(ShardedJedis)我个人理解这东西就是个负载均衡，利用xxx哈希算法，均匀的把key存到不同redis服务器上jedisPoolConfig与上面的一样，第二个参数是redis服务器的列表&bean id=&shardedJedisPool& class=&redis.clients.jedis.ShardedJedisPool&&
&constructor-arg index=&0& ref=&jedisPoolConfig&/&
&constructor-arg index=&1&&
&bean class=&redis.clients.jedis.JedisShardInfo&&
&constructor-arg index=&0& value=&${redis.hostname}&/&
&constructor-arg index=&1& value=&${redis.port}&/&
&/constructor-arg&
&/bean&使用：ShardedJedis jedis = pool.getResource();
jedis.set(&a&, &foo&);
.... // do your work here
pool.returnResource(jedis);
.... // a few moments later
ShardedJedis jedis2 = pool.getResource();
jedis.set(&z&, &bar&);
pool.returnResource(jedis);
pool.destroy();因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。import java.util.ArrayL
import java.util.HashM
import java.util.I
import java.util.L
import java.util.M
import java.util.S
import redis.clients.jedis.J
public class JedisDemo {
public void test1(){
redis = new Jedis (&192.168.10.64&,6379);//连接redis
redis.auth(&redis&);//验证密码
/* -----------------------------------------------------------------------------------------------------------
Set keys = redis.keys(&*&);//列出所有的key，查找特定的key如：redis.keys(&foo&)
Iterator t1=keys.iterator() ;
while(t1.hasNext()){
Object obj1=t1.next();
System.out.println(obj1);
//DEL 移除给定的一个或多个key。如果key不存在，则忽略该命令。
redis.del(&name1&);
//TTL 返回给定key的剩余生存时间(time to live)(以秒为单位)
redis.ttl(&foo&);
//PERSIST key 移除给定key的生存时间。
redis.persist(&foo&);
//EXISTS 检查给定key是否存在。
redis.exists(&foo&);
//MOVE key db
将当前数据库(默认为0)的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
redis.move(&foo&, 1);//将foo这个key，移动到数据库1
//RENAME key newkey
将key改名为newkey。当key和newkey相同或者key不存在时，返回一个错误。当newkey已经存在时，RENAME命令将覆盖旧值。
redis.rename(&foo&, &foonew&);
//TYPE key 返回key所储存的值的类型。
System.out.println(redis.type(&foo&));//none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)
//EXPIRE key seconds 为给定key设置生存时间。当key过期时，它会被自动删除。
redis.expire(&foo&, 5);//5秒过期
//EXPIREAT EXPIREAT的作用和EXPIRE一样，都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。
//一般SORT用法 最简单的SORT使用方法是SORT key。
redis.lpush(&sort&, &1&);
redis.lpush(&sort&, &4&);
redis.lpush(&sort&, &6&);
redis.lpush(&sort&, &3&);
redis.lpush(&sort&, &0&);
List list = redis.sort(&sort&);//默认是升序
for(int i=0;i&list.size();i++){
System.out.println(list.get(i));
/* -----------------------------------------------------------------------------------------------------------
STRING 操作
//SET key value将字符串值value关联到key。
redis.set(&name&, &wangjun1&);
redis.set(&id&, &123456&);
redis.set(&address&, &guangzhou&);
//SETEX key seconds value将值value关联到key，并将key的生存时间设为seconds(以秒为单位)。
redis.setex(&foo&, 5, &haha&);
//MSET key value [key value ...]同时设置一个或多个key-value对。
redis.mset(&haha&,&111&,&xixi&,&222&);
//redis.flushAll();清空所有的key
System.out.println(redis.dbSize());//dbSize是多少个key的个数
//APPEND key value如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
redis.append(&foo&, &00&);//如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
//GET key 返回key所关联的字符串值
redis.get(&foo&);
//MGET key [key ...] 返回所有(一个或多个)给定key的值
List list = redis.mget(&haha&,&xixi&);
for(int i=0;i&list.size();i++){
System.out.println(list.get(i));
//DECR key将key中储存的数字值减一。
//DECRBY key decrement将key所储存的值减去减量decrement。
//INCR key 将key中储存的数字值增一。
//INCRBY key increment 将key所储存的值加上增量increment。
/* -----------------------------------------------------------------------------------------------------------
//HSET key field value将哈希表key中的域field的值设为value。
redis.hset(&website&, &google&, &&);
redis.hset(&website&, &baidu&, &&);
redis.hset(&website&, &sina&, &&);
//HMSET key field value [field value ...] 同时将多个field - value(域-值)对设置到哈希表key中。
Map map = new HashMap();
map.put(&cardid&, &123456&);
map.put(&username&, &jzkangta&);
redis.hmset(&hash&, map);
//HGET key field返回哈希表key中给定域field的值。
System.out.println(redis.hget(&hash&, &username&));
//HMGET key field [field ...]返回哈希表key中，一个或多个给定域的值。
List list = redis.hmget(&website&,&google&,&baidu&,&sina&);
for(int i=0;i&list.size();i++){
System.out.println(list.get(i));
//HGETALL key返回哈希表key中，所有的域和值。
Map&String,String& map = redis.hgetAll(&hash&);
for(Map.Entry entry: map.entrySet()) {
System.out.print(entry.getKey() + &:& + entry.getValue() + &\t&);
//HDEL key field [field ...]删除哈希表key中的一个或多个指定域。
//HLEN key 返回哈希表key中域的数量。
//HEXISTS key field查看哈希表key中，给定域field是否存在。
//HINCRBY key field increment为哈希表key中的域field的值加上增量increment。
//HKEYS key返回哈希表key中的所有域。
//HVALS key返回哈希表key中的所有值。
/* -----------------------------------------------------------------------------------------------------------
//LPUSH key value [value ...]将值value插入到列表key的表头。
redis.lpush(&list&, &abc&);
redis.lpush(&list&, &xzc&);
redis.lpush(&list&, &erf&);
redis.lpush(&list&, &bnh&);
//LRANGE key start stop返回列表key中指定区间内的元素，区间以偏移量start和stop指定。下标(index)参数start和stop都以0为底，也就是说，以0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
List list = redis.lrange(&list&, 0, -1);
for(int i=0;i&list.size();i++){
System.out.println(list.get(i));
//LLEN key返回列表key的长度。
//LREM key count value根据参数count的值，移除列表中与参数value相等的元素。
/* -----------------------------------------------------------------------------------------------------------
//SADD key member [member ...]将member元素加入到集合key当中。
redis.sadd(&testSet&, &s1&);
redis.sadd(&testSet&, &s2&);
redis.sadd(&testSet&, &s3&);
redis.sadd(&testSet&, &s4&);
redis.sadd(&testSet&, &s5&);
//SREM key member移除集合中的member元素。
redis.srem(&testSet&, &s5&);
//SMEMBERS key返回集合key中的所有成员。
Set set = redis.smembers(&testSet&);
Iterator t1=set.iterator() ;
while(t1.hasNext()){
Object obj1=t1.next();
System.out.println(obj1);
//SISMEMBER key member判断member元素是否是集合key的成员。是（true），否则（false）
System.out.println(redis.sismember(&testSet&, &s4&));
//SCARD key返回集合key的基数(集合中元素的数量)。
//SMOVE source destination member将member元素从source集合移动到destination集合。
//SINTER key [key ...]返回一个集合的全部成员，该集合是所有给定集合的交集。
//SINTERSTORE destination key [key ...]此命令等同于SINTER，但它将结果保存到destination集合，而不是简单地返回结果集
//SUNION key [key ...]返回一个集合的全部成员，该集合是所有给定集合的并集。
//SUNIONSTORE destination key [key ...]此命令等同于SUNION，但它将结果保存到destination集合，而不是简单地返回结果集。
//SDIFF key [key ...]返回一个集合的全部成员，该集合是所有给定集合的差集 。
//SDIFFSTORE destination key [key ...]此命令等同于SDIFF，但它将结果保存到destination集合，而不是简单地返回结果集。
* @param args
public static void main(String[] args) {
JedisDemo t1 = new JedisDemo();
t1.test1();
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致
