package com.vincent.rsf.common.utils;
|
|
import com.vincent.rsf.framework.common.Cools;
|
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Optional;
|
import java.util.function.BiConsumer;
|
import java.util.function.Function;
|
import java.util.Map;
|
|
/**
|
* Created by vincent on 2023/3/14
|
*/
|
public class Utils {
|
|
/**
|
* List转为树形结构
|
*
|
* @param data List
|
* @param parentId 顶级的parentId
|
* @param parentIdMapper 获取parentId的Function
|
* @param idMapper 获取id的Function
|
* @param consumer 赋值children的Consumer
|
* @param <T> 数据的类型
|
* @param <R> parentId的类型
|
* @return List<T>
|
*/
|
public static <T, R> List<T> toTreeData(List<T> data,
|
R parentId,
|
Function<? super T, ? extends R> parentIdMapper,
|
Function<? super T, ? extends R> idMapper,
|
BiConsumer<T, List<T>> consumer) {
|
List<T> result = new ArrayList<>();
|
for (T d : data) {
|
R dParentId = parentIdMapper.apply(d);
|
if (parentId.equals(dParentId)) {
|
R dId = idMapper.apply(d);
|
List<T> children = toTreeData(data, dId, parentIdMapper, idMapper, consumer);
|
if(!children.isEmpty()) {
|
consumer.accept(d, children);
|
}
|
result.add(d);
|
}
|
}
|
return result;
|
}
|
|
public static <T> void treeRemove(List<T> list, String condition, Function<? super T, ? extends String> fetcher, Function<T, List<T>> childrenGetter) {
|
Iterator<T> iterator = list.iterator();
|
while (iterator.hasNext()) {
|
T next = iterator.next();
|
List<T> children = childrenGetter.apply(next);
|
if (children != null && !children.isEmpty()) {
|
treeRemove(children, condition, fetcher, childrenGetter);
|
} else {
|
if (!fetcher.apply(next).contains(condition)) {
|
iterator.remove();
|
}
|
}
|
}
|
}
|
|
/**
|
* 数组倒序
|
*/
|
public static <T> byte[] reverse(byte[] bytes) {
|
if (bytes == null) return null;
|
for (int start = 0, end = bytes.length - 1; start < end; start++, end--) {
|
byte temp = bytes[end];
|
bytes[end] = bytes[start];
|
bytes[start] = temp;
|
}
|
return bytes;
|
}
|
|
/**
|
* 截取数组
|
* @param bytes 原数组
|
* @param pos 定位（截取后包含定位点数据）
|
* @param len 长度
|
* @return new arr
|
*/
|
public static byte[] slice(byte[] bytes, int pos, int len) {
|
if (bytes == null || bytes.length == 0 || len == 0) {
|
return new byte[0];
|
}
|
if (pos + len > bytes.length) {
|
throw new RuntimeException("com.vincent.rsf.common.utils ArrayIndexOutOfBoundsException\n" +
|
"原数组 bytes 长度为 " + bytes.length + "，截取长度超过原数组！");
|
}
|
byte[] arr = new byte[len];
|
System.arraycopy(bytes, pos, arr, 0, len);
|
return arr;
|
}
|
|
public static byte[] sliceWithReverse(byte[] bytes, int pos, int len) {
|
byte[] slice = slice(bytes, pos, len);
|
reverse(slice);
|
return slice;
|
}
|
|
public static byte[] merge(Object... objects) {
|
int len = 0;
|
for (Object object : objects) {
|
if (object instanceof byte[]) {
|
byte[] bytes = (byte[]) object;
|
len += bytes.length;
|
}
|
if (object instanceof Byte) {
|
len++;
|
}
|
}
|
byte[] arr = new byte[len];
|
int idx = 0;
|
for (Object object : objects) {
|
if (object instanceof byte[]) {
|
byte[] bytes = (byte[]) object;
|
System.arraycopy(bytes, 0, arr, idx, bytes.length);
|
idx += bytes.length;
|
}
|
if (object instanceof Byte) {
|
byte[] bytes = new byte[] {(Byte) object};
|
System.arraycopy(bytes, 0, arr, idx, bytes.length);
|
idx += bytes.length;
|
}
|
}
|
return arr;
|
}
|
|
public static <T> String join(T[] array, String seq) {
|
StringBuilder sb = new StringBuilder();
|
if (array != null) {
|
for (int i = 0; i < array.length; i++) {
|
sb.append(array[i]);
|
if (i < array.length - 1) {
|
sb.append(seq);
|
}
|
}
|
}
|
return sb.toString();
|
}
|
|
public static String zeroFill(String msg, Integer len) {
|
len = Optional.ofNullable(len).orElse(16);
|
if (msg.length() == len){
|
return msg;
|
} else if (msg.length() > len){
|
return msg.substring(0, 16);
|
} else {
|
StringBuilder msgBuilder = new StringBuilder(msg);
|
for (int i = 0; i<len-msg.length(); i++){
|
msgBuilder.insert(0,"0");
|
}
|
return msgBuilder.toString();
|
}
|
}
|
|
public static String removePrefix(String str, String prefix) {
|
if (!Cools.isEmpty(str) && !Cools.isEmpty(prefix)) {
|
if (str.startsWith(prefix)) {
|
return str.substring(prefix.length());
|
} else {
|
return str;
|
}
|
} else {
|
return str;
|
}
|
}
|
|
public static String removeSuffix(String str, String suffix) {
|
if (!Cools.isEmpty(str) && !Cools.isEmpty(suffix)) {
|
if (str.endsWith(suffix)) {
|
return str.substring(0, str.indexOf(suffix));
|
} else {
|
return str;
|
}
|
} else {
|
return str;
|
}
|
}
|
|
public static String toSymbolCase(String str, char symbol) {
|
if (str == null) {
|
return null;
|
} else {
|
int length = str.length();
|
StringBuilder sb = new StringBuilder();
|
|
for(int i = 0; i < length; ++i) {
|
char c = str.charAt(i);
|
if (Character.isUpperCase(c)) {
|
Character preChar = i > 0 ? str.charAt(i - 1) : null;
|
Character nextChar = i < str.length() - 1 ? str.charAt(i + 1) : null;
|
if (null != preChar) {
|
if (symbol == preChar) {
|
if (null == nextChar || Character.isLowerCase(nextChar)) {
|
c = Character.toLowerCase(c);
|
}
|
} else if (Character.isLowerCase(preChar)) {
|
sb.append(symbol);
|
if (null == nextChar || Character.isLowerCase(nextChar)) {
|
c = Character.toLowerCase(c);
|
}
|
} else if (null == nextChar || Character.isLowerCase(nextChar)) {
|
sb.append(symbol);
|
c = Character.toLowerCase(c);
|
}
|
} else if (null == nextChar || Character.isLowerCase(nextChar)) {
|
c = Character.toLowerCase(c);
|
}
|
}
|
|
sb.append(c);
|
}
|
|
return sb.toString();
|
}
|
}
|
|
public static String toCamelCase(CharSequence name) {
|
if (null == name) {
|
return null;
|
} else {
|
String name2 = name.toString();
|
if (name2.contains("_")) {
|
int length = name2.length();
|
StringBuilder sb = new StringBuilder(length);
|
boolean upperCase = false;
|
|
for(int i = 0; i < length; ++i) {
|
char c = name2.charAt(i);
|
if (c == '_') {
|
upperCase = true;
|
} else if (upperCase) {
|
sb.append(Character.toUpperCase(c));
|
upperCase = false;
|
} else {
|
sb.append(Character.toLowerCase(c));
|
}
|
}
|
|
return sb.toString();
|
} else {
|
return name2;
|
}
|
}
|
}
|
|
public static String sub(String str, Integer maxLen) {
|
if (str.length() > maxLen) {
|
return str.substring(0, maxLen);
|
}
|
return str;
|
}
|
|
public static String generateSeqNum(String lastSeqNum) {
|
if (Cools.isEmpty(lastSeqNum)) {
|
return zeroFill("1", 4);
|
} else {
|
int i = Integer.parseInt(lastSeqNum);
|
if (i >= 9999) {
|
return zeroFill("1", 4);
|
} else {
|
return zeroFill(String.valueOf(i+1), 4);
|
}
|
}
|
}
|
|
// pos start in 0
|
public static boolean getBit(byte b, int position) {
|
if (position < 0 || position > 7) {
|
throw new IllegalArgumentException("Bit position must be between 0 and 7");
|
}
|
int mask = 1 << position;
|
return (b & mask) != 0;
|
}
|
|
public static <T> List<T> singletonList(T o) {
|
List<T> list = new ArrayList<>();
|
list.add(o);
|
return list;
|
}
|
|
public static String convertToSnakeCaseForOrderByStr(String input) {
|
String[] parts = input.split("\\s+");
|
String fieldName = parts[0];
|
String order = parts.length > 1 ? parts[1] : "";
|
|
String snakeCaseField = fieldName.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
|
|
return snakeCaseField + (order.isEmpty() ? "" : " " + order);
|
}
|
|
public static String processTemplate(String template, Map<String, Object> params) {
|
if (template == null || params == null) {
|
return template;
|
}
|
String processed = template;
|
for (Map.Entry<String, Object> entry : params.entrySet()) {
|
processed = processed.replace("${" + entry.getKey() + "}", entry.getValue().toString());
|
}
|
return processed;
|
}
|
|
}
|
