Ping

/**
 * 如果c为汉字，则返回大写拼音；如果c不是汉字，则返回String.valueOf(c)
 */
String Pinyin.toPinyin(char c)

/**
 * c为汉字，则返回true，否则返回false
 */
boolean Pinyin.isChinese(char c)

/**
 * 将输入字符串转为拼音，转换过程中会使用之前设置的用户词典，以字符为单位插入分隔符
 */
String toPinyin(String str, String separator)

// 添加中文城市词典
Pinyin.init(Pinyin.newConfig().with(CnCityDict.getInstance());

// 添加自定义词典
Pinyin.init(Pinyin.newConfig()
            .with(new PinyinMapDict() {
                @Override
                public Map<String, String[]> mapping() {
                    HashMap<String, String[]> map = new HashMap<String, String[]>();
                    map.put("重庆",  new String[]{"CHONG", "QING"});
                    return map;
                }
            }));

char --> String // 字符 --> 拼音，如 20013(中) --> "ZHONG"

static final String[] PINYIN_TABLE = new String[]{"A", "AI", ...

char --> short // 字符 --> 拼音编码

// 计算出真实的编码
short decodeIndex(byte[] paddings, byte[] indexes, int offset) {
  int index1 = offset / 8;
  int index2 = offset % 8;
  short realIndex = (short) (indexes[offset] & 0xff);

  if ((paddings[index1] & PinyinData.BIT_MASKS[index2]) != 0) {
    realIndex = (short) (realIndex | PinyinData.PADDING_MASK);
  }
  return realIndex;
}

// 添加中文城市词典
Pinyin.init(Pinyin.newConfig().with(CnCityDict.getInstance());


/**
 * 将输入字符串转为拼音，转换过程中会使用之前设置的用户词典，以字符为单位插入分隔符
 *
 * 例: "hello:中国"  在separator为","时，输出： "h,e,l,l,o,:,ZHONG,GUO,!"
 *
 * @param str  输入字符串
 * @param separator 分隔符
 * @return 中文转为拼音的字符串
 */
String toPinyin(String str, String separator);

/**
 * free the unnecessary memory
 */
private void loseWeight()
{
    int nbase[] = new int[size + 65535];
    System.arraycopy(base, 0, nbase, 0, size);
    base = nbase;

    int ncheck[] = new int[size + 65535];
    System.arraycopy(check, 0, ncheck, 0, size);
    check = ncheck;
}

/**
 * 如果c为汉字，则返回大写拼音；如果c不是汉字，则返回String.valueOf(c)
 */
String Pinyin.toPinyin(char c)

/**
 * c为汉字，则返回true，否则返回false
 */
boolean Pinyin.isChinese(char c)

/**
 * 将输入字符串转为拼音，转换过程中会使用之前设置的用户词典，以字符为单位插入分隔符
 */
String toPinyin(String str, String separator)

Config config = Pinyin.newConfig()
                  .with(dict_1)
                  .with(....) // 可以继续添加多个词典
                  .with(dict_n);

Pinyin.init(config);

Pinyin.add(other_dict); // 向Pinyin中追加词典

词(String) --> 拼音(String[]) // 如："重庆" --> ["CHONG", "QING"]

/**
 * 字典接口
 */
public interface PinyinDict {

    /**
     * 字典所包含的所有词
     */
    Set<String> words();

    /**
     * 将词转换为拼音，应保证对words中的所有词，toPinyin(String)均返回非null的结果
     */
    String[] toPinyin(String word);
}

final Map<String, String[]> map = new HashMap();
map.put("重庆", new String[]{"CHONG", "QING"});

PinyinDict dict = new PinyinDict() {
    @Override
    public Set<String> words() {
        return map.keySet();
    }

    @Override
    public String[] toPinyin(String word) {
        return map.get(word);
    }
};

/**
 * 基于java.util.Map的字典实现，利于添加自定义字典
 */
public abstract class PinyinMapDict implements PinyinDict {

    /**
     * Key为字典的词，Value为该词所对应的拼音
     *
     * @return 包含词和对应拼音的 {@link java.util.Map}
     */
    public abstract Map<String, String[]> mapping();


    @Override
    public Set<String> words() {
        return mapping() != null ? mapping().keySet() : null;
    }

    @Override
    public String[] toPinyin(String word) {
        return mapping() != null ? mapping().get(word) : null;
    }
}

PinyinDict dict = new PinyinMapDict() {
    @Override
    public Map<String, String[]> mapping() {
        Map<String, String[]> map = new HashMap();
        map.put("重庆", new String[]{"CHONG", "QING"});
        return map;
    }
}

@Test
public void test_toPinyin_char() {
    char[] allChars = allChars();
    int chineseCount = 0;

    for (int i = 0; i < allChars.length; i++) {
        char targetChar = allChars[i];
        String[] pinyins = PinyinHelper.toHanyuPinyinStringArray(targetChar, format);
        if (pinyins != null && pinyins.length > 0) {
            // is chinese
            chineseCount++;
            assertThat(Pinyin.toPinyin(targetChar), equalTo(pinyins[0]));
        } else {
            // not chinese
            assertThat(Pinyin.toPinyin(targetChar), equalTo(String.valueOf(targetChar)));
        }
    }

    int expectedChineseCount = 20378;

    assertThat(chineseCount, is(expectedChineseCount));
}

public boolean canAttendMeetings(int[][] intervals) {
    if (intervals == null || intervals.length == 0) return false;
    /**       
    Arrays.sort(intervals, new Comparator<int[]>() {

            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
  */
    Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
    for (int i = 1; i < intervals.length; i++) {
        // 前一个结束时间大于后一个开始时间
        if (intervals[i][0] < intervals[i - 1][1]) {
            returtn false;
        }
    }
    return true;
}

// 用日期判断
public boolean canAttendMeetings(List<Meeting> meetings) {
    if (meetings == null || meetings.isEmpty()) {
        return false;
    }
    meetings.sort(Comparator.comparingLong(value -> value.getBdate().getTime()));
    log.debug("meetings={}", JSON.toJSONString(meetings));
    for (int i = 1; i < meetings.size(); i++) {
        // 前一个结束时间大于后一个开始时间
        if (meetings.get(i - 1).getEdate().after(meetings.get(i).getBdate())) {
            return false;
        }
    }
    return true;
}

// 测试
@Test
void test() {
    int[][] meetings = {{830, 900}, {900, 1000}, {1500, 1530}};
    log.debug("{}", MeetingUtils.canAttendMeetings(meetings));
    meetings = new int[][]{{830, 1000}, {900, 1000}, {1500, 1530}};
    log.debug("{}", MeetingUtils.canAttendMeetings(meetings));
    meetings = new int[][]{{830, 1000}, {1500, 1530}};
    log.debug("{}", MeetingUtils.canAttendMeetings(meetings));
    assertTrue(true);
}

@Test
void test1() {
    List<Meeting> meetingMoList = new ArrayList<>();
    Meeting meetingMo1;
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MILLISECOND, 0);

    meetingMo1 = new Meeting();
    calendar.set(Calendar.HOUR_OF_DAY, 8);
    calendar.set(Calendar.MINUTE, 0);
    meetingMo1.setBdate(calendar.getTime());
    calendar.set(Calendar.HOUR_OF_DAY, 8);
    calendar.set(Calendar.MINUTE, 30);
    meetingMo1.setEdate(calendar.getTime());
    meetingMoList.add(meetingMo1);

    meetingMo1 = new Meeting();
    calendar.set(Calendar.HOUR_OF_DAY, 8);
    calendar.set(Calendar.MINUTE, 30);
    meetingMo1.setBdate(calendar.getTime());
    calendar.set(Calendar.HOUR_OF_DAY, 9);
    calendar.set(Calendar.MINUTE, 0);
    meetingMo1.setEdate(calendar.getTime());
    meetingMoList.add(meetingMo1);

    log.debug("{}", MeetingUtils.canAttendMeetings(meetingMoList));

    meetingMo1 = new Meeting();
    calendar.set(Calendar.HOUR_OF_DAY, 9);
    calendar.set(Calendar.MINUTE, 0);
    meetingMo1.setBdate(calendar.getTime());
    calendar.set(Calendar.HOUR_OF_DAY, 10);
    calendar.set(Calendar.MINUTE, 0);
    meetingMo1.setEdate(calendar.getTime());
    meetingMoList.add(meetingMo1);

    log.debug("{}", MeetingUtils.canAttendMeetings(meetingMoList));
}

import java.util.LinkedList;
class Solution {
    public int minMeetingRooms(int[][] intervals) {
        if(intervals == null || intervals.length == 0){
            return 0;
        }
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

        PriorityQueue<Integer> queue = new PriorityQueue<>((o1, o2) -> o1 - o2);
        queue.offer(intervals[0][1]);
        for(int i = 1; i < intervals.length; i++){
            if(intervals[i][0] >= queue.peek()){
                queue.poll();
            }
            queue.offer(intervals[i][1]);
        }
        return queue.size();
    }
}

class Solution {
    // public int maxEvents(int[][] events) {
    //     Arrays.sort(events, (o1, o2) -> o1[1] - o2[1]);
    //     Set<Integer> set = new HashSet<>();
    //     for (int[] event : events) {
    //         for (int i = event[0]; i <= event[1]; ++i) {
    //             if (!set.contains(i)) {
    //                 set.add(i);
    //                 break;
    //             }
    //         }
    //     }
    //     return set.size();
    // }

    public int maxEvents(int[][] events) {
        Arrays.sort(events, (o1, o2) -> o1[0] - o2[0]);
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        int i = 0;
        int day = 1;
        int ans = 0;
        int n = events.length;

        while (i < n || !pq.isEmpty()) {
            while (i < n && events[i][0] == day) {
                pq.offer(events[i][1]);
                i++;
            }

            while (!pq.isEmpty() && pq.peek() < day) {
                pq.poll();
            }

            if (!pq.isEmpty()) {
                pq.poll();
                ans++;
            }
            day++;
        }
        return ans;
    }
}

public int eraseOverlapIntervals(int[][] intervals) {
    if (intervals == null || intervals.length == 0) return 0;
    Arrays.sort(intervals, (a, b) -> a[1] - b[1]); //1.每个子区间尾排序
    int count = 1;
    int end = intervals[0][1]; 

    for (int i = 1; i < intervals.length; i++) {
        if (intervals[i][0] < end) continue;    //2.与之前区间重叠(即当前区间的头小于之前区间的尾，删除)
        end = intervals[i][1];
        count++;
    }
    return intervals.length - count;    //3.要删除的区间数量
}

public int[][] merge(int[][] intervals) {
        //1.按照每个子区间端点（左端点）进行排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        int[][] ret = new int[intervals.length][2];
        int idx = -1;

        for (int[] interval : intervals) {
            //3.没有重叠（数组为空/当前区间左边界大于结果区间右边界），直接加入
            if (idx == -1 || interval[0] > ret[idx][1]) { 
                ret[++idx] = interval;
            } else {
                //4.有重叠，合并区间(更新结果区间右边界)
                ret[idx][1] = Math.max(interval[1], ret[idx][1]);  
            }
        }
        //ps：copyOf(int[] original, int newLength) 
        return Arrays.copyOf(ret, idx + 1);
    }

public int[][] insert(int[][] intervals, int[] newInterval) {
    int[][] ret = new int[intervals.length + 1][2];
    int idx = 0, i = 0;
    //1.左边不重叠区间
    while (i < intervals.length && newInterval[0] > intervals[i][1]) {
        ret[idx++] = intervals[i++];
    }
    //2.区间合并(更新新区间的左右边界)
    while (i < intervals.length && newInterval[1] >= intervals[i][0]) {
        newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
        newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
        i++;
    }
    ret[idx++] = newInterval;
    //3.右边不重叠区间
    while (i < intervals.length) {
        ret[idx++] = intervals[i++];
    }
    return Arrays.copyOf(ret, idx);
}

BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
System.out.println("=====================");
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);

a values is:0.1000000000000000055511151231257827021181583404541015625
=====================
b values is:0.1

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用 
NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用 
percent.setMaximumFractionDigits(3); //百分比小数点最多3位 

BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
BigDecimal interestRate = new BigDecimal("0.008"); //利率   
BigDecimal interest = loanAmount.multiply(interestRate); //相乘

System.out.println("贷款金额:\t" + currency.format(loanAmount)); 
System.out.println("利率:\t" + percent.format(interestRate)); 
System.out.println("利息:\t" + currency.format(interest)); 

贷款金额: ￥15,000.48 利率: 0.8% 利息: ￥120.00

public class NumberFormat {
	public static void main(String[] s){
		System.out.println(formatToNumber(new BigDecimal("3.435")));
		System.out.println(formatToNumber(new BigDecimal(0)));
		System.out.println(formatToNumber(new BigDecimal("0.00")));
		System.out.println(formatToNumber(new BigDecimal("0.001")));
		System.out.println(formatToNumber(new BigDecimal("0.006")));
		System.out.println(formatToNumber(new BigDecimal("0.206")));
    }
	/**
	 * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
	 * 2.传入的参数等于0，则直接返回字符串"0.00"
	 * 3.大于1的小数，直接格式化返回字符串
	 * @param obj传入的小数
	 * @return
	 */
	public static String formatToNumber(BigDecimal obj) {
		DecimalFormat df = new DecimalFormat("#.00");
		if(obj.compareTo(BigDecimal.ZERO)==0) {
			return "0.00";
		}else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
			return "0"+df.format(obj).toString();
		}else {
			return df.format(obj).toString();
		}
	}
}

