java 正则和连接json
前面已经写了不少关于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;
}
java 正则和连接json的更多相关文章
- Java正则速成秘籍（一）之招式篇
导读 正则表达式是什么?有什么用? 正则表达式(Regular Expression)是一种文本规则,可以用来校验.查找.替换与规则匹配的文本. 又爱又恨的正则 正则表达式是一个强大的文本匹配工具,但 ...
- Java正则速成秘籍（二）之心法篇
导读 正则表达式是什么?有什么用? 正则表达式(Regular Expression)是一种文本规则,可以用来校验.查找.替换与规则匹配的文本. 又爱又恨的正则 正则表达式是一个强大的文本匹配工具,但 ...
- Java正则速成秘籍（三）之见招拆招篇
导读 正则表达式是什么?有什么用? 正则表达式(Regular Expression)是一种文本规则,可以用来校验.查找.替换与规则匹配的文本. 又爱又恨的正则 正则表达式是一个强大的文本匹配工具,但 ...
- java中myeclipse连接mysql问题（java.lang.ClassNotFoundException: com.mysql.jdbc.Driver）
java中myeclipse连接mysql问题(java.lang.ClassNotFoundException: com.mysql.jdbc.Driver) 1.往项目中添加mysql-conne ...
- java.lang.classnotfoundexception org.json.jsonexception
java.lang.classnotfoundexception org.json.jsonexception 解决方法 http://www.java2s.com/Code/Jar/j/Downlo ...
- Java构造和解析Json数据的两种方法详解二
在www.json.org上公布了很多JAVA下的json构造和解析工具,其中org.json和json-lib比较简单,两者使用上差不多但还是有些区别.下面接着介绍用org.json构造和解析Jso ...
- java 正则匹配空格字符串 正则表达式截取字符串
java 正则匹配空格字符串 正则表达式截取字符串 需求:从一堆sql中取出某些特定字符串: 比如配置的sql语句为:"company_code = @cc and project_id = ...
- JAVA使用jdbc连接MYSQL简单示例
以下展示的为JAVA使用jdbc连接MYSQL简单示例: import java.sql.DriverManager; import java.sql.ResultSet; import java.s ...
- java根据url获取json对象
package test; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; ...
随机推荐
- 一个禁用mac内置键盘的方法
一个禁用mac内置键盘的方法 强大的 karabiner, 非常好用. 可以直接在有外接键盘连接的情况下, 禁用掉内置键盘 另外一个方法是启用mac的 鼠标键, 感觉用处不是很大, 修饰健并没有被禁用 ...
- Beta冲刺（3/5）
队名:無駄無駄 组长博客 作业博客 组员情况 张越洋 过去两天完成了哪些任务 数据库实践的报告 提交记录(全组共用) 接下来的计划 加快校园百科的进度 还剩下哪些任务 学习软工的理论课 学习代码评估. ...
- ICEM-带柱底座
原视频下载地址:https://pan.baidu.com/s/1c2KgCBA 密码: ixk8
- node.js使用cluster实现多进程
首先郑重声明: nodeJS 是一门单线程!异步!非阻塞语言! nodeJS 是一门单线程!异步!非阻塞语言! nodeJS 是一门单线程!异步!非阻塞语言! 重要的事情说3遍. 因为nodeJS天生 ...
- 【大数据】分布式文件系统HDFS 练习
作业要求来自于https://edu.cnblogs.com/campus/gzcc/GZCC-16SE2/homework/3292 利用Shell命令与HDFS进行交互 以”./bin/dfs d ...
- Net core学习系列（四）——Net Core项目执行流程
"跨平台"后的ASP.Net Core是如何接收并处理请求的呢? 它的运行和处理机制和之前有什么不同?本章从"宏观"到"微观"地看一下它的结 ...
- postgres安装pg_buffercache扩展
1.查看是否安装了pg_buffercache postgres=# \dx List of installed extensions Name | Version | Schema | Descri ...
- 轻量级Web服务器http-server
http-server是一个简单的零配置命令行http服务器.可用于h5页面手机端测试 Vue .Angualr.React项目打包后真机测试 github地址:https://github.com/ ...
- Spring cloud微服务安全实战-7-8ELK+SpringBoot环境搭建
采集不可聚合的离散的.日志信息的e ELK是三个系统的简称 LogStash:用来做日志的收集.过滤.格式转换 Kibana:和普罗米修斯的grafana一个意思.主要用来展示数据. 用docker来 ...
- redis内存分析工具rdbtools
当Redis的内存已经快满的时候,我们能做什么呢? 最直接的方法就是分析一下Redis内存的构成,看是哪些键比较大,或者比较多,然后考虑一下对应的功能能不能优化,例如减少超时时间,例如不必要的数据不用 ...