精华内容
下载资源
问答
  • Java工具类」BeanCopyUtil对象复制工具类
    千次阅读
    2021-10-31 18:59:04

    介绍语

    本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新,欢迎码友关注点赞收藏转发!

    望各位码友点击关注,冲1000粉。后面会录制一些视频教程,图文和视频结合,比如:图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱,码友们冲啊

    如果码友觉得代码太长,可以从头到尾快速扫射一遍,了解大概即可。觉得有用后再转发收藏,以备不时之需。

    正文:

    对象复制工具类,简单好用。但是使用场景好像不多,先收藏

    例子1

    复制学生类到另一个学生类

    import java.time.LocalDate;
     ​
     public class BeanUtilTest {
         public static void main(String[] args) {
             Student student = new Student("zhang三",
                     12, "花果山", LocalDate.of(1990, 2, 26));
             Student studentCopy = new Student();
             BeanCopyUtil.merge(student, studentCopy);
     ​
             System.out.println(studentCopy);
         }
     }
     ​
     // 控制台打印
     Student(name=zhang三, age=12, address=花果山, birthday=1990-02-26)

    例子用到的实体类

    import lombok.AllArgsConstructor;
     import lombok.Data;
     import lombok.NoArgsConstructor;
     ​
     import java.time.LocalDate;
     ​
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Student {
         private String name;
         private int age;
         private String address;
         private LocalDate birthday;
     }

    工具类源码:

    import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     ​
     import java.lang.reflect.Field;
     ​
     /**
      * 对象赋值工具类
      *
      * @author liangxn
      */
     public class BeanCopyUtil {
     ​
         private static final Logger logger = LoggerFactory.getLogger(BeanCopyUtil.class);
     ​
         /**
          * 相同对象合并,将原对象的非空属性的值赋值给目标对象
          *
          * @param origin      源对象
          * @param destination 目标对象
          * @param <T>         对象的类型
          */
         public static <T> void merge(T origin, T destination) {
             if (origin == null || destination == null) {
                 return;
             }
             if (!origin.getClass().equals(destination.getClass())) {
                 return;
             }
     ​
             Field[] fields = origin.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 try {
                     Object value = field.get(origin);
                     if (null != value) {
                         field.set(destination, value);
                     }
                 } catch (IllegalAccessException e) {
                     logger.error("访问对象异常", e);
                 }
                 field.setAccessible(false);
             }
         }
     }

    鄙人编码十年多,在项目中也积累了一些工具类,很多工具类在每个项目都有在用,很实用。大部分是鄙人封装的,有些工具类是同事封装的,有些工具类已经不记得是ctrl+c的还是自己封装的了,现在有空就会总结项目中大部分的工具类,分享给各位码友。如果文章中涉及的代码有侵权行为请通知鄙人处理。

    计划是先把工具类整理出来,正所谓工欲善其事,必先利其器。项目中不管是普通单体项目还是多模块maven项目或是分布式微服务,一部分功能模块都是可以重用的,工具类模块就是其中之一。

    更多相关内容
  • Java 缓存工具类 Cache

    千次阅读 2022-04-07 22:54:43
    Java 缓存工具类 Cache工具类定义

    Java 缓存工具类 Cache

    工具类定义

    package com.demo.utils;
    
    import org.springframework.util.StringUtils;
    
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.*;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * Description: 缓存工具类
     * 1.部分方法未验证,如有问题请自行修改
     * 2.其他方法请自行添加
     *
     * @Author: zhx & moon hongxu_1234@163.com
     * @Date: 2022-04-07 20:54
     * @version: V1.0.0
     */
    public class Cache {
    
        /**
         * 屏蔽工具类的无参构造 避免工具类被实例化
         */
        private Cache(){}
    
        /**
         * 缓存留存期 30min 1H 24H
         */
        public static final long CACHE_HOLD_TIME_30M = 30 * 60 * 1000L;
        public static final long CACHE_HOLD_TIME_1H = 2 * CACHE_HOLD_TIME_30M;
        public static final long CACHE_HOLD_TIME_24H = 24 * CACHE_HOLD_TIME_1H;
        public static final long CACHE_HOLD_TIME_FOREVER = -1L;
    
        /**
         * 缓存容量、最少使用容量
         */
        private static final int CACHE_MAX_CAP = 1000;
        private static final int CLEAN_LRU_CAP = 800;
    
        /**
         * 缓存当前大小
         */
        private static AtomicInteger CACHE_CURRENT_SIZE = new AtomicInteger(0);
    
        /**
         * 缓存对象
         */
        private static final Map<String,Node> CACHE_MAP = new ConcurrentHashMap<>(CACHE_MAX_CAP);
    
        /**
         * 最少使用记录
         */
        private static final List<String> LRU_LIST = new LinkedList<>();
    
        /**
         * 自动清理标志位
         */
        private static volatile boolean CLEAN_RUN_FLAG = false;
    
        /**
         * 默认30MIN
         * @param key
         * @param val
         */
        public static void put(String key,Object val){
            put(key,val,CACHE_HOLD_TIME_30M);
        }
    
        /**
         * 添加永久缓存
         * @param key
         * @param val
         */
        public static void putForever(String key,Object val){
            put(key,val,CACHE_HOLD_TIME_FOREVER);
        }
    
        /**
         * 添加缓存
         * @param key
         * @param val
         * @param ttlTime
         */
        public static void put(String key,Object val,long ttlTime){
            if (!StringUtils.hasLength(key) || null == val){
                return;
            }
            checkSize();
            updateCacheLru(key);
            CACHE_MAP.put(key,new Node(val,ttlTime));
        }
    
        /**
         * 获取缓存信息
         * @param key
         * @param clazz
         * @param <T>
         * @return
         */
        public static <T> T get(String key,Class<T> clazz){
            if (!StringUtils.hasLength(key) || !CACHE_MAP.containsKey(key)){
                return null;
            }
            updateCacheLru(key);
            return (T) CACHE_MAP.get(key).getVal();
        }
    
        /**
         * 更新最近使用位置
         * @param key
         */
        private static void updateCacheLru(String key){
            synchronized (LRU_LIST){
                LRU_LIST.remove(key);
                LRU_LIST.add(0,key);
            }
        }
    
        /**
         * 删除,成功则容量-1
         * @param key
         */
        private static boolean remove(String key){
            Node node = CACHE_MAP.remove(key);
            if (null!=node){
                CACHE_CURRENT_SIZE.getAndDecrement();
                return true;
            }
            return false;
        }
    
        /**
         * 检查是否超过容量,先清理过期,在清理最少使用
         */
        private static void checkSize(){
            if (CACHE_CURRENT_SIZE.intValue() > CACHE_MAX_CAP){
                deleteTimeOut();
            }
            if (CACHE_CURRENT_SIZE.intValue() > CLEAN_LRU_CAP){
                deleteLru();
            }
        }
    
        /**
         * 删除最久未使用,尾部删除
         * 永久缓存不会被清除
         */
        private static void deleteLru(){
            synchronized (LRU_LIST){
                while (LRU_LIST.size() > CLEAN_LRU_CAP){
                    int lastIndex = LRU_LIST.size() - 1;
                    String key = LRU_LIST.get(lastIndex);
                    if (!CACHE_MAP.get(key).isForever() && remove(key)){
                        LRU_LIST.remove(lastIndex);
                    }
                }
            }
        }
    
        /**
         * 删除过期
         */
        private static void deleteTimeOut(){
            List<String> del = new LinkedList<>();
            for (Map.Entry<String,Node> entry:CACHE_MAP.entrySet()){
                if (entry.getValue().isExpired()){
                    del.add(entry.getKey());
                }
            }
            for (String k:del){
                remove(k);
            }
        }
    
        /**
         * 缓存是否已存在,过期则删除返回False
         * @param key
         * @return
         */
        public static boolean contains(String key){
            if (CACHE_MAP.containsKey(key)){
                if (!CACHE_MAP.get(key).isExpired()){
                    return true;
                }
                if (remove(key)){
                    return false;
                }
                return true;
            }
            return false;
        }
    
        /**
         * 清空缓存
         */
        public static void clear(){
            CACHE_MAP.clear();
            CACHE_CURRENT_SIZE.set(0);
            LRU_LIST.clear();
        }
    
        /**
         * 重置自动清理标志
         * @param flag
         */
        public static void setCleanRunFlag(boolean flag){
            CLEAN_RUN_FLAG = flag;
        }
    
        /**
         * 自动清理过期缓存
         */
        private static void startAutoClean(){
    
            if (!CLEAN_RUN_FLAG){
                setCleanRunFlag(true);
                ScheduledExecutorService scheduledExecutor = new ScheduledThreadPoolExecutor(1);
                scheduledExecutor.scheduleAtFixedRate(()->{
                    try {
                        Cache.setCleanRunFlag(true);
                        while (CLEAN_RUN_FLAG){
                            Cache.deleteTimeOut();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                },10,Cache.CACHE_HOLD_TIME_1H, TimeUnit.SECONDS);
            }
        }
    
        /**
         * 缓存对象类
         */
        public static class Node{
            /**
             * 缓存值
             */
            private Object val;
            /**
             * 过期时间
             */
            private long ttlTime;
    
            public Node(Object val,long ttlTime){
                this.val = val;
                if (ttlTime<0){
                    this.ttlTime = ttlTime;
                }else{
                    this.ttlTime = System.currentTimeMillis() + ttlTime;
                }
            }
    
            public Object getVal(){
                return this.val;
            }
    
            public boolean isExpired(){
                if (this.ttlTime<0){
                    return false;
                }
                return System.currentTimeMillis() > this.ttlTime;
            }
    
            public boolean isForever(){
                if (this.ttlTime<0){
                    return true;
                }
                return false;
            }
    
        }
    
    
    }
    
    
    展开全文
  • java后台微信支付工具类

    热门讨论 2016-05-11 14:53:16
    该资源为微信app支付java服务器代码所依赖的工具包,微信appV3代码请查看博客: http://blog.csdn.net/xu_xiao_ji/article/details/51374174
  • java常用工具类封装

    千次阅读 2021-09-29 10:35:41
    java常用工具类封装 import org.apache.commons.lang.StringUtils; import java.math.BigDecimal; public class CommonUtil { public static String safeToString(Object value, String defaultValue) { if ...

    java常用工具类封装

    import org.apache.commons.lang.StringUtils;
    
    import java.math.BigDecimal;
    
    public class CommonUtil {
    
        public static String safeToString(Object value, String defaultValue) {
            if (value != null) {
                return StringUtils.trim(String.valueOf(value));
            }
            return defaultValue;
        }
    
        public static Integer safeToInteger (Object obj, Integer defaultValue) {
            if (obj != null) {
                return Integer.parseInt(String.valueOf(obj));
            }
            return defaultValue;
        }
    
        /**
         * 方法注释: 银行卡号脱敏
         * @return
         */
        public static String getHideCardNo(String cardNo){
            if (StringUtils.isNotBlank(cardNo)) {
                StringBuffer cardBuffer = new StringBuffer();
                char[] card = cardNo.toCharArray();
                if (card.length > 8 && card.length <= 12) {
                    card[card.length - 5] = '*';
                    card[card.length - 6] = '*';
                    card[card.length - 7] = '*';
                    card[card.length - 8] = '*';
                }
                if (card.length > 12) {
                    for (int i = 5; i <= 12; i++) {
                        card[card.length - i] = '*';
                    }
                }
                int head = card.length%4 + 4;
                for (int i = 0; i < head; i++) {
                    cardBuffer.append(card[i]);
                }
                cardBuffer.append("");
                for (int i = 0; (i + head)< card.length; i++) {
                    cardBuffer.append(card[i + head]);
                    if ((i+1)%4 == 0) {
                        cardBuffer.append("");
                    }
                }
                return cardBuffer.toString().trim();
            }
            return cardNo;
        }
    
        /**
         * 名字脱敏
         * 规则,张三丰,脱敏为:**丰
         */
        public static String nameDesensitization(String name){
            if(name==null || name.isEmpty()){
                return "";
            }
            String myName = null;
            char[] chars = name.toCharArray();
            if(chars.length==1){
                myName=name;
            }
            if(chars.length==2){
                myName=name.replace(name.substring(0,1), "*");
            }
            if(chars.length>2){
                myName=name.replaceAll(name.substring(0, chars.length-1), "*");
            }
            return myName;
        }
    
        /**
         * 对手机号进行脱敏
         * @param phone
         * @return
         */
        public static String getHidePhone (String phone) {
            if (StringUtils.isNotBlank(phone)) {
                phone = phone.replaceAll("(^\\d{3})\\d.*(\\d{4})", "$1****$2");
            }
            return phone;
        }
    
        /**
         * 对身份证号进行脱敏
         * @param idNumber
         * @return
         */
        public static String desensitizedIdNumber(String idNumber){
            if (StringUtils.isNotBlank(idNumber)) {
                if (idNumber.length() == 15){
                    idNumber = idNumber.replaceAll("(\\w{3})\\w*(\\w{4})", "$1********$2");
                }
                if (idNumber.length() == 18){
                    idNumber = idNumber.replaceAll("(\\w{3})\\w*(\\w{4})", "$1***********$2");
                }
            }
            return idNumber;
        }
    
        /**
         * 元转为无小数点的分
         *
         * @param price
         * @return
         */
        public static BigDecimal yuan2Fen(BigDecimal price) {
            return new BigDecimal(price.multiply(new BigDecimal("100")).longValue());
        }
    
        public static void main(String[] args) {
            String idNumber = desensitizedIdNumber("421202199805060221");
            System.out.println(idNumber);
        }
    }
    
    展开全文
  • java日常工具类之Excel工具类

    万次阅读 2021-07-28 19:45:23
    import java.io.ByteArrayOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.text.DecimalFormat; import java.text.SimpleDateFormat; ...
    import java.io.ByteArrayOutputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.text.DecimalFormat;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import org.apache.poi.hssf.usermodel.HSSFCell;
    import org.apache.poi.hssf.usermodel.HSSFDateUtil;
    import org.apache.poi.ss.usermodel.Cell;
    import org.apache.poi.ss.usermodel.DateUtil;
    import org.apache.poi.ss.usermodel.Row;
    import org.apache.poi.xssf.streaming.SXSSFWorkbook;
    import org.apache.poi.xssf.usermodel.XSSFCell;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    
    /**
     * Excel工具类
     *
     * @author lp
     */
    public class ExcelUtil {
        public static final String OFFICE_EXCEL_2003_POSTFIX = "xls";
        public static final String OFFICE_EXCEL_2010_POSTFIX = "xlsx";
        public static final String EMPTY = "";
        public static final String POINT = ".";
        public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
    
        /**
         * 获得path的后缀名
         *
         * @param path
         * @return
         */
        public static String getPostfix(String path) {
            if (path == null || EMPTY.equals(path.trim())) {
                return EMPTY;
            }
            if (path.contains(POINT)) {
                return path.substring(path.lastIndexOf(POINT) + 1, path.length());
            }
            return EMPTY;
        }
    
        /**
         * 单元格格式
         *
         * @param hssfCell
         * @return
         */
        @SuppressWarnings({"static-access", "deprecation"})
        public static String getHValue(HSSFCell hssfCell) {
            if (hssfCell.getCellType() == hssfCell.CELL_TYPE_BOOLEAN) {
                return String.valueOf(hssfCell.getBooleanCellValue());
            } else if (hssfCell.getCellType() == hssfCell.CELL_TYPE_NUMERIC) {
                String cellValue = "";
                if (HSSFDateUtil.isCellDateFormatted(hssfCell)) {
                    Date date = HSSFDateUtil.getJavaDate(hssfCell.getNumericCellValue());
                    cellValue = sdf.format(date);
                } else {
                    DecimalFormat df = new DecimalFormat("#.##");
                    cellValue = df.format(hssfCell.getNumericCellValue());
                    String strArr = cellValue.substring(cellValue.lastIndexOf(POINT) + 1, cellValue.length());
                    if (strArr.equals("00")) {
                        cellValue = cellValue.substring(0, cellValue.lastIndexOf(POINT));
                    }
                }
                return cellValue;
            } else {
                return String.valueOf(hssfCell.getStringCellValue());
            }
        }
    
        /**
         * 单元格格式
         *
         * @param xssfCell
         * @return
         */
        public static String getXValue(XSSFCell xssfCell) {
            if (xssfCell.getCellType() == Cell.CELL_TYPE_BOOLEAN) {
                return String.valueOf(xssfCell.getBooleanCellValue());
            } else if (xssfCell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
                String cellValue = "";
                if (DateUtil.isCellDateFormatted(xssfCell)) {
                    Date date = DateUtil.getJavaDate(xssfCell.getNumericCellValue());
                    cellValue = sdf.format(date);
                } else {
                    DecimalFormat df = new DecimalFormat("#.##");
                    cellValue = df.format(xssfCell.getNumericCellValue());
                    String strArr = cellValue.substring(cellValue.lastIndexOf(POINT) + 1, cellValue.length());
                    if (strArr.equals("00")) {
                        cellValue = cellValue.substring(0, cellValue.lastIndexOf(POINT));
                    }
                }
                return cellValue;
            } else {
                return String.valueOf(xssfCell.getStringCellValue());
            }
        }
        public static int writeExcelOs(String[][] content,String savaPath) {
            byte[] data = null;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            OutputStream os=null;
            SXSSFWorkbook workBook = null;
            int rutle=0;
            try {
    
                workBook = new SXSSFWorkbook();
                os=new FileOutputStream(savaPath);
                org.apache.poi.ss.usermodel.Sheet sheet=workBook.createSheet();
                workBook.setSheetName(0,"sheet1");
                //
                for (int i = 0; i < content.length; i++) {
                    Row row = sheet.createRow(i);
                    for (int j = 0; j < content[i].length; j++) {
                        row.createCell(j).setCellValue(content[i][j]);
                    }
    
    
                }
    
                workBook.write(os);
                os.flush();
                os.close();
                rutle=1;
    
    
            } catch (IOException e) {
                e.printStackTrace();
            }  finally {
                try {
                    bos.close();
                    //os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return rutle;
        }
    }
    
    展开全文
  • Java文件工具类

    千次阅读 2022-03-17 13:41:41
    Java文件工具类 /** * 读取项目根目录下的文件内容 * @author zouguang * @date 2020/9/15 16:03 * @param filePath 文件路径 * @return **/ public static String readFile(String filePath){ StringBuffer...
  • Java Http请求工具类

    千次阅读 2021-10-14 11:50:47
    在对接第三方接口时,需要进行数据交互,于是了一个 Java 的 Http 请求工具类,该工具类可以调用 Get 请求或者 POST 请求。 根据自己业务需求灵活修改 直接上代码: package com.file.license.utils; import org....
  • Java Utils工具类大全

    万次阅读 2019-01-21 23:06:10
    另外希望身为Java牛牛的你们一起测试和完善,欢迎入群263641914 一起封装和完成常用的Java代码。 节约撸码时间以方便有更多的时间去把妹子~ #开发环境 Win7x64 JDK1.7 IDEA14 #项目结构 │ README.m...
  • java集合工具类

    千次阅读 2019-05-26 21:47:25
    下面小编给大家java的集合工具类:Collections,java提供了一个操作Set、List和Map等集合的工具类:Collections,该工具类里面提供了大量方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象实现同步控制...
  • 30个java工具类

    热门讨论 2010-09-14 08:45:37
    [工具类] 获得汉字拼音首字母的java工具类.java.txt [工具类] 获取绝对路径 .java.txt [工具类] 记录log日志文件的工具类 .java.txt [工具类] 连接数据库的工具类 .java.txt [工具类] 使用Java程序来实现HTTP文件的...
  • JAVA中RSA加密解密工具类加强版

    热门讨论 2015-07-14 09:46:29
    博客地址 http://blog.csdn.net/sbsujjbcy/article/details/46873403
  • 场景:有些工具类里面出现业务代码,导致工具类不好复用。只能在工具类新建一个类似方法勉强满足业务,但是这个工具类看起来就很low了。 解决:把工具类中的业务代码抽成一个方法,这个方法设置为抽象方法a...
  • 在Java中,工具类定义了一组公共方法,这篇文章将介绍Java中使用最频繁及最通用的Java工具类。 以下工具类、方法按使用流行度排名,参考数据来源于Github上随机选取的5万个开源项目源码。 一. org.apache.commons.io...
  • Java 旋转、翻转图片工具类(附代码) | Java工具类

    千次阅读 多人点赞 2021-11-18 18:19:58
    本文提供java操作图片生成旋转、翻转后的图片工具类,拿来即用。
  • Java实现Unicode加码和解码的工具类

    千次阅读 2022-04-07 11:36:48
    代码的时候经常会用到unicode编码和解码,这里记录一下unicode的工具类。 其实unicode编码和解码,就是16进制数字和char之间的来回转换。 先看一下工具类: package com.test.test.util; import org.apache....
  • 整理收集的一些常用java工具类

    万次阅读 多人点赞 2017-08-20 19:42:14
    整理收集的一些常用java工具类
  • java手动分页工具类

    千次阅读 2019-03-04 14:14:20
    开发中,碰到了一些奇葩的业务逻辑,无法使用框架自身的分页功能,想了很久最后还是决定自己手写一个分页工具类,以备后续参考和使用,下面直接上代码, /** * 手动分页类 * @param datas * @param pageSize * ...
  • java雪花算法工具类

    万次阅读 2021-06-04 09:58:13
    创建一个SnowFlake的工具类,然后把下面的代码粘过去就可以了 /** * Twitter_Snowflake<br> * SnowFlake的结构如下(每部分用-分开):<br> * 0 - 0000000000 0000000000 0000000000 0000000000 0 - ...
  • 将自己的工具类项目右键导出jar文件保存到自己设置的目录中 打开cmd命令框输入并执行一下内容 mvn install:install-file -DgroupId=...
  • java实用类之正则工具类

    万次阅读 2021-09-20 11:47:01
    * 正则工具类 */ public class PatternUtil { /** * 匹配邮箱正则 */ private static final Pattern VALID_EMAIL_ADDRESS_REGEX = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern....
  • java工具类编写思考

    千次阅读 多人点赞 2018-09-06 08:55:11
    这篇博客的初衷是因为我想一个工具类,同时对工具类做出一些规范以及优化。 规范 工具类定义为final class,考虑到工具类应该不能被继承 工具类的命名应该用Util结尾,例如LogUtil 工具类的构造方法应该首选...
  • Java- HttpUtil工具类

    千次阅读 2022-03-15 10:56:09
    引入包 <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.7.22</version> </dependency> HttpUtill GET请求 ...
  • java 读写csv文件工具类

    千次阅读 2020-01-20 18:00:07
    依赖的jar包 <dependency> <groupId>net.sourceforge.javacsv</groupId>...javacsv</artifactId> <version>2.0</version> </dependency> 代码块 packa...
  • java 加密工具类

    千次阅读 2021-07-01 11:34:47
    * 加密工具类 * @author lwc * @version 1.0 * @date 2019-09-02 0:41 * */ public class EncryptUtils { /** * 盐值生成的长度,需要的长度除以二 */ private static final Integer saltLen=64; /** * ...
  • Java 内存缓存工具类

    千次阅读 2019-08-27 18:25:48
    /** * */ ... import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * @author liurui * @date 2019年8月27日 */ public class EasyCacheUtil { // 缓存...
  • java 工具类】集合判断是否为空

    千次阅读 2021-03-14 11:15:02
    java 工具类】集合判断是否为空【java 工具类】集合判断是否为空前言比如:判断list是否为空,通过我们是这样判断的:if(null != list && list.size() > 0){// ...}多了,就感觉太繁琐了。然后list...
  • java中什么是工具类

    千次阅读 2020-08-29 10:13:52
    工具类,顾名思义,就是使用的工具,哪里有需要就往哪里添加它,当遇到非静态的工具类,调用的时候还要去new一下。 用static修饰的都是属于类成员,类成员可以直接调用的,不是用static修饰的,必须使用类的对象去...
  • 1、HMAC-MD5、HMAC-SHA1 三、使用Java工具类进行MD5加密 Java提供了一个工具类进行MD5加密,首先我们需要引入一下依赖: commons-codec commons-codec 1.3 当然这个时候就有人说,天天依赖,我又没学过maven!...
  • JAVA常用工具类

    万次阅读 多人点赞 2018-09-11 22:28:32
    JAVA常用工具类(根据GITHUB代码统计) 从Google你能搜索到大量的关于Struts,Spring,Hibernate,iBatis等比较大的框架的资料,但是很少有人去关注一些小的工具包,但是当你真正知道了这些包的用处之后,你会发现它能很...
  • java线程池工具类

    千次阅读 2019-08-14 18:18:40
    public class ThreadPools { public static ExecutorService exec = new ThreadPoolExecutor( 20, 300, 0L, TimeUnit.MILLISECONDS, new LinkedB...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,305,383
精华内容 522,153
关键字:

java工具类怎么写

java 订阅