3.44
0.00
0.00
0.00
0.01
0.21

java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

package com.vivo.ars.util;
import java.math.BigDecimal;

/**
 * 用于高精确处理常用的数学运算
 */
public class ArithmeticUtils {
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */

    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1    被加数
     * @param v2    加数
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1    被减数
     * @param v2    减数
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */

    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param v1 被比较数
     * @param v2 比较数
     * @return 如果v1 大于v2 则 返回true 否则false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }
}

public List<FeedItemVo> getFeeds(Query query,Page page){
    List<String> orgiList = new ArrayList<>();

    List<FeedItemVo> collect = page.getRecords().stream()
    .filter(this::addDetail)
    .map(FeedItemVo::convertVo)
    .filter(vo -> this.addOrgNames(query.getIsSlow(),orgiList,vo))
    .collect(Collectors.toList());
    //...其他逻辑
    return collect;
}

private boolean addDetail(FeedItem feed){
    vo.setItemCardConf(service.getById(feed.getId()));
    return true;
}

private boolean addOrgNames(boolean isSlow,List<String> orgiList,FeedItemVo vo){
    if(isShow && vo.getOrgIds() != null){
        orgiList.add(vo.getOrgiName());
    }
    return true;
}

if (!CollectionUtils.isEmpty(roleNameStrList) && roleNameStrList.contains(REGULATORY_ROLE)) {
    vos = vos.stream().filter(
           vo -> !CollectionUtils.isEmpty(vo.getSpecialTaskItemVoList())
                    && vo.getTaskName() != null)
           .collect(Collectors.toList());
} else {
    vos = vos.stream().filter(vo -> vo.getIsSelect()
           && vo.getTaskName() != null)
           .collect(Collectors.toList());
    vos = vos.stream().filter(
            vo -> !CollectionUtils.isEmpty(vo.getSpecialTaskItemVoList())
                    && vo.getTaskName() != null)
           .collect(Collectors.toList());
}
result.addAll(vos.stream().collect(Collectors.toList()));

