java开发小问题总结

一、java中年月日比大小

方法一：用毫秒比较，虽然是伪毫秒，但是相当精确

String date1 = "2007-10-12 18:35:00";
String date2 = "2008-10-12 18:35:00";
String pattern ="yyyy-MM-dd hh:mm:ss";
SimpleDateFormat sf = new SimpleDateFormat(pattern);
Date d1 = sf.parse(date1);
Date d2 = sf.parse(date2);
if(d1.getTime() > d2.getTime()){
System.out.println("date 1 > date 2");
}else{
System.out.println("date 1 < date 2");
}

方法二： Date类型就可直接比较的

Date a=...
Date b=...
int i=a.compareTo(b);
if(i>0)...
else if(i<0)...
else ...

二、java使用new Date()和System.currentTimeMillis()获取当前时间戳

在开发过程中，通常很多人都习惯使用new Date()来获取当前时间，使用起来也比较方便，同时还可以获取与当前时间有关的各方面信息，例如获取小时，分钟等等，而且还可以格式化输出，包含的信息是比较丰富的。但是有些时候或许你并不需要获取那么多信息，你只需要关心它返回的毫秒数就行了，例如getTime()。为了获取这个时间戳，很多人也喜欢使用new Date().getTime()去获取，咋一看没什么问题，但其实没这个必要。

 其实看一下java的源码就知道了：

public Date()
  {
    this(System.currentTimeMillis());
  }

已经很明显了，new Date()所做的事情其实就是调用了System.currentTimeMillis()。如果仅仅是需要或者毫秒数，那么完全可以使用System.currentTimeMillis()去代替new Date()，效率上会高一点。况且很多人喜欢在同一个方法里面多次使用new Date()，通常性能就是这样一点一点地消耗掉，这里其实可以声明一个引用。

三、 解决java前台传递时间到后台相差8个小时的时区问题

经过查阅相关资料发现在spring转json的默认实现jackson中会根据时区去转换时间，而jackson的默认时区跟
国内应该是相差8小时，所以再时间换算上相差了8小时

解决方案一，在Model的时间字段上加上注解

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss", timezone="GMT+8")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date regisDate; //注册时间

@JsonFormat用于输出的时候解析，并且设置解析时区
@DateTimeFormat用于接收 前端传的时间值自动转换 可以是Date 可以是string 注意 格式要一样 如yyyy-MM-dd HH:mm:ss
个人建议都加上。

解决方案二，application.yml配置文件增加以下配置

jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

date-format指定date输出格式为yyyy-MM-dd HH:mm:ss
time-zone指定时区，解决8小时的时间差问题

四、创建Maven项目时，GroupId和Artifact Id该怎么填写呢？

最近一直想自己搭建一个项目，练习一下，但每次创建maven项目时GroupId和Artifact Id都不知道该怎么写，其实主要是不知道它们都是什么意思，所以在网上搜了一下，并在这里做个记录。

   GroupId和ArtifactId被统称为“坐标”是为了保证项目唯一性而提出的，如果你要把你项目弄到maven本地仓库去，你想要找到你的项目就必须根据这两个id去查找。

GroupId一般分为多个段，这里我只说两段，第一段为域，第二段为公司名称。域又分为org、com、cn等等许多，其中org为非营利组织，com为商业组织。

  ArtifactId 也是当前工程的名字，定义maven项目在组中唯一的ID

   举个apache公司的tomcat项目例子：这个项目的GroupId是org.apache，它的域是org（因为tomcat是非营利项目），公司名称是apache，ArtifactId是tomcat。 

比如我创建一个项目，我一般会将GroupId设置为cn.zt，cn表示域为中国，zt是我个人姓名缩写，ArtifactId设置为ksj，表示你这个项目的名称是ksj，依照这个设置，在你创建Maven工程后，新建包的时候，包结构最好是cn.zt.ksj打头的，如果有个UserDao，它的全路径就是cn.zt.ksj.dao.UserDao
　　

五、Java整合极光推送 ( 简单 )

https://www.cnblogs.com/hanzhe/p/14312564.html

@Component
public class JPushUtil {

    // 设置好账号的app_key和masterSecret是必须的
    private static String APP_KEY = "bedab8db78aeb49ffc39607c";
    private static String MASTER_SECRET = "1bf73e7050899e9de2fa18fb";


