代码笔记-技术代码随笔（更新ing）

BIGSHU0923

已于 2023-03-30 14:04:24 修改

阅读量312

点赞数 1

分类专栏：代码笔记文章标签： java spring json

于 2022-12-16 10:50:56 首次发布

本文链接：https://blog.csdn.net/qq_37398465/article/details/126167507

版权

代码笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

JsonPath解析Json快速获得其中的值

java：StringEscapeUtils.unescapeJava去掉转义字符
https://blog.csdn.net/a232884c/article/details/122365840

当数据表中一个字段作为数组使用

方法1 用字符串分割“,”

最简单的方法，但是要注意元素中不存在分割字符串，保证分割字符串是唯一的

public class test20230221 {
    public static void main(String[] args) {
        Person p1 = new Person("小明", "男", 12, 170, 120);
        Person p2 = new Person("小王", "男", 13, 175, 110);
        Person p3 = new Person("小朱", "男", 14, 169, 130);
        Person p4 = new Person("小花", "女", 15, 165, 90);
        Person p5 = new Person("小明", "男", 16, 170, 100);

        List<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        list.add(p5);
        List<String> nameList = list.stream().map(Person::getName).collect(Collectors.toList());

        String s2 = String.join("，", nameList);
        System.out.println(s2);
    }
}

在这里插入图片描述

方法二 json

一般得到的是一个java集合，这时候可以直接转成json字符串保存。

String s = JSON.toJSONString(nameList);
System.out.println(s);

在这里插入图片描述
转化之后一般还要解析

List<String> array = JSON.parseArray(s, String.class);
System.out.println(array);

在这里插入图片描述

方法三修改数据表中的字段类型，改成数组

如postgreSQL中的_varchar表示字符串数组，这种方式可以像java中的集合contains一样使用。可用来判断该字段是否包含某个元素，可通过SQL使用。
在这里插入图片描述

select * from table_a where column @> array[item];

postgreSQL 在DBeaver中设置主键自增

(‘department_department_key_seq’::regclass)
在这里插入图片描述
serial4这个类型
在新建字段时，可以选择serial这个类型，然后勾选not_null，并且设置主键

@RequestExcel处理带文件参数接口

接口中有一个文件参数，前端会传一个excel文件，后端只需要在参数前面使用@RequestExcel注解即可将excel文件变成一个集合，每个集合的元素就是行记录。

for嵌套stream踩的坑

java去掉返回对象中为NULL的属性

@JsonInclude(JsonInclude.Include.NON_NULL)

集合多字段排序

// 先以属性一降序,再进行属性二降序。
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));

Jackson处理null

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 
import java.io.IOException;
 
@Configuration
public class JacksonConfig {
    @Bean
    @Primary
    @ConditionalOnMissingBean(ObjectMapper.class)
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                jsonGenerator.writeString("");
            }
        });
        return objectMapper;
    }
}

FastJson处理null

import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
 
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
 
@Configuration
public class fastJsonConfig extends WebMvcConfigurationSupport {
 
