最近积累的一些工具方法（2019-09-24）

最新推荐文章于 2021-02-12 19:02:57 发布
最新推荐文章于 2021-02-12 19:02:57 发布
阅读量173 收藏
点赞数
分类专栏： 工作遇到 java基础 文章标签： 工具方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hq091117/article/details/91490887
版权 
 /**
 * 获取当前时间往前往后推几天
 *
 **/
 public Map<String,Date> getDate() {
        Map<String,Date> map = new HashMap<>(2);
        try {
            //获取当前日期
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date today = new Date();
            Date endDate = sdf.parse(sdf.format(today));
            //获取三十天前日期
            Calendar theCa = Calendar.getInstance();
            theCa.setTime(today);
            //最后一个数字5可改，5天的意思
            //data就是往前往后几天的意思，负数是往前，正数是往后
            theCa.add(Calendar.DATE, Integer.parseInt(date));
            Date start = theCa.getTime();
            //三十天之前日期
            Date startDate = sdf.parse(sdf.format(start));
            map.put("end",endDate);
            map.put("start",startDate);
        } catch (ParseException e) {
            e.printStackTrace();
            log.error(e);
        }
        return map;
    }


     /**
     * @param firstArrayList  第一个ArrayList
     * @param secondArrayList 第二个ArrayList
     * @return resultList 差集ArrayList
     * @方法描述：获取两个ArrayList的差集
     */
    public static List<IncomeInvResponse> receiveDefectList(List<IncomeInvResponse> firstArrayList,
            List<InvoiceDetailDO> secondArrayList) {
        List<IncomeInvResponse> resultList = firstArrayList.stream()
                .filter(item -> !secondArrayList.stream().map(e -> e.getInvoiceCode() + "|" + e.getInvoiceNum())
                        .collect(Collectors.toList()).contains(item.getInvoiceCode() + "|" + item.getInvoiceNr()))
                .collect(Collectors.toList());
        return resultList;
    }



     /**
     * 计算两个时间相差天数
     * @param date1
     * @param date2
     * @return
     */
    public static int differentDaysByMillisecond(Date date1, Date date2) {
        int days = (int) ((date2.getTime() - date1.getTime()) / (1000*3600*24));
        return days;
    }

    /**
     * 解析字符串中的数字和汉字
     * @param str
     * @return
     */
    public static Map<String,String> getChinaNum(String str) {
        Map<String,String> obj = new HashMap<>();
        if(StringUtils.isEmpty(str)){
            return obj;
        }
        //获取数字
        String a = str.replaceAll("[^0-9-]", "_").replace("_+", "_");
        String[] as = a.split("_+");
        obj.put("num",replaceNull(as));
        //获取汉字
        String b = str.replaceAll("[^\\u4e00-\\u9fa5]", "_").replace("_+", "_");
        String[] bs = b.split("_+");
        obj.put("china",replaceNull(bs));
        return obj;
    }

    /**
     * 去除数组中的空串
     * @param str
     * @return
     */
    public static String replaceNull(String[] str){
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<str.length; i++) {
            if("".equals(str[i])) {
                continue;
            }
            sb.append(str[i]);
            if(i != str.length - 1) {
                sb.append(",");
            }
        }
        return sb.toString();
    }