    // 极光推送>>Android
    //Map<String, String> parm是我自己传过来的参数,可以自定义参数
    public static void jpushAndroid(Map<String, String> parm) {

        // 创建JPushClient(极光推送的实例)
        JPushClient jpushClient = new JPushClient(MASTER_SECRET, APP_KEY);
        // 推送的关键,构造一个payload
        PushPayload payload = PushPayload.newBuilder()
                 .setPlatform(Platform.android())//指定android平台的用户
                 .setAudience(Audience.alias("text_123")) // 设置别名发送,单发，点对点方式
                 .setNotification(Notification.alert(parm.get("msg")))
  //              .setAudience(Audience.all()) // 你项目中的所有用户

                //.setNotification(Notification.android(parm.get("msg"), parm.get("title"), parm)) // 发送内容
                // TimeToLive 两个小时的缓存时间
                 .setOptions(Options.newBuilder().setApnsProduction(true).setTimeToLive(7200).build())
                //.setMessage(Message.content(JSON.toJSONString(parm.get("msg")))) // 自定义信息
                 .build();

        try {
            PushResult pu = jpushClient.sendPush(payload);
            System.out.println(pu.toString());
        } catch (APIConnectionException e) {
            e.printStackTrace();
        } catch (APIRequestException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 设置推送参数
        // 这里可以自定义推送参数了
        Map<String, String> parm = new HashMap<String, String>();
        // 设置提示信息,内容是文章标题
        parm.put("msg","shujuelin");
        parm.put("title","某电商类APP");
        parm.put("alias","alias");
        JPushUtil.jpushAndroid(parm);

    }

六、SpringBoot-RestTemplate实现调用第三方API

1. RestTemplate的方式来调用别人的API，将数据转化为json 格式，引入了fastjson

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.28</version>
</dependency>

2. 编写RestTemlateConfig，配置好相关信息

 
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
 
@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
        return new RestTemplate(factory);
    }
 
    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}

3.编写controller，调用第三方的API，浏览器模拟get请求，postman模拟post请求

 
 
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
 
import java.util.Map;
 
@RestController
public class SpringRestTemplateController {
    @Autowired
    private RestTemplate restTemplate;
    /***********HTTP GET method*************/
    @GetMapping("/testGetApi")
    public String getJson(){
        String url="http://localhost:8089/o2o/getshopbyid?shopId=19";
        //String json =restTemplate.getForObject(url,Object.class);
        ResponseEntity<String> results = restTemplate.exchange(url, HttpMethod.GET, null, String.class);
        String json = results.getBody();
        return json;
    }
 
    /**********HTTP POST method**************/
    @PostMapping(value = "/testPost")
    public Object postJson(@RequestBody JSONObject param) {
        System.out.println(param.toJSONString());
        param.put("action", "post");
        param.put("username", "tester");
        param.put("pwd", "123456748");
        return param;
    }
 
    @PostMapping(value = "/testPostApi")
    public Object testPost() {
        String url = "http://localhost:8081/girl/testPost";
        JSONObject postData = new JSONObject();
        postData.put("descp", "request for post");
        JSONObject json = restTemplate.postForEntity(url, postData, JSONObject.class).getBody();
        return json;
    }
}

七、java用spilt方法分割ip地址

必须对"."进行转意
“ . ”在正则表达式中有特殊的含义，因此我们使用的时候必须进行转义。

public static void main(string[] args) {  
string value = "192.168.128.33";  
string[] names = value.split("\\.");  
for (int i = 0; i < names.length; i++) {  
system.out.println(names[i]);  
}}  

八、JSON.parseObject 和 JSON.toJSONString 实例

JSON.parseObject，是将Json字符串转化为相应的对象；JSON.toJSONString则是将对象转化为Json字符串。在前后台的传输过程中，Json字符串是相当常用的，这里就不多介绍其功能了，直接举一下应用的小例子，帮助理解这两个方法的用法。

首先用maven引入fastjson

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wujiang.test</groupId>
    <artifactId>test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <fastjson_version>1.2.28</fastjson_version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson_version}</version>
        </dependency>
    </dependencies>
</project>

定义一个model类，员工，有四个属性，如下所示：

package jsonTest;

import java.util.Date;

/**
 * @author wujiang
 * @version 1.0.0.
 * @date 2017/4/30
 */
public class Staff {
    private String name;
    private Integer age;
    private String sex;
    private Date birthday;
    
