Java开发工具类

已于 2022-08-22 10:33:01 修改
阅读量1.3k 收藏
点赞数
文章标签： java 数据库 开发语言
于 2022-07-13 10:30:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41560394/article/details/125758517
版权

数字工具类

import java.math.BigDecimal;
/**
 * @decription 数字工具类
 */
public class NumberUtils {


    private static BigDecimal numIsExit(String num) {
        return num != null ? new BigDecimal(num) : new BigDecimal(0);
    }

    /**
     * 相除 num1/num2
     *
     * @param num1 10
     * @param num2 5
     * @return 2
     */
    public static String numDivide(String num1, String num2) {
        if (BigDecimal.ZERO.toString().equals(num1)) {
            //被除数不能为0
            return BigDecimal.ZERO.toString();
        }
        BigDecimal bigDecimal1 = numIsExit(num1);
        BigDecimal bigDecimal12 = numIsExit(num2);

        BigDecimal result5 = bigDecimal1.divide(bigDecimal12, 15, BigDecimal.ROUND_DOWN);
        return result5.toString();
    }

    /**
     * 保留两位位小数
     *
     * @param num
     * @return
     */
    public static BigDecimal numScale2(String num) {
        num = numIsExit(num).toString();
        BigDecimal bigDecimal = new BigDecimal(num).setScale(2, BigDecimal.ROUND_DOWN);
        return bigDecimal;
    }
    /**
     * 保留两位位小数
     *
     * @param num
     * @return
     */
    public static BigDecimal numScale0(BigDecimal num) {
        if (num==null){
            num=BigDecimal.ZERO;
        }
        BigDecimal bigDecimal = new BigDecimal(num.toString()).setScale(0, BigDecimal.ROUND_DOWN);
        return bigDecimal;
    }

    /**
     * 保留两位位小数
     *
     * @param num
     * @return
     */
    public static BigDecimal numScale2(BigDecimal num) {
        if (num==null){
            num=BigDecimal.ZERO;
        }
        BigDecimal bigDecimal = new BigDecimal(num.toString()).setScale(2, BigDecimal.ROUND_DOWN);
        return bigDecimal;
    }

    /**
     * 保留四位小数
     *
     * @param num
     * @return
     */
    public static BigDecimal numScale4(String num) {
        num = numIsExit(num).toString();
        BigDecimal bigDecimal = new BigDecimal(num).setScale(4, BigDecimal.ROUND_DOWN);

        return bigDecimal;
    }

    /**
     * 返回百分比值
     *
     * @param num
     * @return
     */
    public static BigDecimal getNumPercent(String num) {
        BigDecimal bigDecimal = numIsExit(num);
        bigDecimal= bigDecimal.multiply(new BigDecimal(100));
        return bigDecimal;
    }

}
//        100 compareTo 0   1
//        100 compareTo 0   -1
//        100 compareTo 100   -1
//        System.out.println(NUM_100.compareTo(new BigDecimal(100)));

日期工具类


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * date util
 *
 * @author xuxueli 2018-08-19 01:24:11
 */
public class DateUtil {

    // ---------------------- format parse ----------------------
    private static Logger logger = LoggerFactory.getLogger(DateUtil.class);

    private static final String DATE_FORMAT = "yyyy-MM-dd";
    private static final String DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private static final ThreadLocal<Map<String, DateFormat>> dateFormatThreadLocal = new ThreadLocal<Map<String, DateFormat>>();
    private static DateFormat getDateFormat(String pattern) {
        if (pattern==null || pattern.trim().length()==0) {
            throw new IllegalArgumentException("pattern cannot be empty.");
        }

        Map<String, DateFormat> dateFormatMap = dateFormatThreadLocal.get();
        if(dateFormatMap!=null && dateFormatMap.containsKey(pattern)){
            return dateFormatMap.get(pattern);
        }

        synchronized (dateFormatThreadLocal) {
            if (dateFormatMap == null) {
                dateFormatMap = new HashMap<String, DateFormat>();
            }
            dateFormatMap.put(pattern, new SimpleDateFormat(pattern));
            dateFormatThreadLocal.set(dateFormatMap);
        }

        return dateFormatMap.get(pattern);
    }

    /**
     * format datetime. like "yyyy-MM-dd"
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static String formatDate(Date date) {
        return format(date, DATE_FORMAT);
    }

    /**
     * format date. like "yyyy-MM-dd HH:mm:ss"
     *
     * @param date
     * @return
     * @throws ParseException
     */
    public static String formatDateTime(Date date) {
        return format(date, DATETIME_FORMAT);
    }

