开发中常使用的方法

最新推荐文章于 2023-09-20 13:39:35 发布
最新推荐文章于 2023-09-20 13:39:35 发布
阅读量257 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36323075/article/details/105976623
版权

1. org.apache.commons.lang 的StringUtils类

  • 判断字符串部不为null也不为空：

    System.out.println(StringUtils.isEmpty("")); //true
    注意：

  • System.out.println(StringUtils.isEmpty(" ")); //false

    注意在空格作非空处理
    判断字符串为空白或者为null

  • System.out.println(StringUtils.isBlank("")); //true

注意：一般使用此方法判断字符串是否为空或者null
2. org.springframework.util的StringUtils类
判断对象是否为空：isEmpty（）
这个可以判断对象，也可以判断string字符串。
3. java启动线程

new Thread(new Runnable() {
			@Override
			public void run() {
				for (Bill bill : billList) {
					if(bill.getType() != null && Keys.HTLX_TYPE_DF == bill.getType().getDicId()){
						logger.info(sendEleMeterMsg(bill.getWsbzbdbh(), null, null));
					}
				}
			}
		}).start();

4、redis的工具类

package com.newtouch.platform.cache;

import com.newtouch.platform.base.json.JsonSerializer;
import com.newtouch.platform.base.json.jackson.JacksonImp;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Response;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;

import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * Created by hxh on 2016/10/28.
 */
public class RedisMemoTool {

    private static JsonSerializer jsonSerializer = new JacksonImp();

    private static final Logger logger = LoggerFactory.getLogger(RedisMemoTool.class);

    static final boolean isOld = false;

    private static final  String PRE = "FAS_CACHE_";

    private static final String LOCK = "_LOCK";

