前面已经写了不少关于C# 怎么使用正则,有兴趣,可以翻译成java代码。
以图片为例子:
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexUtil { public static String regexImg(String html){ if(StrKit.isBlank(html)){ return html; } Pattern pattern=Pattern.compile("<img\s+[^]*?>"); Matcher matcher=Pattern.matcher(html); while (matcher.find()) { String img=matcher.group(); String src=findAttrInHtmlTag(img, "src"); } return html; } public static String findAttrInHtmlTag(String tag,String attr){ if(tag==null||attr==null) return null; Pattern pattern=Pattern.compile("\b"+attr+"\s*=\s*(['"]?)(?<value>.*?)\1"); Matcher matcher=pattern.matcher(tag); if(matcher.find()){ return matcher.group("value"); } return null; } }
连接Json:
Record就是一个实体对象:
public static String concatJson(Record record,String[] columnNames, boolean keepEmptyColumn) { if (record == null) { return null; } StringBuilder sb = new StringBuilder(); sb.append("{"); if (columnNames == null) { columnNames = record.getColumnNames(); } for (int i = 0; i < columnNames.length; i++) { Object object = record.get(columnNames[i]); if (object == null) { if (keepEmptyColumn) { sb.append("""+ columnNames[i] +"":null,"); } } else if( object instanceof String || object instanceof Date) { sb.append("""+ columnNames[i] +"":""+ object.toString() + "","); }else if( object instanceof Integer || object instanceof Long || object instanceof Double || object instanceof BigDecimal || object instanceof Float || object instanceof Boolean) { sb.append("""+ columnNames[i] +"":" + object + ","); } } // 去掉最后的逗号 if (sb.charAt(sb.length()-1) == ',') { sb.deleteCharAt(sb.length()-1); } sb.append("}"); return sb.toString(); }
拼接普通的字段为json:(key:json名称,value:值,alreadyJsonKeys,是不是已经是json)
public static String concatJson(String[] keys , String[] values, String[] alreadyJsonKeys) { if (keys == null || values == null) { return null; } if (keys.length != values.length) { //throw new Exception("Json转化出错: keys 与 values 长度不相等 "); return "Json转化出错: keys 与 values 长度不相等"; } StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < keys.length; i++) { Object object = values[i]; if (object == null) { sb.append("""+ keys[i] +"":null,"); }else { if(alreadyJsonKeys!= null && CollectionsUtils.indexOf(alreadyJsonKeys, keys[i])>=0 ){ sb.append("""+ keys[i] +"":" + object + ","); }else { sb.append("""+ keys[i] +"":"" + object + "","); } } } // 去掉最后的逗号 if (sb.charAt(sb.length()-1) == ',') { sb.deleteCharAt(sb.length()-1); } sb.append("}"); return sb.toString(); }
把一个list拼接成json
public static <T> String concatJson(List<T> list, boolean alreadyElementJson, boolean keepEmptyColumn) { if (list == null) { return null; } StringBuilder sb = new StringBuilder(); sb.append("["); int size = list.size(); for (int i = 0; i < size; i++) { T object = list.get(i); if (object == null) { sb.append("null"); } if (object instanceof Date) { sb.append(""" + object + "","); }else if(object instanceof String) { if( alreadyElementJson) { //如果已经是json字符串,则不加引号 sb.append(object.toString() + ","); }else { sb.append(""" + object + "","); } }else if (object instanceof Boolean){ sb.append(object.toString() + ","); } else { sb.append(objectToJson(object, keepEmptyColumn) + ","); } } // 去掉最后的逗号 if (sb.charAt(sb.length()-1) == ',') { sb.deleteCharAt(sb.length()-1); } sb.append("]"); return sb.toString(); }
public static<T> String concatJson(List<T> jsonObjects, boolean keepEmptyColumn) { if (jsonObjects == null) { return null; } if (jsonObjects.size() == 0) { return null; } StringBuilder sb = new StringBuilder(); sb.append("["); int size = jsonObjects.size(); for (int i = 0; i < size; i++) { sb.append(objectToJson(jsonObjects.get(i), keepEmptyColumn) + ","); } // 去掉最后的逗号 if (sb.charAt(sb.length()-1) == ',') { sb.deleteCharAt(sb.length()-1); } sb.append("]"); return sb.toString(); } //连接每个元素都已经是JSON的List public static String concatJsonStrings(List<String> list){ if(list==null) return null; if(list.size()<=0) return "[]"; StringBuilder sb = new StringBuilder(); sb.append("["); int size = list.size(); for (int i = 0; i < size; i++) { sb.append(list.get(i) + ","); } // 去掉最后的逗号 if (sb.charAt(sb.length()-1) == ',') { sb.deleteCharAt(sb.length()-1); } sb.append("]"); return sb.toString(); }
处理集合的类:
1.通过条件筛选集合:
public static <T> void removeByCondition(List<T> list1, List<T> list2, CollectionFilter<T> filter) { for (int i = list1.size() - 1; i >= 0; i--) { T item1 = list1.get(i); for (T item2 : list2) { if (filter.same(item1, item2)) { list1.remove(i); } } } }
2.通过条件查找一个集合在另一个集合中存在的次数
public static <T> Integer findExistCountByCondition(List<T> list1, List<T> list2, CollectionFilter<T> filter) { int count = 0; for (int i = list1.size() - 1; i >= 0; i--) { T item1 = list1.get(i); for (T item2 : list2) { if (filter.same(item1, item2)) { count++; } } } return count; }
public static <T> T findExistByCondition(List<T> list1, List<T> list2, CollectionFilter<T> filter) { for (int i = list1.size() - 1; i >= 0; i--) { T item1 = list1.get(i); for (T item2 : list2) { if (filter.same(item1, item2)) { return item2; } } } return null; }
3.一个集合中根据条件合并,条件相同的只留前面的一个元素,后面的(满足条件的)元素都删除
public static <T> void uniqueByCondition(List<T> list, CollectionFilter<T> filter) { for (int i = list.size() - 1; i >= 1; i--) { T item1 = list.get(i); for (int k = i - 1; k >= 0; k--) { T item2 = list.get(k); if (filter.same(item1, item2)) { list.remove(i); break; } } } }
4.一个集合中根据过滤,得到满足条件的集合
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) { // list.stream().filter(predicate).collect(Collectors.toList()); //这是用stream方法 if (list == null) return null; if (predicate == null) return list; List<T> result = new ArrayList<>(); int size = list.size(); for (int i = 0; i < size; i++) { T item1 = list.get(i); if (predicate.test(item1)) { result.add(item1); } } return result; }
一个集合中根据过滤,得到满足条件的集合的第一个元素
public static <T> T filterFirst(List<T> list, Predicate<T> predicate) { // list.stream().filter(predicate).collect(Collectors.toList()); //这是用stream方法 if (list == null) return null; if (predicate == null) return null; List<T> result = new ArrayList<>(); int size = list.size(); for (int i = 0; i < size; i++) { T item1 = list.get(i); if (predicate.test(item1)) { result.add(item1); } } if (result != null && result.size() > 0) { return result.get(0); } return null; } public static <T> T findExsit(List<T> list, Predicate<T> predicate) { // list.stream().filter(predicate).collect(Collectors.toList()); //这是用stream方法 if (list == null) return null; if (predicate == null) return null; int size = list.size(); for (int i = 0; i < size; i++) { T item1 = list.get(i); if (predicate.test(item1)) { return item1; } } return null; } public static <T> boolean findExsit(T[] arr, Predicate<T> predicate) { // list.stream().filter(predicate).collect(Collectors.toList()); //这是用stream方法 if (arr == null) return false; if (predicate == null) return false; int size = arr.length; for (int i = 0; i < size; i++) { T item1 = arr[i]; if (predicate.test(item1)) { return true; } } return false; }
根据条件对已经排序的集合进行分组(必须排序后调用)
public static <T> List<List<T>> groupListByCategory(List<T> allBooks, CollectionFilter<T> filter) throws Exception { T oldRecord = null; List<List<T>> allCategories = new ArrayList<>(); // 所有类的集合 List<T> oneCategory = new ArrayList<>(); // 当前的一类 // 循环所有的对象,根据前后是否是同一类进行分类 for (T record : allBooks) { // 判断是否为新的一类 if (oldRecord == null || !filter.same(oldRecord, record)) { oneCategory = new ArrayList<>(); // 新的一类 oneCategory.add(record); allCategories.add(oneCategory); } else { oneCategory.add(record); } oldRecord = record; } return allCategories; }
对一个list<map>集合根据条件进行分组重新构造
public static List<Map<String, Object>> groupListByCondition(List<Map<String, Object>> list, String itemKey, String listKey, Predicate<Map<String, Object>> predicate) { List<Map<String, Object>> resultMapList = new ArrayList<>(); for (Map<String, Object> map : list) { Map<String, Object> oldMap = CollectionsUtils.findExsit(resultMapList, predicate); if (oldMap != null) { List secondCategories = (List) oldMap.get(listKey); secondCategories.add(map.get(itemKey)); } else { // 如果不存在,创建一个结果集合 Object item = map.get(itemKey); map.remove(itemKey); Map<String, Object> map2 = new LinkedHashMap<>(); map2.putAll(map); List<Object> newList = new ArrayList<>(); newList.add(item); map2.put(listKey, newList); resultMapList.add(map2); } } return resultMapList; }
通过字段对集合中的集合进行排序 排序逻辑:外层集合的排序决定于内层集合中的第一个元素的排序
public static <T> List<List<Record>> orderByFields(List<List<Record>> outerList, String... fields) throws Exception { // 对内层的每一个集合按照条件进行排序 for (List<Record> innerList : outerList) { innerList = sortByFields(innerList, fields); } // 外层集合进行排序: return sortByFields(outerList, fields); }
根据条件对未排序的集合进行分组
public static <T> List<List<T>> groupUnorderedListByCategory(List<T> allRecords, CollectionFilter<T> filter) throws Exception { List<List<T>> allCategories = new ArrayList<>(); // 循环所有的对象,根据前后是否是同一类进行分类 for (T record : allRecords) { // 查看当前记录是否在原来的某一个类别中 int idx = -1; for (int i = 0; i < allCategories.size(); i++) { if (filter.same(allCategories.get(i).get(0), record)) { idx = i; break; } } // 判断是否为新的一类 if (idx < 0) { List<T> oneCategory = new ArrayList<>(); // 新的一类 oneCategory.add(record); allCategories.add(oneCategory); } else { allCategories.get(idx).add(record);书 } } return allCategories; }
public static <T> List<T> sort(List<T> allRecords, Comparator<T> comparator) throws Exception { if (allRecords == null) return null; allRecords.sort(comparator); return allRecords; } public static <T> T[] sort(T[] allRecords, Comparator<T> comparator) throws Exception { if (allRecords == null) return null; Arrays.sort(allRecords, comparator); return allRecords; }
public static <T> List<T> sortByFields(List<T> allRecords, String... fieldsAndAscDesc) throws Exception { if (allRecords == null) return null; if (fieldsAndAscDesc == null || fieldsAndAscDesc.length == 0) { return allRecords; // 如果不给字段参数,则不排序 } // 由于下面要从fields当中分离出(asc,desc),所以复制一份,而不要改变原参数 String[] fields = Arrays.copyOf(fieldsAndAscDesc, fieldsAndAscDesc.length); // 从fields当中取到升降要求(asc,desc) int[] ascOrDesc = new int[fields.length]; // 每个字段的升降性,1表示升,-1表示降 for (int i = 0; i < fields.length; i++) { String field = fields[i]; String[] words = field.trim().split("\s"); if (words.length <= 1) { ascOrDesc[i] = 1; // 默认为升 } else { fields[i] = words[0]; // 剥离了asc/desc的真正字段名 if (words[1].equalsIgnoreCase("asc")) { ascOrDesc[i] = 1; } else if (words[1].equalsIgnoreCase("desc")) { ascOrDesc[i] = -1; } else { throw new Exception("asc/desc写法有误"); } } } allRecords.sort((T r1, T r2) -> { if (r1 == null && r2 == null) return 0; if (r1 == null && r2 != null) return -1; if (r1 != null && r2 == null) return 1; for (int i = 0; i < fields.length; i++) { String field = fields[i]; int ascFlg = ascOrDesc[i]; Object value1 = null; Object value2 = null; // 集合排序逻辑:外层集合的排序决定于内层集合中的第一个元素的排序 if (r1 instanceof List && r2 instanceof List) { value1 = ((List<Record>) r1).get(0).get(field); value2 = ((List<Record>) r2).get(0).get(field); } else if (r1 instanceof Record && r2 instanceof Record) { value1 = ((Record) r1).get(field); value2 = ((Record) r2).get(field); } if (value1 == null && value2 == null) continue; // 如果这个字段相等,则要循环看下一个字段 if (value1 == null && value2 != null) return -1 * ascFlg; if (value1 != null && value2 == null) return 1 * ascFlg; if (value1 instanceof Comparable) { // if(! (value2 instanceof Comparable))throw new // Exception("value2字段类型与value1不一样"); int result = ((Comparable) value1).compareTo(value2) * ascFlg; if (result != 0) return result; // 该字段能做出大小的判断。如果这个字段相等,则要循环看下一个字段 } else { // throw new Exception("字段类型不能用于比较"); //TODO 这个异常暂不处理 } } return 0; }); return allRecords; }
join两个集合
public static void join(List<Record> targetList, String[] targetFields, List<Record> fromList, String[] fromFields, String targetJoinField, String fromJoinField) throws Exception { if (targetList == null || fromList == null) { return; } if (targetFields == null || fromFields == null) { return; } if (targetFields.length != fromFields.length) { throw new Exception(" 长度不相等 "); } for (Record targetRecord : targetList) { Object joinValue = targetRecord.get(targetJoinField);// 关联的值 Record fromRecord = CollectionsUtils.filterFirst(fromList, record -> { return record.get(fromJoinField).equals(joinValue); }); if (fromRecord == null) { continue; } for (int i = 0; i < targetFields.length; i++) { String fromField = fromFields[i]; String targetField = targetFields[i]; targetRecord.set(targetField, fromRecord.get(fromField)); // 把对应的段的值取过来 } } }
public static void join(List<Record> targetList, String targetField, List<Record> fromList, String fromField, String targetJoinField, String fromJoinField) throws Exception { if (targetField == null || fromField == null) { return; } join(targetList, new String[] { targetField }, fromList, new String[] { fromField }, targetJoinField, fromJoinField); }
合并两个list,返回一个新的list
public static List<Record> union(List<Record> list1 ,List<Record> list2) { if (list1 == null) { return list2; } if (list2 == null) { return list1; } List<Record> resultList = new ArrayList<>(); resultList.addAll(list1); resultList.addAll(list2); return resultList; }