字符串处理
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.IntStream;
public class MyStringUtils {
public static void main(String[]args){
}
/** 将一个字符串重复N次 str: 源字符串 repeat: 重复的次数 */
public static String repeat(String str, int repeat) {
if (str == null) {
return null;
}
if (repeat <= 0) {
return null;
}
int inputLength = str.length();
if (repeat == 1 || inputLength == 0) {
return str;
}
if (inputLength == 1 && repeat <= 8192) {
return repeat(str.charAt(0), repeat);
}
int outputLength = inputLength * repeat;
switch (inputLength) {
case 1:
return repeat(str.charAt(0), repeat);
case 2:
char ch0 = str.charAt(0);
char ch1 = str.charAt(1);
char[] output2 = new char[outputLength];
for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
output2[i] = ch0;
output2[i + 1] = ch1;
}
return new String(output2);
default:
StringBuilder buf = new StringBuilder(outputLength);
for (int i = 0; i < repeat; i++) {
buf.append(str);
}
return buf.toString();
}
}
/** 将一个字符串重复N次，并且中间加上指定的分隔符 */
public static String repeat(String str, String separator, int repeat) {
if (str == null || separator == null) {
return repeat(str, repeat);
} else {
// given that repeat(String, int) is quite optimized, better to rely
// on it than try and splice this into it
String result = repeat(str + separator, repeat);
return removeEnd(result,separator);
}
}
/** 将某个字符重复N次. */
public static String repeat(char ch, int repeat) {
char[] buf = new char[repeat];
for (int i = repeat - 1; i >= 0; i--) {
buf[i] = ch;
}
return new String(buf);
}
/** 字符串长度达不到指定长度时，在字符串右边补指定的字符 str:源字符串 size:指定的长度 padChar:进行补充的字符 */
public static String rightPad(String str, int size, char padChar) {
if (str == null) {
return null;
}
int pads = size - str.length();
if (pads <= 0) {
return str; // returns original String when possible
}
if (pads > 8192) {
return rightPad(str,size, String.valueOf(padChar));
}
return str.concat(repeat(padChar,pads));
}
/** 扩大字符串长度，从左边补充指定字符 str:源字符串 size:扩大后的长度 padStr:在右边补充的字符串 */
public static String rightPad(String str, int size, String padStr) {
if (str == null) {
return null;
}
if (isEmpty(padStr)) {
padStr = " ";
}
int padLen = padStr.length();
int strLen = str.length();
int pads = size - strLen;
if (pads <= 0) {
return str; // returns original String when possible
}
if (padLen == 1 && pads <= 8192) {
return rightPad(str, size, padStr.charAt(0));
}
if (pads == padLen) {
return str.concat(padStr);
} else if (pads < padLen) {
return str.concat(padStr.substring(0, pads));
} else {
char[] padding = new char[pads];
char[] padChars = padStr.toCharArray();
for (int i = 0; i < pads; i++) {
padding[i] = padChars[i % padLen];
}
return str.concat(new String(padding));
}
}
/** 从右边截取字符串 str:源字符串 len:长度 */
public static String right(String str, int len) {
if (str == null) {
return null;
}
if (len < 0) {
return null;
}
if (str.length() <= len) {
return str;
}
return str.substring(str.length() - len);
}
/** 从源字符串中移除指定结尾的子字符串 */
public static String removeEnd(String str, String remove) {
if (isEmpty(str) || isEmpty(remove)) {
return str;
}
if (str.endsWith(remove)) {
return str.substring(0,str.length() - remove.length());
}
return str;
}
/** 反转字符串 */
public static String reverse(String str) {
if (str == null) {
return null;
}
return new StringBuilder(str).reverse().toString();
}
/** 检查字符串是否全部为小写 */
public static boolean isAllLowerCase(String cs) {
if (cs == null || isEmpty(cs)) {
return false;
}
int sz = cs.length();
for (int i = 0; i < sz; i++) {
if (Character.isLowerCase(cs.charAt(i)) == false) {
return false;
}
}
return true;
}
/** 检查字符串是否都是大写 */
public static boolean isAllUpperCase(String cs) {
if (cs == null || MyStringUtils.isEmpty(cs)) {
return false;
}
int sz = cs.length();
for (int i = 0; i < sz; i++) {
if (Character.isUpperCase(cs.charAt(i)) == false) {
return false;
}
}
return true;
}
/** 判断字符串是否纯数字 */
public static boolean isDigital(String str){
if (!isEmpty(str))
return str.matches("[0-9]+");
return false;
}
/** 字符串数组转换List<String> */
public static List<String> stringsToList(String[] items) {
List<String> lists = new ArrayList<>();
for(int i=0; i<items.length; i++){
lists.add(items[i]);
}
return lists;
}
/** 去掉字符串中的空格、回车、换行符、制表符 */
public static String replaceBlank(String str) {
String dest = "";
if (str != null) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n|");
Matcher m = p.matcher(str);
dest = m.replaceAll("");
// 将ASCII的值为160的替换为空字符串
dest = dest.replace(backStr(160), "");
}
return dest;
}
/** 去掉字符串中的空格、回车、换行符、制表符、斜杠、点、冒号 */
public static String replaceBlanks(String str) {
str = replaceBlank(str);
String dest = "";
if (str != null) {
Pattern p = Pattern.compile("/|\\.|\\:|");
Matcher m = p.matcher(str);
dest = m.replaceAll("");
}
return dest;
}
/** 删除字符串左侧所有字符ch */
public static String deleteLeftChar(String data, char ch){
int flag = 0;
for(int i = 0;i<data.length();i++){
if(data.charAt(i) == ch){
flag = i;
}else{
break;
}
}
flag = flag+1;
data = data.substring(flag);
return data;
}
/** 删除字符串右侧所有字符ch*/
public static String deleteRightChar(String data, char ch){
int flag = data.length();
for(int i = data.length()-1;i>=0;i--){
if(data.charAt(i) == ch){
flag = i;
}else{
break;
}
}
data = data.substring(0,flag);
return data;
}
/** 根据某个字符对字符串进行分割 */
public static String[] spiltStr(String str,String reg) {
str = replaceBlank(str);
String[] spilt = str.split(reg);
return spilt;
}
/** 按照前后标识拆分字符串 allStr:要拆分字符串 startStr:前标识 endStr:后标识 */
public static String cutString(String allStr,String startLog,String endLog){
allStr = allStr.substring(allStr.indexOf(startLog),allStr.indexOf(endLog));
allStr = allStr.substring(startLog.length(),allStr.length());
return allStr;
}
/** 拼串 */
public static String mergeStr(String...strings) {
StringBuilder sb = new StringBuilder();
for (String str : strings) {
sb.append(str);
}
return sb.toString();
}
/** ASC 转字符串 */
public static String backStr(int backnum) {
char strChar = (char) backnum;
return String.valueOf(strChar);
}
/** 判断字符串是否为空 */
public static boolean isEmpty(String str) {
if (str == null||str.isEmpty()||str.length()==0||"null".equals(str)||"NULL".equals(str)) {
return true;
}else {
return false;
}
}
/** 验证邮箱格式 */
public static boolean isEmail(String email) {
if (email == null) {
return false;
}
return Pattern.matches("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$",email);
}
/** 验证手机格式 */
public static boolean isPhone(String phoneNum) {
if (phoneNum == null) {
return false;
}
//验证规则，手机号第一位为1，后面十位为数字
return Pattern.matches("^1(\\d{10})$", phoneNum);
}
/** 验证身份证号 */
public static boolean isIdentity(String identity) {
final int[] COEFFICIENT_ARRAY = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
// 身份证号的尾数规则
final String[] IDENTITY_MANTISSA = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
final String IDENTITY_PATTERN = "^[0-9]{17}[0-9Xx]$";
if (identity == null) {
return false;
}
if (identity.length() != 18) {
return false;
}
if (!identity.matches(IDENTITY_PATTERN)) {
return false;
}
char[] chars = identity.toCharArray();
long sum = IntStream.range(0, 17).map(index -> {
char ch = chars[index];
int digit = Character.digit(ch, 10);
int coefficient = COEFFICIENT_ARRAY[index];
return digit * coefficient;
}).summaryStatistics().getSum();
// 计算出的尾数索引
int mantissaIndex = (int) (sum % 11);
String mantissa = IDENTITY_MANTISSA[mantissaIndex];
String lastChar = identity.substring(17);
if (lastChar.equalsIgnoreCase(mantissa)) {
return true;
} else {
return false;
}
}
}
日期时间处理
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
public class MyDataTimeUtils {
// Java8 处理时间
public static void useJava8DateTime(){
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 获取当前日期
LocalDate date = LocalDate.now();
System.out.println("当前日期: " + date);
// 获取当前时间
LocalTime time = LocalTime.now();
System.out.println("当前时间: " + time);
// 上海时间
ZoneId shanghaiZoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime shanghaiZonedDateTime = ZonedDateTime.now(shanghaiZoneId);
// 东京时间
ZoneId tokyoZoneId = ZoneId.of("Asia/Tokyo");
ZonedDateTime tokyoZonedDateTime = ZonedDateTime.now(tokyoZoneId);
System.out.println("上海时间: " + shanghaiZonedDateTime.format(formatter));
System.out.println("东京时间: " + tokyoZonedDateTime.format(formatter));
// 解析日期
String dateText = "20180924";
LocalDate parsDate = LocalDate.parse(dateText,DateTimeFormatter.BASIC_ISO_DATE);
System.out.println("格式化之后的日期: " + parsDate);
// 格式化日期
dateText = date.format(DateTimeFormatter.ISO_DATE);
System.out.println("dateText: " + dateText);
// 日期时间转字符串
LocalDateTime now = LocalDateTime.now();
String nowStr = now.format(formatter);
System.out.println("日期转字符串: " + nowStr);
// 字符串转日期时间
String datetimeText = "1999-12-31 23:59:59";
LocalDateTime datetime = LocalDateTime.parse(datetimeText,formatter);
System.out.println("字符串转日期: "+datetime);
// 日期增量
LocalDate nowDate = LocalDate.now();
LocalDate aftetWeek = nowDate.plus(1, ChronoUnit.WEEKS);
LocalDate aftetMonth = nowDate.plus(1,ChronoUnit.MONTHS);
System.out.println("一周后: " + aftetWeek);
System.out.println("一月后: " + aftetMonth);
// 时间增量
LocalTime nowTime = LocalTime.now();
LocalTime afterHours = nowTime.plusHours(1);
LocalTime afterSeconds = nowTime.plusSeconds(1);
LocalTime afterNanos = nowTime.plusNanos(1000);
System.out.println("一小时后: " + afterHours);
System.out.println("一分后: " + afterSeconds);
System.out.println("一千纳秒后: " + afterNanos);
// 时间比较
LocalDate nowPare = LocalDate.now();
LocalDate date001 = LocalDate.of(2000, 12, 31);
if (nowPare.isAfter(date001)) {
System.out.println("2019年已经过去了");
}
LocalDate date002 = LocalDate.of(2021, 1, 1);
if (nowPare.isBefore(date002)) {
System.out.println("2021年还未到来");
}
LocalDate nowEquals = LocalDate.now();
LocalDate setDate = LocalDate.of(2020, 5, 1);
System.out.println("日期是否相等: " + nowEquals.equals(setDate));
}
}
List处理
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class MyListUtils {
public static void main(String[]args){
}
/** 单个List集合去除重复 */
public static List<Object> removeRepeat(List<Object> list) {
Set<Object> set = new HashSet<>(list);
return new ArrayList<>(set);
}
/** 比较一个list集合里是否有重复*/
public static boolean isRepeat(List<Object> list) {
Set<Object> set = new HashSet<>(list);
return set.size() != list.size();
}
/** 比较两个集合是否有重复 */
public static boolean isRepeat(List<Object> list1, List<Object> list2){
Set<Object> set001 = new HashSet<>(list1);
Set<Object> set002 = new HashSet<>(list2);
Set<Object> setAll = new HashSet<>(set001);
setAll.addAll(set002);
int setSize = set001.size() + set002.size();
return setAll.size() != setSize;
}
/** 比较两个集合是否有重复(有相同移除第一个集合中的相同值) */
public static List<Object> removeRepeat(List<Object> list001,List<Object> list002) {
list001.removeAll(list002);
return list001;
}
/** 求两个集合的交集 */
//用hash这种很有用的数据结构来实现。 把第一个集合的所有元素都放进hashSet中，时间复杂度O(M)。
// 再把第二个集合中的元素放进hashSet中，如果有重复元素，就是这2个集合的交集，时间复杂度为O(N)。即总的时间复杂度从O(M*N)降低到了O(M+N)。
public static List<String> getIntersection(List<String> list001, List<String> list002) {
List<String> commonList = new ArrayList<>();
Set<Object> hashSet = new HashSet<>();
Collections.addAll(hashSet,list001);
for (String item : list002) {
if (!hashSet.add(item)) {
commonList.add(item);
}
}
return commonList;
}
/** 求两个集合的并集 */
public static List<Object> unionAll(List<Object> list1, List<Object> list2) {
list1.removeAll(list2);
list1.addAll(list2);
return list1;
}
/** 拆分list */
public static <T> List<List<T>> averageAssign( List<T> source, int splitItemNum ){
List<List<T>> result = new ArrayList<List<T>>();
if ( source != null && source.size() > 0 && splitItemNum > 0 ){
if ( source.size() <= splitItemNum ){
// 源List元素数量小于等于目标分组数量
result.add( source );
}else{
// 计算拆分后list数量
int splitNum = (source.size() % splitItemNum == 0 ) ? ( source.size() / splitItemNum ) : (source.size() / splitItemNum + 1);
List<T> value = null;
for ( int i = 0; i < splitNum; i++ ){
if ( i < splitNum - 1 ){
value = source.subList( i * splitItemNum, ( i + 1 ) * splitItemNum );
}else{
// 最后一组
value = source.subList( i * splitItemNum, source.size() );
}
result.add( value );
}
}
}
return result;
}
}
Map处理
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class MyMapUtils {
public static void main(String[]args){
Map<String,String> maps001 = new HashMap<>();
Map<String,String> maps002 =creatManyValues("1","11","22","33","##");
Map<String,String> maps003 = creatManyValues("a","aa","bb","cc","##");
Map<String,String> maps004 = creatManyValues("b","yy","jj","kk","##");
Map<String,String> maps005 = creatManyValues("c","vv","bb","hh","##");
maps001.putAll(maps002);
maps001.putAll(maps003);
maps001.putAll(maps004);
maps001.putAll(maps005);
for(Map.Entry<String,String> map :maps001.entrySet()){
String key = map.getKey();
String value = map.getValue();
String[] spilt = value.split("##");
System.out.println("key: "+key+" value: "+value);
for (String str : spilt){
System.out.print("str: "+str+" ");
}
System.out.println("");
System.out.println("************");
}
}
/** 创建 一键对应多值(拼接) */
public static Map creatManyValues(String key,String value01,String value02,String value03,String logo){
Map<String,String> maps = new HashMap<>();
String value = value01+logo+value02+logo+value03;
maps.put(key,value);
return maps;
}
/** 获取Map中key集合 */
public static List<Object> getMapKey(Map<Object,Object> maps){
List<Object> listKey = new ArrayList();
for (Map.Entry<Object,Object> map :maps.entrySet()){
Object key = map.getKey();
listKey.add(key);
}
return listKey;
}
/** 获取Map中value集合 */
public static List<Object> getMapValue(Map<Object,Object> maps){
List<Object> listValue = new ArrayList();
for (Map.Entry<Object,Object> map :maps.entrySet()){
Object value = map.getValue();
listValue.add(value);
}
return listValue;
}
/** 将map切成若干段,每段 chunkNum 个元素 */
public static <k, v> List<Map<k, v>> mapChunk(Map<k, v> chunkMap, int chunkNum) {
if (chunkMap == null || chunkNum <= 0) {
List<Map<k, v>> list = new ArrayList<>();
list.add(chunkMap);
return list;
}
Set<k> keySet = chunkMap.keySet();
Iterator<k> iterator = keySet.iterator();
int i = 1;
List<Map<k, v>> total = new ArrayList<>();
Map<k, v> tem = new HashMap<>();
while (iterator.hasNext()) {
k next = iterator.next();
tem.put(next, chunkMap.get(next));
if (i == chunkNum) {
total.add(tem);
tem = new HashMap<>();
i = 0;
}
i++;
}
if(!CollectionUtils.isEmpty(tem)){
total.add(tem);
}
return total;
}
}
扫一扫
9122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