Stream.of("i", "am", "xjjdog").map(toUpperCase()).map(toBase64()).collect(joining(" "));

Stream.of("i", "am", "xjjdog")
    .map(toUpperCase())
    .map(toBase64())
    .collect(joining(" "));

public Stream<OrderDto> getOrderByUser(String userId){
    return orderRepo.findOrderByUser().stream()
        .map(order-> {
            OrderDto dto = new OrderDto();
            dto.setOrderId(order.getOrderId());
            dto.setTitle(order.getTitle().split("#")[0]);
            dto.setCreateDate(order.getCreateDate().getTime());
            return dto;
    });
}

public Stream<OrderDto> getOrderByUser(String userId){
    return orderRepo.findOrderByUser().stream()
        .map(this::toOrderDto);
}
public OrderDto toOrderDto(Order order){
    OrderDto dto = new OrderDto();
            dto.setOrderId(order.getOrderId());
            dto.setTitle(order.getTitle().split("#")[0]);
            dto.setCreateDate(order.getCreateDate().getTime());
    return dto;
}

public Stream<OrderDto> getOrderByUser(String userId){
    return orderRepo.findOrderByUser().stream()
        .map(OrderDto::new);
}

Predicate<Registar> registarIsCorrect = reg -> 
    reg.getRegulationId() != null 
    && reg.getRegulationId() != 0 
    && reg.getType() == 0;