    /**
     * 使用阿里 FastJson 作为JSON MessageConverter
     * @param converters
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(
                // 保留map空的字段
                SerializerFeature.WriteMapNullValue,
                // 将String类型的null转成""
                SerializerFeature.WriteNullStringAsEmpty,
                // 将Number类型的null转成0
                SerializerFeature.WriteNullNumberAsZero,
                // 将List类型的null转成[]
                SerializerFeature.WriteNullListAsEmpty,
                // 将Boolean类型的null转成false
                SerializerFeature.WriteNullBooleanAsFalse,
                // 避免循环引用
                SerializerFeature.DisableCircularReferenceDetect);
 
        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> mediaTypeList = new ArrayList<>();
        // 解决中文乱码问题，相当于在Controller上的@RequestMapping中加了个属性produces = "application/json"
        mediaTypeList.add(MediaType.APPLICATION_JSON);
        converter.setSupportedMediaTypes(mediaTypeList);
        converters.add(converter);
    }
}

Java对象与JSON字符串转换

Java对象与JSON字符串相互转换12，JSON对象和JSON字符串相互转换34
普通Java对象

//要导入fastjson依赖
Student student = new Student();
student.setName("张三");
student.setScore(95);

String s = JSON.toJSONString(student);
System.out.println("1 Java对象转Json字符串："+s);

String jsonString = "{\"name\":\"张三\",\"score\":95}";

Student student2 = JSON.parseObject(jsonString, Student.class);
System.out.println("2 Json字符串解析成Java对象："+student2);

JSONObject jsonObject = JSON.parseObject(jsonString);
System.out.println("3 Json字符串解析成Json对象："+jsonObject);

//4 Json对象转Json字符串
String s1 = jsonObject.toString();
System.out.println("4 Json对象转Json字符串："+s1);

集合

public class test1029 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小明");
        student.setAge(15);
        student.setGender("男");

        Student student1 = new Student("小丽", 14, "女");
        Student student2 = new Student("小王", 15, "男");

        List<Student> list = new ArrayList<>();
        list.add(student);
        list.add(student1);
        list.add(student2);
        System.out.println(list);
        System.out.println("=========");

        // 集合转json字符串
        String s = JSON.toJSONString(list);
        System.out.println(s);
        System.out.println("=========");
        
        // 解析json字符串
        List<Student> students = JSON.parseArray(s, Student.class);
        System.out.println(students);
        System.out.println("=========");
    }
}

结果
在这里插入图片描述

字符串和数字比较

输入字符串，并判断是否大于num,输入的字符串可以包含其他符号，如果不是纯数字，也返回false。
自定义的方法比包装类的解析字符串方法更快。

public class StingTest {
    public static void main(String[] args) {
        String str = "532";
        int num = 10000;
        System.out.println(isValid(str, 10000));
        if(Integer.parseInt(str) > num){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    }

    public static boolean isValid(String str, int num){
        // 输入字符串，并判断是否大于num,输入的字符串可以包含其他符号，如果不是纯数字，也返回false
        int count = 0;
        for(int i = 0; i < str.length(); i++){
            if(str.charAt(i) < '0' && str.charAt(i) > '9') return false;
            count = count*10+(str.charAt(i)-'0');
            if(count <= num) return false;
        }
        return true;
    }
}

正则表达式处理字符串

代码

/**
     * 处理字符串，前缀和空白字符
     * @param s 字符串
     * @param regex 正则表达式
     * @return 处理后的字符串
     */
    private static String handleString(String s, String regex){
        if(StringUtils.isEmpty(s)){
            log.info("文章段落为空");
            return s;
        }
        s = s.trim();  // 去除多余的空白字符
        int start;
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        // 去掉原始字符串开头位置的指定字符
        Matcher matcher = pattern.matcher(s);
        if (matcher.lookingAt()) {
            start = matcher.end();
            s = s.substring(start);
        }
        // 返回处理后的字符串
        return s;
    }

测试

测试案例，去除字符串" 34.如果\r\n"中的开头的数字和.，以及前后的空白字符

public static void main(String[] args) {
        String s = "  34.如果\r\n";
        System.out.println(s);
        System.out.println("==============");
        String s1 = handleString(s, "\\d+.{1}");
        System.out.println(s1);
        System.out.println("==============");
    }

结果

在这里插入图片描述

二叉树搜索众数

class Solution {
    Map<Integer, Integer> map = new HashMap();
    public int[] findMode(TreeNode root) {
        if(root.left == null && root.right == null) return new int[]{root.val};
        dps(root);
        List<Map.Entry<Integer, Integer>> list = map.entrySet().stream().sorted((o1,o2)->o2.getValue()-o1.getValue()).collect(Collectors.toList());
        List<Integer> res = new ArrayList<>();
        res.add(list.get(0).getKey());
        for(int i = 1; i < list.size(); i++){
            if(list.get(i).getValue() == list.get(i-1).getValue()){
                res.add(list.get(i).getKey());
            }else{
                break;
            }
        }
        return res.stream().mapToInt(Integer::intValue).toArray();
    }

    public void dps(TreeNode root){
        if(root == null) return;

        dps(root.left);

        map.put(root.val, map.getOrDefault(root.val, 0)+1);

        dps(root.right);
    }
}

集合交集

public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
        List<Integer> list2 = Arrays.asList(12, 3, 4, 7,53,234);
        List<Integer> res = list1.stream().filter(item -> {
            if (list2.contains(item)) return true;
            return false;
        }).collect(Collectors.toList());
        System.out.println(res);
    }