    /**
     * format date
     *
     * @param date
     * @param patten
     * @return
     * @throws ParseException
     */
    public static String format(Date date, String patten) {
        return getDateFormat(patten).format(date);
    }

    /**
     * parse date string, like "yyyy-MM-dd HH:mm:s"
     *
     * @param dateString
     * @return
     * @throws ParseException
     */
    public static Date parseDate(String dateString){
        return parse(dateString, DATE_FORMAT);
    }

    /**
     * parse datetime string, like "yyyy-MM-dd HH:mm:ss"
     *
     * @param dateString
     * @return
     * @throws ParseException
     */
    public static Date parseDateTime(String dateString) {
        return parse(dateString, DATETIME_FORMAT);
    }

    /**
     * parse date
     *
     * @param dateString
     * @param pattern
     * @return
     * @throws ParseException
     */
    public static Date parse(String dateString, String pattern) {
        try {
            Date date = getDateFormat(pattern).parse(dateString);
            return date;
        } catch (Exception e) {
            logger.warn("parse date error, dateString = {}, pattern={}; errorMsg = {}", dateString, pattern, e.getMessage());
            return null;
        }
    }


    // ---------------------- add date ----------------------

    public static Date addYears(final Date date, final int amount) {
        return add(date, Calendar.YEAR, amount);
    }

    public static Date addMonths(final Date date, final int amount) {
        return add(date, Calendar.MONTH, amount);
    }

    public static Date addDays(final Date date, final int amount) {
        return add(date, Calendar.DAY_OF_MONTH, amount);
    }

    public static Date addHours(final Date date, final int amount) {
        return add(date, Calendar.HOUR_OF_DAY, amount);
    }

    public static Date addMinutes(final Date date, final int amount) {
        return add(date, Calendar.MINUTE, amount);
    }

    private static Date add(final Date date, final int calendarField, final int amount) {
        if (date == null) {
            return null;
        }
        final Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(calendarField, amount);
        return c.getTime();
    }

}