if(null == obj)
if(null == user.getName() || "".equals(user.getName()))

if (order != null) {
    Logistics logistics = order.getLogistics();
    if(logistics != null){
        Address address = logistics.getAddress();
        if (address != null) {
            Country country = address.getCountry();
            if (country != null) {
                Isocode isocode = country.getIsocode();
                if (isocode != null) {
                    return isocode.getNumber();
                }
            }
        }
    }
}

public Optional<String> getUserName() {
    return Optional.ofNullable(userName);
}

/**
    * 按GBK编码写入文件，固定长度
    * 补空格(有判断不全的情况)
    *
    * @param length 总长度
    * @param str    要补位的字符串
    * @return 补全位数的字符串
    */
public static String jointSpaceOld(int length, String str) {
    if (str.length() < length) {
        int chinaNum = 0;
        // 中文一个字符占两位
        if (!StringUtils.isEmpty(str)) {
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                try {
                    if (Character.toString(c).getBytes(GBK).length == 2) {
                        chinaNum++;
                    }
                } catch (UnsupportedEncodingException e) {
                    if (isAllChineseByBlock(c) || isLatin1Supplement(c)) {
                        chinaNum++;
                    }
                }
            }
        }
        int total = length - str.length() - chinaNum;
        str = str + " ".repeat(Math.max(0, total));
    }
    return str;
}