    /**
     * 共享锁默认失效时间
     */
    public static final int LOCKTIMEOUT =  1000*180;
    /**
     * 设置缓存,key-value
     * @param key 关键字
     * @param value 值
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     */
    public static void set(String key , String value , int millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.set(key, value);
            expire(shardedJedis,key,millisecond);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    public static void setToken(String key , String value , long millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.set(key, value);
            expire(shardedJedis,key,millisecond);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }
    /**
     * 取值,key-value
     * @param key 关键字
     * @return
     */
    public static String get(String key){
        String value = null;
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            value = shardedJedis.get(key);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
        return value;
    }


    /**
     * 取值,key-value
     * @param keys 关键字
     * @return
     */
    public static List<Response<String>> getBatch(String[] keys){
        List<Response<String>> result = new ArrayList<>();
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            ShardedJedisPipeline pipe = shardedJedis.pipelined();

            for(String key:keys){
                result.add(pipe.get(key));
            }

            pipe.sync();
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
        return result;
    }


    /**
     * 缓存列表增加String对象
     * @param key 关键字
     * @param value 值
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     */
    public static void lpush(String key , String value , int millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.lpush(key,value);
            expire(shardedJedis,key,millisecond);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 缓存列表增加Object对象
     * @param key 关键字
     * @param row Map<String,Object>型数据记录
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     */
    public static void lpushRow(String key , Object row , int millisecond){
        JsonSerializer js = new JacksonImp();
        String str = js.toJson(row);
        RedisMemoTool.lpush(key, str, millisecond);
    }

    /**
     * 缓存列表批量提交
     * @param key 关键字
     * @param rows List<Map<String,Object>>型数据记录
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @param isAsc true表示正序，false表示倒序
     */
    public static void lpushBatch(String key , List<Map<String,Object>> rows , int millisecond,boolean isAsc) throws Exception {
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        logger.debug("lpushBatch rows total size:"+rows.size()+" ");
        try{
            ShardedJedisPipeline pipline = shardedJedis.pipelined();
            //清空原有数据
            pipline.del(key);
             long start = new Date().getTime();

            if(isAsc){
                for(Object row:rows){
                    String str = jsonSerializer.toJson(row);
                    pipline.lpush(key,str);
                }
            }else{
                for(Object row:rows){
                    String str = jsonSerializer.toJson(row);
                    pipline.rpush(key,str);
                }
            }
            logger.debug("lpushBatch.lpush rows，耗时:" + (new Date().getTime() - start) * 1.00/ (1000) + "s.");
            start = new Date().getTime();
            if(millisecond>0) {
                if (isOld) {
                    pipline.expire(key, (int) (millisecond / 1000));
                } else {
                    pipline.pexpire(key, millisecond);
                }
            }
            logger.debug("lpushBatch.pipline.expire，耗时:" + (new Date().getTime() - start) * 1.00/ (1000) + "s.");
             start = new Date().getTime();
            pipline.sync();
            logger.debug("lpushBatch.pipline.sync，耗时:" + (new Date().getTime() - start) * 1.00/ (1000) + "s.");
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }
    /**
     * 根据范围获取一段缓存列表的值，每个都是String对象
     * @param key 关键字
     * @param start 起始
     * @param end 截至
     */
    public static List<String> lrange(String key , int start, int end ){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        List<String> strList = null;
        try {
            strList = shardedJedis.lrange(key,start,end);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
        return strList;
    }

    /**
     * 根据范围获取一段缓存列表的值，每个都是Object对象
     * @param key 关键字
     * @param start 起始
     * @param end 截至
     */
    public static List<Map<String,Object>> lrangeRow(String key , int start, int end ){
        List<String> strList = RedisMemoTool.lrange(key, start, end);

        List<Map<String,Object>> objectResult = new ArrayList<>();
        Map<String,Object> o = new HashMap<>();
         for(String str:strList){
            objectResult.add(jsonSerializer.fromJson(str,o.getClass()));
        }
        return objectResult;
    }

    /**
     * 获取一共list的size
     * @param key 关键字
     */
    public static Long llen(String key ){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        long length = 0;
        try {
            length = shardedJedis.llen(key);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
        return length;
    }


    /**
     * 判断内存中是否存在关键字对应的值
     * @param key 关键字
     * @return
     */
    public static boolean exists(String key){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        boolean isExists = false;
        try {
            isExists = shardedJedis.exists(key);
        }catch (Exception e){
             e.printStackTrace();
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
        return isExists;
    }

    /**
     * 删除关键字对应的值
     * @param key 关键字
     * @return
     */
    public static Long del(String key){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            return shardedJedis.del(key);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 批量删除关键字对应的值
     * @param keys 关键字数组
     * @return
     */
    public static void del(Set<String> keys){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            ShardedJedisPipeline pipeline = shardedJedis.pipelined();

            for(String key:keys){
                pipeline.del(key);
            }
            pipeline.sync();
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 生成关键字工具
     * @param name 名对象称或者报表名称
     * @param params 查询条件参数组
     * @return
     * @throws java.io.UnsupportedEncodingException
     */
    public static String createKey(String name,String... params) throws UnsupportedEncodingException,Exception {
        String strParam = "";
        for(String p:params){
            strParam += p;
        }

        String key = PRE + name + com.newtouch.cloud.common.encrypt.MD5.ComputeHashString(strParam);

        return key;
    }

    /**
     * 内存锁，加锁
     * @param key key关键字
     * @param millisecond 锁自动失效时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void lock(String key,int millisecond){
        String lock = key + LOCK;

        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            while(shardedJedis.setnx(lock,"locked") == 0){
                Thread.sleep(50);
            }
            expire(shardedJedis,lock,millisecond);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }


    /**
     * 内存锁，解锁
     * @param key key关键字
     * @return
     */
    public static void unlock(String key)  {
        String lock = key + LOCK;
        del(lock);
    }

    /**
     * 根据key获取缓存列表Object对象
     * @param key 关键字
     * @param classType Object型数据记录
     */
    public static <T> T get(String key , Class<T> classType){
         String json = get(key);
        return jsonSerializer.fromJson(json,classType);
    }


    /**
     * 缓存列表增加Object对象
     * @param key 关键字
     * @param obj Object型数据记录
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     */
    public static void push(String key , Object obj , int millisecond){
         String str = jsonSerializer.toJson(obj);
        RedisMemoTool.set(key, str, millisecond);
    }

    /**
     * 缓存保存，key对应map的结构
     * @param key 关键字
     * @param data 单行数据，Map<String,String>类型
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void hmset(String key,Map<String,String> data,int millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.hmset(key,data);

            if(millisecond>0){
                if(isOld){
                    shardedJedis.expire(key, (int)(millisecond/1000));
                }else{
                    shardedJedis.pexpire(key,millisecond);
                }
            }
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 根据patten获取所有匹配的key
     * @param patten 匹配表达式，例如abc*查询所有abc开头的key
     * @return
     */
    public static Set<String> keys(String patten){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            Set<String> keys = new HashSet<>();
            Collection<Jedis> jedises = shardedJedis.getAllShards();

            Iterator<Jedis> it = jedises.iterator();
            while(it.hasNext()){
                Jedis jedis = it.next();
                keys.addAll(jedis.keys(patten));
            }
            return keys;
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 根据key获取map对象
     * @param key 关键字
     * @return
     */
    public static Map<String,String> hgetAll(String key){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            return shardedJedis.hgetAll(key);

        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 缓存保存，key对应set的结构,常用在建立索引使用
     * @param key 关键字
     * @param members Set<String>集合对象
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void sadd(String key,String[] members,int millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.sadd(key,members);
            expire(shardedJedis,key,millisecond);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 缓存保存，key对应set的结构,常用在建立索引使用
     * @param key 关键字
     * @param member 对象
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void sadd(String key,String member,int millisecond){
        sadd(key,new String[]{member},millisecond);
    }

    /**
     * 返回集合中所有成员
     * @param key 关键字
     * @return
     */
    public static Set<String> smembers(String key){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            return shardedJedis.smembers(key);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }


    /**
     * 缓存保存，key对应set的结构,常用在建立索引使用
     * @param key 关键字
     * @param scoreMembers Set<String>集合对象
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void zadd(String key,Map<String,Double> scoreMembers,int millisecond){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            shardedJedis.zadd(key , scoreMembers);
            expire(shardedJedis,key,millisecond);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    /**
     * 缓存保存，key对应set的结构,常用在建立索引使用
     * @param key 关键字
     * @param member 对象
     * @param score 分值
     * @param millisecond 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static void zadd(String key,String member,Double score,int millisecond){
        Map<String,Double> scoreMembers = new HashMap<>();
        scoreMembers.put(member,score);
        zadd(key,scoreMembers,millisecond);
    }


    /**
     * 缓存保存，key对应set的结构,常用在建立索引使用
     * @param key 关键字
     * @param min Set<String>集合对象
     * @param max 超时时间，单位毫秒;   0或负数表示永久保存,谨慎使用;
     * @return
     */
    public static Set<String> zrangeByScore(String key,Double min,Double max){
        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
        try {
            return shardedJedis.zrangeByScore(key, min, max);
        }catch (Exception e){
            throw e;
        }finally {
            if(shardedJedis!=null){
                shardedJedis.close();
            }
        }
    }

    private static void expire(ShardedJedis shardedJedis,String key,int millisecond){
        if(millisecond>0){
            if(isOld){
                shardedJedis.expire(key, (int)(millisecond/1000));
            }else{
                shardedJedis.pexpire(key,millisecond);
            }
        }
    }

    private static void expire(ShardedJedis shardedJedis,String key,long millisecond){
        if(millisecond>0){
            if(isOld){
                shardedJedis.expire(key, (int)(millisecond/1000));
            }else{
                shardedJedis.pexpire(key,millisecond);
            }
        }
    }

    /**
     * 测试代码
     * @param args
     * @throws java.io.UnsupportedEncodingException
     */
    public static void main(String[] args) throws Exception {

        RedisMemoTool.del("wawa");
        List<Map<String,Object>> list = new ArrayList<>();
        Map<String,Object> a1 = new HashMap<>();
        a1.put("col",1);
        list.add(a1);

        Map<String,Object> a2 = new HashMap<>();
        a2.put("col",2);
        list.add(a2);

        Map<String,Object> a3 = new HashMap<>();
        a3.put("col",3);
        list.add(a3);


        RedisMemoTool.lpushBatch("wawa", list, 1000 * 60 * 30, true);

        list = new ArrayList<>();
        Map<String,Object> a4 = new HashMap<>();
        a4.put("col",4);
        list.add(a4);

        Map<String,Object> a5 = new HashMap<>();
        a5.put("col",5);
        list.add(a5);
        RedisMemoTool.lpushBatch("wawa", list, 1000 * 60 * 30, true);

        List<Map<String,Object>> pageResult = RedisMemoTool.lrangeRow("wawa", 0, -1);

        for(Map<String,Object> row :pageResult){
            System.out.println(row.get("col"));
        }
//        String[] arr = new String[]{"1","2","3","4","5","6"};
//        System.out.println(RedisMemoTool.createKey("ww",arr));

//        HashMap map = new HashMap();
//        map.put("aaa","s");
//        JsonSerializer js = new GsonImpl();
//        String str = js.toJson(map);
//        RedisMemoTool.set("FAS_CACHE_sc_scClassicQueryUtilsManager_balanceFlag6400130000",str,100000);
//        String rel = RedisMemoTool.get("FAS_CACHE_sc_scClassicQueryUtilsManager_balanceFlag6400130000");
//        System.out.println(rel);
//        RedisMemoTool.set("kk","uuu",1000*60);
//        System.out.println(RedisMemoTool.get("kk"));
//
//
//        ShardedJedis shardedJedis = RedisCache.getShardedJedis();
//        shardedJedis.lpush("yyy","过期");
//        shardedJedis.lpush("yyy","meishi");
//        shardedJedis.pexpire("yyy",1000*60);
//        RedisMemoTool.lpush("yyy","过期",1000*60);
//        RedisMemoTool.lpush("yyy","meishi",1000*60);
//
//        List<String> strList = RedisMemoTool.lrange("yyy",0,1);
//        for(String s:strList){
//            System.out.println(s);
//        }
//
//        List<Map<String,Object>> rows = new ArrayList<>();
//        String classicData = "{\"DEBIT_CREDIT\":2131.03,\"BUDAT\":\"20161026\",\"USNAM\":\"51243407@SC\",\"UNIT\":\"A5100:省公司本部\",\"DEBIT__CREDIT\"" +
//                ":2131.03,\"ZZSY_ORI\":\"CW-CFBZ\",\"ECONOMIC\":\"FY010101:经济事项名称(暂无)\",\"SGTXT\":\"付省公司本部电视宽带部报冯艳梅外埠差旅费\",\"BUZEI\"" +
//                ":\"002\",\"PERIOD\":\"201610\",\"DEBIT\":2131.03,\"CREDIT\":0.0,\"KOSTL\":\"A510000036\",\"PRCTR\":\"A510000\",\"HKONT\"" +
//                ":\"6400160901\",\"BELNR\":\"3300081869\",\"BLDAT\":\"20161026\",\"LTEXT\":\"省本部.电视宽带部\",\"BKTXT\":\"省公司本部电视宽带部报外埠差旅费\",\"NUMPG\"" +
//                ":\"004\"}";
//        JsonSerializer js = new GsonImpl();
//        for(int i = 0;i<124764;i++){
//            Map<String,Object> row = js.fromJson(classicData,new HashMap<String,Object>().getClass());
//            rows.add(row);
//        }
//        System.out.println("start...");
//        long start = new Date().getTime();
//        lpushBatch(key , rows , 1000*60*30,false);
//        System.out.println("lpushBatch，耗时:" + (new Date().getTime() - start) * 1.00/ (1000) + "s.");
    }
}

5、使用fastJson转json对象

  • JSONObject与String、实体类互相转换

1、实体类对象转换成String类型的JSON字符串
JSONObject.toJSONString(实体类对象) == String

2、String类型的JSON字符串转换成实体类对象
JSONObject.toJavaObject(JSON字符串,实体类对象) == 实体

3、Json字符串转换成JSONObject对象
JSONObject.parseObject(JSON字符串) == JSONObject

4、JSON字符串转换成实体类对象
JSONObject.parseObject(JSON字符串,实体类对象) == 实体

- 转jsonArray
1、string转jsonArray
JSONArray jsonArray= JSONArray.parseArray(String);

2、List转JSONArray
JSONArray.parseArray(JSON.toJSONString(list))；

3、JSONArray转List
JSONObject.parseArray(array.toJSONString(), EventColAttr.class);

4、字符串转List
JSONObject.parseArray(str,T.class);

我就是程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GMap.Net开发之自定义Marker使用方法
01-01
在地图的使用中常要求的功能就是添加自定义图标，可以点击图标、删除图标、拖动图标、高亮图标等。 下面介绍这些功能的实现（主要是基于WinForm的，WPF的可以参考官方Demo实现）： 1、自定义图标，使用官方的Marker...
开发中常用日语词汇汇总
最新发布
01-26
开发中常用日语词汇汇总
9月25日培训日记
张孝祥专栏
09-26 2727
根据袁龙友老师前两天上课的反馈信息：学员们对表之间建立关联关系的思想还很陌生，毫无概念。首先检讨我以前写的Java书对对象之间的关联关系强调得不够（几乎就是没有任何提及），而对象之间的关系在实际开发中却用得很多。如果对对象之间的关联关系理解不透，那学习hibernate时将会很费劲，我以后的java书中会将对象之间的关系作为一个重点强调。今天我先上来用自己的土办法强制学员们建立关联关系的思想，告诉
NANDFLASH介绍（转）
forever的专栏
08-10 1096
<br />Row也就是page<br />1.       引脚描述<br />I/O0 ~ I/O7-----data inputs/outputs<br />通过这8个I/O引脚，可以输入命令，地址和数据，也可以在读操作时输出数据。<br /> <br />CLE-----command latch enable<br />CLE输入控制了发送到命令寄存器的命令。CLE为高电平时激活，在nWE的上升沿，命令通过I/O端口被锁存到命令寄存器中，结合datasheet的相关时序图来理解更为深刻。<br /
JSON空值处理与 StringUtils工具类使用
HMing的博客
09-08 392
JSON 动态查询时，需要的条件本应是null,前端传入的是" " //null转换为"" private static ValueFilter filter = (obj, s, v) -> { 　　if (v == "") { 　　　　return null; 　　} 　　return v; };...
软件开发方法综述
重剑无锋，大巧不工。。。
10-27 1139
 国外大的软件公司和机构一直在研究软件开发方法这个概念性的东西，而且也提出了很多实际的开发方法，比如：生命周期法、原型化方法、面向对象方法等等。下面介绍几种流行的开发方法：1、结构化方法结构化开发方法是由E.Yourdon 和 L.L.Constantine 提出的，即所谓的SASD 方 法， 也可称为面向功能的软件开发方法或面向数据流的软件开发方法。Yourdon方法是80年代 使用最广泛的软件
JS lodash库在开发中常用到的方法
GodLoveMe的博客
11-19 1069
一.摘要 lodash是JS一个开箱即用的库函数，里面对于在日常开发中常用到的方法都是已经封装好的，使用起来非常方便，本篇记录了在日常开发过程总经常用的方法，就大概记录一下，具体请参考lodash的官方API：lodash官方API 二.常用方法 get import { get } from 'lodash' // 从一个变量中取值，第一参数表示变量，第二个表示该节点对应的名称，第三个参数表示当取不到的时候设置的默认值 const a1 = get(nextProps, 'treeVal'.
JavaScript中常用的数组过滤方法
weixin_53156345的博客
09-20 5080
在 JavaScript 编程中，经常会遇到需要对数组进行筛选和过滤的情况。本文将介绍几种常用的数组过滤方法，帮助你在处理数组数据时更加灵活高效。
嵌入式开发中常用的软件设计模式
m0_46535940的博客
03-28 2094
文章目录前言一、如何在嵌入式中使用设计模式的思想？一、命令模式1.1 命令模式定义1.2 命令模式实例二、设计模式的C语言应用-状态机模式-第二章六、设计模式的C语言应用-适配及系列模式-第六章七、设计模式的C语言应用-建造者模式-第七章八、设计模式的C语言应用-外观模式-第八章九、设计模式的C语言应用-访问者模式-第九章十、设计模式的C语言应用-非典型模式-第十章总结 前言 一、如何在嵌入式中使用设计模式的思想？ 嵌入式的标签多为：低配，偏硬件，底层，资源紧张，代码多以C语言，汇编为主，代码应用逻辑简
项目开发中常遇到的问题以及解决方法
04-02 3428
基于区块链的文物管理系统： 问题1： HyperledgerFabric环境搭建运行失败： 缺少镜像，从官网上拉去缺少的镜像即可。缺少配置文件,利用Cryptogen生成（是一个用于生成Hyperledger Fabric密钥和证书文件的工具。并且可以查看配置的模板信息， 它被用来测试预先配置的网络，它通常不会用于生产网络）。Configtxgen该工具用来操作超级账本Fabric的通道配置...
软件开发中常各类软件开发文档的英文缩写
xiao.yu的博客
06-27 2931
英文简写文档名称 MRD market requirement document （市场需求文档） PRD product requirement document （产品需求文档） SOW 工作任务说明书 PHB Process Handbook (项目过程手册) EST Estimation Sheet (估计记录) PPL Project Plan (项目计划) CMP Sof...
[002]VC++中常用控件的使用方法.zip上位机开发VC串口学习资料源码下载
05-03
[002]VC++中常用控件的使用方法.zip上位机开发VC串口学习资料源码下载[002]VC++中常用控件的使用方法.zip上位机开发VC串口学习资料源码下载[002]VC++中常用控件的使用方法.zip上位机开发VC串口学习资料源码下载[002]...
Java中常用字符串方法总结.doc
05-09
Java 中常用字符串方法总结 Java 中的字符串是极其重要的数据类型之一，字符串的操作和处理在 Java 开发中占据着非常重要的地位。下面是 Java 中常用字符串方法的总结。 创建并初始化字符串 在 Java 中，可以使用...
hive开发中常遇到的坑
08-13
hive 下dual表，Lock，explain， 数据类型，开发常见的问题
C语言版本的师生管理系统
nikolashuai的博客
05-18 804
共7个文件 list.c 用到的链表实现 main.c 主函数入口，controller main1.c 链表的常规算法 stu.h 头文件 use.c service层 welcome.c view层 student.txt 数据源 teach.txt 数据源 #include"stu.h" //welcome.c extern c; extern a,b; int...
get方式请求接受参数的方法
热门推荐
qq_36323075的博客
10-29 1万+
1、获取jsp页面的url，然后通过js获取参数 function getQueryString(name) { var reg = new RegExp("(^|&)"+ name +"=([^&]*)(&|$)"); var r = parent.document.location.search.substr(1).match(reg); ...
idea没法识别java文件，idea文件左下角有个j的符号并是黄色
qq_36323075的博客
03-15 4301
解决方法：
spring启动加载流程
qq_36323075的博客
10-25 3063
上次看了spring的加载流程，今天发现或多都忘记了，今天又看了一下，顺便总结一下： 标题spring的web项目启动： 1、首先web容器（比如Tomcat）会读取配置在web.xml中的监听器，从而启动spring容器。 &amp;lt;!--web项目中上下文初始化参数, name value的形式 --&amp;gt; &amp;lt;context-param&amp;gt; &amp;lt;param-name&amp;gt...
EXCEL导入导出使用的框架
qq_36323075的博客
07-29 2265
以前excel使用的都是poi但是在使用过程中比较麻烦，上次做一个项目，发现一个很好用的工具们今天分享给大家。 1、使用Easypoi，免费开源是国内开发的，中文文档看起来比较方便，这个我就不评论了，大家上官网看看。 官网地址：http://easypoi.mydoc.io/#text_173307 2、这个是重点，也是我们项目中使用到的。这个Excle导出工具不知是哪位大神写的，我只是分享。 引...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值