/**
     * 将一组数据固定分组，每组n个元素
     *
     * @param source 要分组的数据源
     * @param n      每组n个元素
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> fixedGrouping(List<T> source, int n) {

        if (null == source || source.size() == 0 || n <= 0) {
            return null;
        }
        List<List<T>> result = new ArrayList<List<T>>();
        int remainder = source.size() % n;
        int size = (source.size() / n);
        for (int i = 0; i < size; i++) {
            List<T> subset = null;
            subset = source.subList(i * n, (i + 1) * n);
            result.add(subset);
        }
        if (remainder > 0) {
            List<T> subset = null;
            subset = source.subList(size * n, size * n + remainder);
            result.add(subset);
        }
        return result;
    }

 

 

package com.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Header;
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.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.*;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;

public class HttpClientUtil {

    private static HttpClient httpClient;
    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    private static final Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);
    private static final String USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.110 Safari/537.36";

    static {
        List<Header> defaultHeaders = new ArrayList<Header>();
        defaultHeaders.add(new BasicHeader("content-type", "application/json"));
        httpClient = HttpClientBuilder.create()
                .setMaxConnPerRoute(50)
                .setMaxConnTotal(500)
                .setRetryHandler(new StandardHttpRequestRetryHandler(3, true))
                .setServiceUnavailableRetryStrategy(new DefaultServiceUnavailableRetryStrategy(2, 500))
                .setDefaultHeaders(defaultHeaders)
                .setUserAgent(USER_AGENT)
                .build();
    }


    public static String get(String httpUrl, List<NameValuePair> nvps) throws IOException {
        StringBuilder stringBuilder = new StringBuilder(httpUrl);
        if (nvps != null && nvps.size() > 0) {
            String params = (URLEncodedUtils.format(nvps, DEFAULT_CHARSET));
            stringBuilder.append("?" + params);
        }
        HttpGet httpGet = new HttpGet(stringBuilder.toString());
        HttpResponse response = httpClient.execute(httpGet);
        return EntityUtils.toString(response.getEntity(), "UTF-8");
    }


    public static String doPost(String url, String json) {
        String result = null;
        try {
            HttpPost post = new HttpPost(url);
            post.setEntity(new StringEntity(json, DEFAULT_CHARSET));

            String basicAuthKey = "pay:7C4F4363838B5846367BEB03962F8B81";
            String base64Result = Base64.getEncoder().encodeToString(basicAuthKey.getBytes("utf-8"));
            post.setHeader("Authorization",  base64Result);

            HttpResponse response = httpClient.execute(post);
            result = inputStreamToStr(response.getEntity().getContent(), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("url=>{}json=>{}发送Post请求失败，异常=>{}", url, json, e);
        }
        return result;
    }

    private static List<NameValuePair> buildPostParams(Map<String, String> params) {
        if (params == null || params.size() == 0) {
            return null;
        }
        List<NameValuePair> results = new ArrayList<NameValuePair>();

        for (Map.Entry<String, String> entry : params.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            results.add(new BasicNameValuePair(key, value));
        }
        return results;
    }

    public static String inputStreamToStr(InputStream is, String charset) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(is, "ISO-8859-1"));
        StringBuffer buffer = new StringBuffer();
        String line = "";
        while ((line = in.readLine()) != null) {
            buffer.append(line);
        }
        return new String(buffer.toString().getBytes("ISO-8859-1"), charset);
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url   发送请求的 URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, String param) {
        logger.info("url=>{}, param=>{}", url, param);
        HttpPost httppost = new HttpPost(url);
        if (StringUtils.isNotBlank(param)) {
            StringEntity se = new StringEntity(param, "utf-8");
            se.setContentType("application/json; charset=UTF-8");
            httppost.setEntity(se);
        }
        HttpResponse response;
        InputStream inputStream = null;
        String result = null;
        try {
            response = httpClient.execute(httppost);
            inputStream = response.getEntity().getContent();
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes, 0, 1024);
            while (len > 0) {
                output.write(bytes, 0, len);
                len = inputStream.read(bytes, 0, 1024);
            }
            result = new String(output.toByteArray(), "utf-8");
            logger.info("发送请求完成,result:{}", result);
        } catch (IOException e) {
            logger.error("发送请求失败,异常:{}", e);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
        return result;
    }

    /**
     * 向指定URL发送GET方法的请求
     *
     * @param url   发送请求的URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return URL 所代表远程资源的响应结果
     */
    public static String sendGet(String url, String param) {
        StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try {
            String urlNameString = url + "?" + param;
            URL realUrl = new URL(urlNameString);
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            in = new BufferedReader(new InputStreamReader(
                    connection.getInputStream(), "UTF-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
        } catch (Exception e) {
            logger.error("发送GET请求出现异常！" + e);
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                logger.error("异常"+ e2.toString());
            }
        }
        return result.toString();
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url   发送请求的 URL
     * @param message 请求参数，json的形式。
     * @return 所代表远程资源的响应结果
     */
    public static Boolean postUrl(String url, String message) {
        logger.info("url=>{}, message=>{}", url, message);
        HttpPost httppost = new HttpPost(url);
        String currentTime = String.valueOf(System.currentTimeMillis()/1000);
        httppost.addHeader("Authorization", "BTBPM17D4A7ABEE164341B879A1E9D44CB674");
        httppost.addHeader("App-Key", "192208F8DB5942DBBCB16ED762B7DCDE");
        httppost.addHeader("APP_SECRET", "65E66CFE173F4F8A864BCA50DB6FC979");
        httppost.addHeader("Timestamp", currentTime);
        httppost.addHeader("Sign-Method", "md5");
        httppost.addHeader("Sign", encryptSign(message, currentTime));

        StringEntity se = new StringEntity(message, "utf-8");
        se.setContentType("application/json; charset=UTF-8");
        httppost.setEntity(se);
        InputStream inputStream = null;
        HttpResponse response;
        Boolean isSuccess = false;
        try {
            response = httpClient.execute(httppost);
            inputStream = response.getEntity().getContent();
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes, 0, 1024);
            while (len > 0) {
                output.write(bytes, 0, len);
                len = inputStream.read(bytes, 0, 1024);
            }
            String result = new String(output.toByteArray(), "utf-8");
            JSONObject dataObject = JSON.parseObject(result);
            isSuccess = dataObject.getBoolean("IsSuccess");
            logger.info("发送请求完成,result:{}", result);
        } catch (IOException e) {
            logger.error("发送请求失败,异常:{}", e);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
        return isSuccess;
    }

    private static String encryptSign(String param, String currentTime) {

      return null;
    }



    /**
     * POST请求返回String
     *
     * @param url
     * @param param
     * @param cookie
     * @return
     */
    public static String doPost(String url, Map<String, String> param, String cookie) {
        logger.info("url=>{}, param=>{}", url, JSON.toJSONString(param));
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            response = postResponse(httpClient, response, url, param, cookie);
            resultString = EntityUtils.toString(response.getEntity(), "utf-8");
            logger.info("请求完成：{}", resultString);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return resultString;
    }

    public static String doPost(String url, Map<String, String> param) {
        return doPost(url, param, null);
    }

    /**
     * POST请求
     *
     * @param httpClient
     * @param response
     * @param url
     * @param param
     * @param cookie
     * @return
     */
    public static CloseableHttpResponse postResponse(CloseableHttpClient httpClient, CloseableHttpResponse response,
            String url, Map<String, String> param, String cookie) {

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            if (cookie != null) {
                httpPost.setHeader("Cookie", cookie);
            }

            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return response;
    }
}

关流工具

 public static void close(Closeable... closeables){
        if(closeables != null){
            for(Closeable closeable:closeables){
                try {
                    closeable.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

 

hq091117
关注
专栏目录
Android-常用的一些工具类
08-13
"Android-常用的一些工具类"这个资源可能是一个开源项目，名为MYXG-Tools-master，它很可能包含了开发者在日常工作中积累的各种实用工具函数。下面我们将详细探讨一些常见的Android工具类及其重要性。 1. **日期...
Java获取当前日期的前30天
qxx_918的博客
01-08 1万+
//获取当前日期         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");         Date today = new Date();         String endDate = sdf.format(today);//当前日期        
Calendar的add()方法介绍
suoyihen
01-11 4619
由于项目当中要统计指定日期的日志记录，是使用Calendar的add方法来进行对日期参数进行相关的动态改变。但是看了java doc上面介绍的不是很清楚，只是说了一下add能够做什么事，并没有介绍如何具体实现。看了网上的一些资料大部分都是在讲add和roll两个方法的区别，其实我们只需要使用add方法就可以解决大部分的功能。比如我们需要得到当前年，月，日，小时，分钟，秒，毫秒的前面时间或者后面时间...
2019-05-06 两个有对象的List，根据对象的某些属性来取差集
hq091117的博客
05-06 3882
/** * @方法描述：获取两个ArrayList的差集 * @param firstArrayList 第一个ArrayList * @param secondArrayList 第二个ArrayList * @return resultList 差集ArrayList */ public static List<IncomeInvResponse> receiveDef...
java date 相差_Java获得日期相差的天数
weixin_33788465的博客
02-12 326
文章来源: http://www.jb51.net/article/75551.htm这篇文章主要介绍了java计算两个时间相差天数的方法，感兴趣的小伙伴们可以参考一下:问题描述：输入：两个日期输出：两个日期相差的天数具体代码实现方法1：通过Calendar类的日期比较。注意：这里需要考虑一下：日期是跨年份的，如一个是2012年，一个是2015年的年份是分闰年和平年的，各自的天数不同/*** da...
判断两个时间的间隔
霓虹深处
05-04 2425
public static Integer getCompareDate(String startDate) throws ParseException { SimpleDateFormat formatter=new SimpleDateFormat("yyyy-MM-dd"); Date date1=formatter.parse(startDate); Date d...
ccks2019-el-master.zip
最新发布
04-14
描述中提到的“蓝桥杯2024”可能是比赛的名字或者是该竞赛的一个后续活动，但请注意，2019年的项目不太可能直接关联到2024年的赛事，除非是历年的积累或复习资料。 标签 "蓝桥杯" 指的是“蓝桥杯全国软件和信息技术...
x-easypdf pdf构建工具
08-14
pdfbox作为Apache的一个开源项目，已经在PDF处理领域积累了丰富的经验和强大的功能，而x-easypdf在此基础上进行了封装和优化，使得开发者能够更便捷地利用这些功能。 在实际应用中，x-easypdf适用于各类需要生成PDF...
swift-iOS开发过程中积累的程序优化工具
08-15
这里我们关注的是在开发过程中积累的一些程序优化工具。这些工具和技巧旨在提升UI响应速度、优化内存管理、改善代码执行效率，以及更好地控制线程和定时器。让我们逐一探讨这些主题。 1. **UI的顺序执行**：在iOS...
Android-提交工具类的一个项目平时的项目积累代码。
08-13
"Android-提交工具类的一个项目平时的项目积累代码"是一个集合了多种工具方法的资源库，适用于不同水平的开发者，从初级到高级。下面我们将详细探讨这个项目中可能包含的常见工具类及其重要知识点。 1. **字符串...
IO工具类 - IOUtils
u010599816的博客
11-20 879
/** <a href="http://www.cpupk.com/decompiler">Eclipse Class Decompiler</a> plugin, Copyright (c) 2017 Chen Chao. */ package org.apache.commons.io; import java.io.BufferedInputStream; impo...
java 判断两个时间相差的天数
weixin_33728708的博客
11-27 228
1、实现目标 　　输入：两个日期 　　输出：两个日期相差的天数 2、代码实现 方法1： 　　通过Calendar类的日期比较。注意：这里需要考虑一下： 　　日期是跨年份的，如一个是2012年，一个是2015年的 　   年份是分闰年和平年的，各自的天数不同 /** * date2比date1多的天数 * @param date1 ...
Java中计算两个日期间隔多少天
u013456370的专栏
02-23 4万+
String dbtime1 = "2017-02-23";  //第二个日期 String dbtime2 = "2017-02-22";  //第一个日期 //算两个日期间隔多少天 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); Date date1 = format.parse(dbtime1); Date
对接顺丰接口相关
热门推荐
hq091117的博客
01-21 25万+
今天做了下对接顺丰的接口，对接的是http的接口，这个没什么说的，主要记录下返回的xml格式数据，并解析 import java.io.ByteArrayInputStream; import java.security.MessageDigest; import java.util.HashMap; import java.util.List; import java.util.Map; ...
从HttpServletRequest中读取请求body中的数据
hq091117的博客
09-05 1万+
工作中遇到要从HttpServletRequest request中获取body的值，不像mvc一样可以直接@RequestBody获取， 代码： BufferedReader br = request.getReader();             String str = "";             String listString = "";             while ...
2019-10-25 sql的in()里面数据太多怎么办
hq091117的博客
11-12 1万+
问题： 项目里一直有个问题，就是sql查询一张表(t)需要根据用户公司权限，而用户公司权限的值是根据接口从另外一个项目查询过来的，(公司权限，因为有很多分公司，用户可能有很多公司的权限，就是拥有这些公司的id)当然表(t)里的记录都有对应哪家公司的id,所以查询记录的时候会带上公司id,当有些用户拥有几百家公司id的话，那这个sql里的id in(几百个)，这样查询效率超级差，因为我们知道in本...
mysql事务的坑----MyISAM表类型不支持事务操作
hq091117的博客
11-28 9744
最近需要通过JDBC对数据库做事务型操作，实践时发现，并没有达到想要的效果，表现在：1、每次执行executeUpdate()后，数据就马上能在DB中查到。但按理来说，我还没执行commit()，DB中不应该有这个数据；2、执行rollback()时，数据也没回滚。 定位问题后，发现是数据库表类型在作祟： 当时设定的“表类型”为MyISAM，而这种类型，是不支持事务操作的。 能够支持事务操作的表...
request取出file与用httpclient进行文件上传（MultipartEntityBuilder 并解决上传时乱码问题）
hq091117的博客
10-15 3448
//这是一个以前的接口，采用.do的链接方式，现在一般都不会用了，最近的工作就是从以前很老的项目中进行改造，所以遇到， //所以参数都是放在request的body中，这样就需要从request取出file流,然后再调另外服务器接口进行文件上传到另外的一个服务//器中 //这里主要了解了从request请求获取file，和怎么样用httpclient去上传文件 /**      * requ...
mybatis的if判断
hq091117的博客
07-14 3358
<if test='isInterview == "1" and role == "manager"'> and a.line_manager_interview is not null </if> mybatis动态sql，用if判断时，如果条件=是这种等于的，参数又是string的，就需要用这种，test=''单引号，里面参数==""用双引号，具体原因还没去查下，先记下来 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值