    //省略getter和setter方法
    @Override
    public String toString() {
        return "Staff{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

好的，下一步，测试一下JSON.parseObject 和 JSON.toJSONString方法。这里故意在Json字符串中多了一个telephone，少了一个Staff中的birthday，看看输出的对象会有什么变化

package jsonTest;

import com.alibaba.fastjson.JSON;

/**
 * @author wujiang
 * @version 1.0.0.
 * @date 2017/4/30
 */
public class jsonTest {
    public static void main(String[] args) {
        /**
         * json字符串转化为对象
         */
        String jsonString = "{name:'Antony',age:'12',sex:'male',telephone:'88888'}";
        Staff staff = JSON.parseObject(jsonString, Staff.class);
        System.out.println(staff.toString());

        /**
         * 对象转化为json字符串
         */
        String jsonStr = JSON.toJSONString(staff);
        System.out.println(jsonStr);
    }
}

输出结果

Staff{name='Antony', age=12, sex='male', birthday=null}

{"age":12,"name":"Antony","sex":"male"}
//如果age是String类型，那么输出结果变为
//{"age":"12","name":"Antony","sex":"male"}

在JSON.parseObject 的时候，会去填充名称相同的属性。对于Json字符串中没有，而model类有的属性，会为null；对于model类没有，而Json字符串有的属性，不做任何处理。

至于 JSON.toJSONString 就不需要多说了，看一下就知道

至于应用场景，比方说，用户登录微信公众号的时候，调用微信官方的restful接口，得到该用户的所有信息的一个Json字符串，然后写一个类（将自己需要的信息封装成一个类）。例如下面的伪代码

String s = httpRequest.sendGet("https://api.weixin.qq.com/sns/oauth2/access_token","appid=" + appId + "&secret=" + appSecret + "&code=" + code + "&grant_type=authorization_code");

UserAuthorizationReturn userAuthorizationReturn = JSON.parseObject(s, UserAuthorizationReturn.class);

另外注意，如果需要对List进行json的转化，转成json字符串的方式没有区别，但是从json字符串转化回List时，需要使用JSON.parseArray方法。

String jsonStr = JSON.toJSONString(tableInfoVO.getFieldInfo())
List<FiledInfoVO> filedInfoVOList = JSON.parseArray(jsonStr,FiledInfoVO.class)

---

java将json格式的字符串转化为对象数组: 例子如下

//拿到需要转化的json字符串
String jsonString="[{\"input4\":\"40\",\"input3\":\"30\",\"input2\":\"20\",\"input1\":\"10\"}]";
JSONArray jsonArray=JSONArray.parseArray(jsonString);
for(int i=0;i<jsonArray.size();i++){
    JSONObject object= (JSONObject) jsonArray.get(i);
    System.out.println(object.get("input3"));
}

九、MyBatis-Plus EntityWrapper的使用

https://blog.csdn.net/shujuelin/article/details/99568651

十、springboot 读取 yml 配置的几种方式

https://blog.csdn.net/yucaifu1989/article/details/103524342
第一种读取方式@value
如果我们只需要配置文件中的一两个值,@Value 是最简单方便的方式.

server:
  port: 8081

我们在代码中可以这样取值

@Value("${server.port}")
public String port; 

第二种读取方式@ConfigurationProperties
如果需要一个JavaBean 来专门映射配置的话,我们一般会使用@ConfigurationProperties来读取.

student:
    age: 18
    name: mysgk

javabean:

@Component
@ConfigurationProperties(prefix = "student")
public class Student {
 
    private String name;
 
    private Integer age;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

使用@ConfigurationProperties,需要配置一个prefix (前缀) 参数, 即写上 key 就可以了

十一、MyBatisplus自动填充处理

1，继承MetaObjectHandler

2，注解填充字段 @TableField(… fill = FieldFill.INSERT) 生成器策略部分也可以配置！

    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

3，自定义实现类 DatePaddingHandler

package com.zl.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;


@Slf4j
@Component
public class DatePaddingHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("fill...........");
        //setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

十二、String.join() 方法的学习

以前我们循环字符串数组，并且要在每个元素的后面加一个符号的时候，我们总是要去处理首歌或者是最后一个加不加符号的问题，在引入jdk 1.8 以后，发现了一个特别好的api，就是这个：

可惜的是，这个只能是字符类型才能使用，就是下面这些：

示例代码：

public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("s1");
		list.add("s3");
		list.add("s5");
		list.add("s7");
		System.out.println(String.join(",", list));
	}

输出结果为：

s1,s3,s5,s7

十三、JSON数组形式字符串转换为List＜Map＜String,String＞＞的8种方法

package com.zkn.newlearn.json;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
 
import java.util.List;
import java.util.Map;
 
/**
 * Created by zkn on 2016/8/22.
 */
public class JsonToMapTest02 {
 
    public static void main(String[] args){
 
        String strArr = "[{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
                "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}]";
        //第一种方式
        List<Map<String,String>> listObjectFir = (List<Map<String,String>>) JSONArray.parse(strArr);
        System.out.println("利用JSONArray中的parse方法来解析json数组字符串");
        for(Map<String,String> mapList : listObjectFir){
            for (Map.Entry entry : mapList.entrySet()){
               System.out.println( entry.getKey()  + "  " +entry.getValue());
            }
        }
        //第二种方式
        List<Map<String,String>> listObjectSec = JSONArray.parseObject(strArr,List.class);
        System.out.println("利用JSONArray中的parseObject方法并指定返回类型来解析json数组字符串");
        for(Map<String,String> mapList : listObjectSec){
            for (Map.Entry entry : mapList.entrySet()){
                System.out.println( entry.getKey()  + "  " +entry.getValue());
            }
        }
        //第三种方式
        JSONArray listObjectThir = JSONArray.parseArray(strArr);
        System.out.println("利用JSONArray中的parseArray方法来解析json数组字符串");
        for(Object mapList : listObjectThir){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第四种方式
        List listObjectFour = JSONArray.parseArray(strArr,Map.class);
        System.out.println("利用JSONArray中的parseArray方法并指定返回类型来解析json数组字符串");
        for(Object mapList : listObjectFour){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第五种方式
        JSONArray listObjectFifth = JSONObject.parseArray(strArr);
        System.out.println("利用JSONObject中的parseArray方法来解析json数组字符串");
        for(Object mapList : listObjectFifth){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第六种方式
        List listObjectSix = JSONObject.parseArray(strArr,Map.class);
        System.out.println("利用JSONObject中的parseArray方法并指定返回类型来解析json数组字符串");
        for(Object mapList : listObjectSix){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第七种方式
        JSONArray listObjectSeven = JSON.parseArray(strArr);
        System.out.println("利用JSON中的parseArray方法来解析json数组字符串");
        for(Object mapList : listObjectSeven){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
        //第八种方式
        List listObjectEigh = JSONObject.parseArray(strArr,Map.class);
        System.out.println("利用JSON中的parseArray方法并指定返回类型来解析json数组字符串");
        for(Object mapList : listObjectEigh){
            for (Object entry : ((Map)mapList).entrySet()){
                System.out.println(((Map.Entry)entry).getKey()  + "  " +((Map.Entry)entry).getValue());
            }
        }
    }
}

十四、Java并行执行任务

invokeAll 可以提交多个任务，在任务完成前该方法会阻塞，直到所有任务完成或中断或超时，返回Future列表。
比如我们的商品详情接口，需要展示立减、阶梯满减、团购等活动标签。需要查询三次不同的活动信息，再组装活动标签信息。如果每次查询耗时1s，按照串行的方式去调用，整个接口下来至少需要3s，整个耗时，对于我们来讲是无法接受的。

private void assemblyActivityTag(CartItemDTO itemDTO) {
 
        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Callable<String>> tasks = Lists.newArrayList();
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //1.查询立减活动信息
                return null;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //2.查询阶梯满减活动信息
                return null;
            }
        });
        tasks.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //3.查询团购活动信息
                return null;
            }
        });
 
        try {
            List<Future<String>> futureList = executorService.invokeAll(tasks, 3000, TimeUnit.MILLISECONDS);
            for (Future<String> future : futureList) {
                // 获取线程执行结果
                try {
                    String activityTag = future.get();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        //4.组装活动标签信息
 
        //5.关闭线程池
        executorService.shutdown();
    }

十五、Java执行python脚本

项目需要提供一个python环境，进行数据加工。因此需要集成到微服务，使用Runtime.getRuntime()执行脚本文件。

package com.bdri.ds.service.impl;

import com.bdri.datasource.utils.FileUtils;
import com.bdri.datasource.utils.MysqlLogUtils;
import com.bdri.datasource.vo.ExecuteReslutVo;
import com.bdri.ds.service.DataPythonService;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.*;

/**
 * @date : 9:48 2021/9/14
 */
@Service
public class DataPythonServicelmpl implements DataPythonService {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public ExecuteReslutVo execute(String pythonCode) {
        ExecuteReslutVo reslutVo = new ExecuteReslutVo();
        BufferedReader bReader = null;
        InputStreamReader sReader = null;
        String log = new String();
        boolean status = false;
        try {
            FileUtils.write("/usr/local/pyCode/", pythonCode, "dataPorcess" + ".py");
            //FileUtils.write("F:\\", pythonCode, "dataPorcess" + ".py");
            //String[] args1 = {"D:\\Anaconda3\\python", "F:\\dataPorcess.py"};
            String[] args1 = {"python", "/usr/local/pyCode/dataPorcess.py"};
            Process p = Runtime.getRuntime().exec(args1); //放python文件的绝对路径
            InputStream error = p.getErrorStream();
            /* "标准输出流"就在当前方法中读取 */
            BufferedInputStream bis = new BufferedInputStream(p.getInputStream(), 5 * 1024 * 1024);
            String[] encoding = {"utf-8"};
            if (encoding != null && encoding.length != 0) {
                sReader = new InputStreamReader(bis, encoding[0]);// 设置编码方式
            } else {
                sReader = new InputStreamReader(bis, "utf-8");
            }
            bReader = new BufferedReader(sReader, 5 * 1024 * 1024);

            StringBuilder sb = new StringBuilder();
            String line;

            while ((line = bReader.readLine()) != null) {
                sb.append(line);
                sb.append("\n");
            }
            status = true;
            //关掉流
            bReader.close();
            //p.destroy();
            log = log + MysqlLogUtils.writeLog(MysqlLogUtils.LogLevel.INFO.value(), "自定义组件",
                    null, "执行成功: " + sb.toString());
            System.out.println(sb.toString());
            reslutVo.setStatus(status);
            reslutVo.setLog(log);

            if (error.available() != 0) {

                //为"错误输出流"单独开一个线程读取之,否则会造成标准输出流的阻塞
                //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
                ExecutorService threadPool = Executors.newSingleThreadExecutor();
                Future<String> result = threadPool.submit(new InputStreamRunnable(p.getErrorStream(), "ErrorStream"));
                if (StringUtils.isNotBlank(result.get())) {
                    //2.接收线程运算后的结果
                    try {
                        String sum = result.get();
                        log =  MysqlLogUtils.writeLog(MysqlLogUtils.LogLevel.ERROR.value(), "自定义组件",
                                null, "执行失败: " + sum);
                        reslutVo.setStatus(status);
                        reslutVo.setLog(log);
                        System.out.println(sum);
                        return reslutVo;
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    } finally {
                        threadPool.shutdown();
                    }
                }
            }
            p.destroy();
        } catch (Exception e) {
            e.printStackTrace();
            reslutVo.setStatus(status);
            return reslutVo;
        }
        return reslutVo;
    }
}

class InputStreamRunnable implements Callable<String> {
    BufferedReader bReader = null;

    public InputStreamRunnable(InputStream is, String _type) {
        try {
            bReader = new BufferedReader(new InputStreamReader(new BufferedInputStream(is, 1024 * 1024 * 4), "UTF-8"));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public String call() throws Exception {
        String line;
        StringBuffer sb = new StringBuffer();
        try {
            while ((line = bReader.readLine()) != null) {
                sb.append(line);
                sb.append("\n");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            bReader.close();
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        DataPythonServicelmpl dataPythonServicelmpl = new DataPythonServicelmpl();
        dataPythonServicelmpl.execute("xx");
    }
}

十六、判断list集合不为空

在java开发中新手容易将判断一个list集合是否为空，只以If（list！=null）去判断，且容易和isEmpty()混淆，但是，list集合为空还是为null，是有区别的。

先看一下下面的例子，你是否会认为输出null呢？

看一下控制台输出结果：

造成这种结果其实是null判断是判断有没有对list集合分配内存空间，而不是list里面内容是否为空。

看一下isEmpty()

isEmpty() 和(list.size() == 0)都是判断List内容是否为空
new一个user对象，判断user的list内容是否为空，出现异常，这是因为， 使用isEmpty()和size()的前提是，list是一个空集合，而不是null，否则会抛异常。

所有我们在判断集合不为空的时候常采用：if(list!=null&&!list.isEmpty())的方法去取list里面的值。

十七、JSON中的JSON.parseArray()方法

json转换的比较

十八、fastjson将json字符串转化成map的五种方法

package com.zkn.newlearn.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import java.util.Map;

/**
 * JSON字符串自动转换
 *
 */
public class JsonToMapTest01 {

    public static void main(String[] args){

        String str = "{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}";
        //第一种方式
        Map maps = (Map)JSON.parse(str);
        System.out.println("这个是用JSON类来解析JSON字符串!!!");
        for (Object map : maps.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"     " + ((Map.Entry)map).getValue());
        }
        //第二种方式
        Map mapTypes = JSON.parseObject(str);
        System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");
        for (Object obj : mapTypes.keySet()){
            System.out.println("key为："+obj+"值为："+mapTypes.get(obj));
        }
        //第三种方式
        Map mapType = JSON.parseObject(str,Map.class);
        System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");
        for (Object obj : mapType.keySet()){
            System.out.println("key为："+obj+"值为："+mapType.get(obj));
        }
        //第四种方式
        /**
         * JSONObject是Map接口的一个实现类
         */
        Map json = (Map) JSONObject.parse(str);
        System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");
        for (Object map : json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        //第五种方式
        /**
         * JSONObject是Map接口的一个实现类
         */
        JSONObject jsonObject = JSONObject.parseObject(str);
        System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");
        for (Object map : json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        //第六种方式
        /**
         * JSONObject是Map接口的一个实现类
         */
        Map mapObj = JSONObject.parseObject(str,Map.class);
        System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");
        for (Object map: json.entrySet()){
            System.out.println(((Map.Entry)map).getKey()+"  "+((Map.Entry)map).getValue());
        }
        String strArr = "{{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
                "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}}";
       // JSONArray.parse()
        System.out.println(json);
    }
}

十九、map转换成JSON的方法

alibaba fastJson：

1.Map转JSON

  Map<String, Object> map = new HashMap<String, Object>();
        map.put("a", "a");
        map.put("b", "123");

        JSONObject json = new JSONObject(map);

2.map转string

  Map<String, Object> map = new HashMap<>();
        map.put("a", "b");
        String s = JSONObject.toJSONString(map);

3.JSON转String

  JSONObject json = new JSONObject();
        json.put("c", "v");
        json.put("z", "123n);

        json.toJSONString();

4.JSON转Map

JSONObject json = new JSONObject();
        json.put("ccc", "321");
        json.put("bbb", "123");

        Map<String, Object> map = (Map<String, Object>)json;

5.String转JSON

 String str = "{"username":"dsad","qwewqe":"123"}";
JSONObject json = JSONObject.parseObject(str);

二十、Java中字符串indexof和substring使用

很早之前的，感觉这个博主讲得不错

https://blog.csdn.net/qq_27093465/article/details/51832189#

二十一、Maven中 jar包冲突原理与解决办法

https://blog.csdn.net/noaman_wgs/article/details/81137893

二十二、Java远程执行Shell指令

https://blog.csdn.net/justry_deng/article/details/89684711

JSch(Java Secure Channel)是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，进而使用端口转发，X11转发，文件传输等等功能。

二十三、java的pom关于maven依赖中的scope的作用和用法

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
</dependency>

博客地址

二十四、前端传一个数组或者集合后台怎么接受

https://blog.csdn.net/weixin_45433031/article/details/125885639
业务场景一：前端传对象集合后台如何接受？

[
	{
	   "id":"1",
	   "name":"辰兮",
	   "age":"22"
     },
	{
	   "id":"2",
	   "name":"辰兮要努力",
	   "age":"23"
     }
]

后台接受方式

@RequestBody List userList

二十五、MyBatis-Plus Page类的total值为0问题解决

问题描述：
Page类records能查询到数据，但是total值一直为0。

问题分析：
1、没有创建MybatisPlusInterceptor（MyBatisPlus分页拦截器）实例，导致total值一直为0。

博客地址

二十六、mybatis-plus的json存入mysql数据库

问题：List的list保存到数据库
字段： “catalogueRelate”: [“a”,“b”],
解决方法

二十七、使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等。

问题：遍历list采用stream

解决方法