结果
在这里插入图片描述

两个列表去重

    public static void main(String[] args) {
        // 在有重复元素的列表中去掉另一个列表中有的元素，去一次
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5);  // 有重复元素的列表
        List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);  // 无重复元素的列表
        // 统计数字出现的次数
        HashMap<Integer, Integer> map = new HashMap<>();
        list1.forEach(item->{
            map.put(item, map.getOrDefault(item, 0)+1);
        });
        ArrayList<Integer> res = new ArrayList<>();
        // 去除元素
        list2.forEach(item->{
            map.put(item, map.get(item)-1);
            if(map.get(item) > 0){
                res.add(item);  // 收集删除后list1还保留的元素
            }
        });
        System.out.println(res);
    }

结果
在这里插入图片描述

模糊搜索

		<if test="queryDTO.key != null and queryDTO.key != ''">
            and se.EMPL_NM like concat('%',#{queryDTO.key},'%')
        </if>
        <if test="queryDTO.key != null and queryDTO.key != ''">
            or se.BUSI_UNIT like concat('%',#{queryDTO.key},'%')
        </if>
        <if test="queryDTO.key != null and queryDTO.key != ''">
            or se.LDR_TYPE like concat('%',#{queryDTO.key},'%')
        </if>
        <if test="queryDTO.key != null and queryDTO.key != ''">
            or s.SEX_DESC like concat('%',#{queryDTO.key},'%')
        </if>

#模糊搜索及模糊搜索查日期

where deleted = 0
        and pid is null
        <if test = "key != null and key != ''">
            and (
                index_wall_tag_name like concat('%', #{key}, '%')
                or
                create_user_name like concat('%', #{key}, '%')
                or
                to_char(create_time, 'YYYY/MM/DD') like concat(#{key}, '%')
            )
        </if>

postgresql _varchar类型

postgresql _varchar类型表示数组，用@>相当于java集合的contains方法

		SELECT
           *
        FROM
            table_a
        where
            deleted = 0
            and deptIdList<![CDATA[@>]]>
            ARRAY[<foreach collection="deptIdList" item="deptId" separator=",">
                #{deptId}::varchar
            </foreach>]

对应实体类的字段

    @TableField(value = "index_code", typeHandler = ArrayTypeHandler.class)
    private String[] indexCodeList;

VO时间类型转换

在VO的属性中添加@JsonFormat控制时间显示的格式和时区

@ApiModelProperty(value = "创建时间")
@JsonFormat(pattern = "yyyy/MM/dd", timezone = "GMT+8")
private LocalDateTime createTme;

Steam流 map

        Map<String, String> indexCodeMapping = indexWallSingleInfos.parallelStream().filter(item -> StringUtils.hasLength(item.getMappingCode())).collect(Collectors.toMap(IndexWallSingleInfo::getMappingCode, IndexWallSingleInfo::getIndexWallTagCode));

XXXConfig.class

项目的yml中的配置信息，可以转成配置类，类的属性要与yml文件里的属性对应上。

test-project:
  #校验排序字段
  filter-column:
    - create_time
    - update_time
    - id

@Configuration
@ConfigurationProperties(prefix = "test-project")
@EnableConfigurationProperties(TestProjectConfig.class)
@Getter
@Setter
public class TestProjectConfig{

    /**
     * 排序需要过滤的字段名称
     */
    private List<String> filterColumn;
}

BIGSHU0923

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码笔记-技术代码随笔（更新ing）

输入字符串，并判断是否大于num,输入的字符串可以包含其他符号，如果不是纯数字，也返回false。postgresql _varchar类型表示数组，用@>相当于java集合的contains方法。测试案例，去除字符串" 34.如果\r\n"中的开头的数字和.，以及前后的空白字符。Java对象与JSON字符串相互转换12，JSON对象和JSON字符串相互转换34。项目的yml中的配置信息，可以转成配置类，类的属性要与yml文件里的属性对应上。#模糊搜索及模糊搜索查日期。
复制链接

扫一扫