/**
    * 按GBK编码写入文件，固定长度
    * 补空格(有判断不全的情况)
    *
    * @param length 总长度
    * @param str    要补位的字符串
    * @return 补全位数的字符串
    */
public static String jointSpace(int length, String str) {
    StringBuilder sb = new StringBuilder(StringUtils.defaultString(str));
    try {
        while (sb.toString().getBytes(GBK).length > length) {
            int sbLen = sb.length();
            sb.delete(sbLen - 1, sbLen);
        }
        while (sb.toString().getBytes(GBK).length < length) {
            sb.append(" ");
        }
    } catch (UnsupportedEncodingException e) {
        sb = new StringBuilder();
        sb.append(" ".repeat(Math.max(0, length)));
    }
    return sb.toString();
}

public static boolean isAllChineseByBlock(char c) {
    return isChineseByBlock(c) || isChinesePunctuation(c);
}

/**
    * 使用UnicodeBlock方法判断
    * 是否为中文字符
    *
    * @param c 字符
    * @return 是否
    */
public static boolean isChineseByBlock(char c) {
    Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
    return ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
            || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
            || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
            || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C
            || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D
            || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
            || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT;
}

/**
    * 使用UnicodeScript方法判断
    * 是否为中文
    *
    * @param c 字符
    * @return 是否
    */