请求工具类

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpClientUtils {

    /**
     * get
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    /**
     * post form
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      Map<String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }

        return httpClient.execute(request);
    }

    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        request.addHeader("Content-type", "application/json; charset=utf-8");
        request.setHeader("Accept", "application/json");
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Post stream
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Put String
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Put stream
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Delete
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path, String method,
                                        Map<String, String> headers,
                                        Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }

        return sbUrl.toString();
    }

    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }

        return httpClient;
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                @Override
                public void checkClientTrusted(X509Certificate[] xcs, String str) {

                }
                @Override
                public void checkServerTrusted(X509Certificate[] xcs, String str) {

                }
            };
            ctx.init(null, new TrustManager[] { tm }, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }
}
DayByDayCode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java自定义工具类编写
qq_43699118的博客
06-26 691
java自定义工具类编写 得到一天的最后时刻 public static Date getDateOneDayEnd(Date date) throws ParseException { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); calendar.set(Calendar.HOUR_OF_DAY, 23); calendar.set(Calendar.
Java并发工具类
weixin_46488959的博客
10-07 526
Lock Condition Semaphore ReadWriteLock StampedLock CountDownLatch、CyclicBarrier 并发容器 原子类 Executor与线程池 Future(获取任务执行结果) CompletableFuture(异步编程) CompletionService Fork/Join(并行计算框架)
java自定义工具类编写规范
虽千万人,吾往矣
09-02 4675
1.工具类定义为`public final class 工具类名称`；2. 工具类名称的命名应为`Util结尾`，例如`BaseUtil`；3. 工具类的构造方法最好为`private`，及这个类无法实例化，无法new出一个工具类；4. 工具类的方法应为`static`修饰的，表示静态方法，可直接通过类名.方法名的格式去访问；5. 工具类应使用单例模式，不要使用new，重复创建对象，浪费系统资源
java 公共类多次用_java经常使用16种工具类
weixin_36339157的博客
02-13 431
一. org.apache.commons.io.IOUtilscloseQuietly：关闭一个IO流、socket、或者selector且不抛出异常，通常放在finally块toString：转换IO流、Uri、byte[]为Stringcopy：IO流数据复制，从输入流写到输出流中，最大支持2GBtoByteArray：从输入流、URI获取byte[]write：把字节. 字符等写入输出流t...
2024年最新Java Utils工具类大全，架构师必备技能
最新发布
ghfgjfg679的博客
05-08 954
我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目需要这份系统化的资料的朋友，可以点击这里获取│ │ ProUtilTest.java│ │ RandomUtilTest.java│ │ RegUtilTest.java│ │ SecUtilTest.java
java工具类怎么写_整理收集的一些常用java工具类
weixin_36250058的博客
02-22 379
1.json转换工具1.packagecom.taotao.utils;3.importjava.util.List;5.importcom.fasterxml.jackson.core.JsonProcessingException;6.importcom.fasterxml.jackson.databind.JavaType;7.importcom.fasterx...
java中工具类的一般写法
qqqz123456789的专栏
06-23 5147
class ArrayTool{ public int getMax(int[] arr){ int max=0; for(int x=1;x if(arr[x]>arr[max])   max=x; } return arr[max]; } public int getMin(int[] arr){ int min=0; for(int x=1;x if(arr[x]
java 工具类
大猩猩的博客
11-17 64
1、http://www.shixinke.com/date-2019-10.html
java开发工具类（常用）
12-01
对于日期，随机字符，时间差计算，拼音转换，金额计算转换，网络图片保存，身份证出生日期获取，字符串首字母获取，年月加减计算等
java开发工具类
03-07
Java开发工具类是Java编程中不可或缺的部分，它们提供了一系列便捷的方法，帮助开发者高效地完成日常开发任务。在Java中，工具类通常包含了各种通用的功能，比如字符串处理、集合操作、日期时间管理等。这些工具类...
java常用开发工具类大全
05-31
"java常用开发工具类大全"可能包含了一系列这样的工具类，旨在帮助开发者高效地解决各种常见问题。下面我们将深入探讨几个常见的Java工具类库以及它们在实际开发中的应用。 1. **Java标准库中的工具类** - `java....
JAVA开发常用工具类
06-19
下面我们将深入探讨一些Java开发中常用的工具类，并了解它们在实际项目中的应用。 1. **`java.util.ArrayList` 和 `java.util.LinkedList`**： 这两个类都是`java.util.List`接口的实现，提供了动态数组和链表数据...
spring内置工具类
weixin_42189550的博客
12-31 1351
断言 1、断言是一个逻辑判断，用于检查不应该发生的情况 2、Assert 关键字在 JDK1.4 中引入，可通过 JVM 参数-enableassertions开启 3、SpringBoot 中提供了 Assert 断言工具类，通常用于数据合法性检查 // 要求参数 object 必须为非空（Not Null），否则抛出异常，不予放行 // 参数 message 参数用于定制异常信息。 void notNull(Object object, String message) // 要求参数必须空（Null），
Java常用工具类方法
Yu_Mariam的博客
08-20 339
日期工具类 public class DateUtil { private DateUtil() { } public static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"; public static final String yyyyMMddHHmmss = "yyyyMMddHHmmss"; public static final String yyyyMMdd = "yyyyMMdd"; /
win10安装mysql5.5，成功入职阿里
m0_57431076的博客
06-17 176
开篇介绍 个人背景： 不说太多废话，但起码要让你先对我有一个基本的了解。本人毕业于浙江某二本院校，算是科班出身，毕业后就进了一家外包公司做开发，当然不是阿里的外包，具体什么公司就不透露了，在外包一呆就呆了整整2年多，直到现在才从外包离开，如今拿到阿里的offer准备入职了。 阐述原因： 在外包公司的两年里，作为一名菜鸡，确实非常合格，技术没什么长进，眼见也没有提升，没规划没未来，让人实在焦虑，之所以开始改变自己也是家庭发生了变故，才让自己开始思考人生。身边很多人感叹过，能从外包逆袭，算是传奇，所以今天想要分
JAVA之常用的工具类
热门推荐
上善若泪
04-16 3万+
目录 1 org.apache.commons.io.IOUtils 2 org.apache.commons.io.FileUtils 3org.apache.commons.lang.StringUtils 4 org.apache.http.util.EntityUtils 5 org.apache.commons.lang3.StringUtils 6 org.apache....
第六节、如何创建自己的工具类jar
小小木的博客
02-03 1029
到此，我们自定义的工具类jar就完成了。以后也可发布至阿里的中心maven仓库。后序可在编写项目时直接引入。pom文件添加maven-assembly-plugin打包配置。在项目根目录下新建一个lib文件，将我们打包的jar放进去。将生成的test-1.0.0.jar放到其他项目调用。我们新建一个项目，创建一个main方法。点击右手边maven。
常用的Java开发工具类
shyの个人笔记
08-30 4830
推荐一些比较常用的Java开发工具类
微信公众号开发java工具类
04-27
好的，我可以为您提供一些微信公众号开发Java工具类的信息。首先，您可以使用官方提供的Java SDK，它可以帮助您快速地开发微信公众号应用程序。该SDK提供了许多常用的API，例如获取用户基本信息、发送消息、创建菜单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值