public static boolean isChineseByScript(char c) {
    Character.UnicodeScript sc = Character.UnicodeScript.of(c);
    return sc == Character.UnicodeScript.HAN;
}


/**
    * 根据UnicodeBlock方法判断中文标点符号
    *
    * @param c 字符
    * @return 是否
    */
public static boolean isChinesePunctuation(char c) {
    Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
    return ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
            || ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
            || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
            || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS
            || ub == Character.UnicodeBlock.VERTICAL_FORMS;
}


/**
    * 根据UnicodeBlock方法是否拉丁1-增补
    *
    * @param c 字符
    * @return 是否
    */
public static boolean isLatin1Supplement(char c) {
    Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
    return ub == Character.UnicodeBlock.LATIN_1_SUPPLEMENT;
}


/**
    * 根据UnicodeBlock方法是否基本拉丁语
    *
    * @param c 字符
    * @return 是否
    */
public static boolean isBasic(char c) {
    Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
    return ub == Character.UnicodeBlock.BASIC_LATIN;
}

@Test
void gbk() throws UnsupportedEncodingException {
    // 错误=张·三     end
    // 正确=张·三    end
    // 固定长度10
    String spaceStr = "张·三";
    log.debug(GbkUtils.jointSpace(10, spaceStr));
    String str = "减法10−2=8,下划线1_2,中横线1-2,少数民族名张·三,中文符号，。；,全角１２３,繁體張三";
    StringBuilder newStr = new StringBuilder();
    for (int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);
        log.debug("{},gbk_length={},block={},chinese={},latin={}", c, Character.toString(c).getBytes("GBK").length
                , Character.UnicodeBlock.of(c), GbkUtils.isAllChineseByBlock(c), GbkUtils.isLatin1Supplement(c));
        if (GbkUtils.isAllChineseByBlock(c) || GbkUtils.isLatin1Supplement(c) || GbkUtils.isBasic(c)) {
            newStr.append(c);
        } else {
            // 无法识别的字符转换为.
            newStr.append(".");
        }
    }
    // 数学符号
    assertFalse(GbkUtils.isAllChineseByBlock("−".charAt(0)));
    assertTrue(GbkUtils.isAllChineseByBlock("中".charAt(0)));
    assertTrue(GbkUtils.isAllChineseByBlock("體".charAt(0)));
    assertTrue(GbkUtils.isAllChineseByBlock("。".charAt(0)));
    assertTrue(GbkUtils.isAllChineseByBlock("１".charAt(0)));
    // 基本拉丁语
    assertTrue(GbkUtils.isBasic("a".charAt(0)));
    log.debug("\n   str={}\nGBK的乱码替换为.\nnewStr={}", str, newStr);
}

@EnableScheduling
@EnableJpaAuditing
// 这里要，或者放在配置文件上
@EnableCaching
@SpringBootApplication
public class AppServer {
}

@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
    // 配置cache 序列化为jsonSerializer
    RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
    RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jsonSerializer);
    RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
    // 设置默认过期时间
    defaultCacheConfig.entryTtl(Duration.ofDays(30));

    // 也可以通过builder来构建
    return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
}

@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    // 有地方出错说要注释掉这里，但注释掉这里别的又出错
    om.activateDefaultTyping(
            om.getPolymorphicTypeValidator(),
            ObjectMapper.DefaultTyping.NON_FINAL,
            JsonTypeInfo.As.PROPERTY);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    // 配置序列化
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofDays(30))
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
            .disableCachingNullValues();
    return RedisCacheManager.builder(factory).cacheDefaults(config).build();
}