内容简介 本文主要说明在Java8及以上版本中，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。 List对象类（StudentInfo）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
public class StudentInfo implements Comparable<StudentInfo> { //名称 private String name; //性别 true男 false女 private Boolean gender; //年龄 private Integer age; //身高 private Double height; //出生日期 private LocalDate birthday; public StudentInfo(String name, Boolean gender, Integer age, Double height, LocalDate birthday){ this.name = name; this.gender = gender; this.age = age; this.height = height; this.birthday = birthday; } public String toString(){ String info = String.format("%s\t\t%s\t\t%s\t\t\t%s\t\t%s",this.name,this.gender.toString(),this.age.toString(),this.height.toString(),birthday.toString()); return info; } public static void printStudents(List<StudentInfo> studentInfos){ System.out.println("[姓名]\t\t[性别]\t\t[年龄]\t\t[身高]\t\t[生日]"); System.out.println("----------------------------------------------------------"); studentInfos.forEach(s->System.out.println(s.toString())); System.out.println(" "); } @Override public int compareTo(StudentInfo ob) { return this.age.compareTo(ob.getAge()); //return 1; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Boolean getGender() { return gender; } public void setGender(Boolean gender) { this.gender = gender; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Double getHeight() { return height; } public void setHeight(Double height) { this.height = height; } public LocalDate getBirthday() { return birthday; } public void setBirthday(LocalDate birthday) { this.birthday = birthday; } } |
测试数据
|
1 2 3 4 5 6 |
//测试数据，请不要纠结数据的严谨性 List<StudentInfo> studentList = new ArrayList<>(); studentList.add(new StudentInfo("李小明",true,18,1.76,LocalDate.of(2001,3,23))); studentList.add(new StudentInfo("张小丽",false,18,1.61,LocalDate.of(2001,6,3))); studentList.add(new StudentInfo("王大朋",true,19,1.82,LocalDate.of(2000,3,11))); studentList.add(new StudentInfo("陈小跑",false,17,1.67,LocalDate.of(2002,10,18))); |
输出Students列表
|
1 2 |
//输出List StudentInfo.printStudents(studentList); |
输出结果如下图： 使用filter()过滤List
|
1 2 3 4 |
//查找身高在1.8米及以上的男生 List<StudentInfo> boys = studentList.stream().filter(s->s.getGender() && s.getHeight() >= 1.8).collect(Collectors.toList()); //输出查找结果 StudentInfo.printStudents(boys); |
结果如下图： from:https://www.cnblogs.com/codecat/p/10912454.html
View DetailsAPI: https://www.runoob.com/java/java8-streams.html
|
1 2 3 4 |
mylist.stream() .map(myfunction->{ return item; }).collect(Collectors.toList()); |
说明： steam():把一个源数据，可以是集合，数组，I/O channel， 产生器generator 等，转化成流。 forEach():迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数.
|
1 2 |
Random random = new Random(); random.ints().limit(10).forEach(System.out::println); |
map():用于映射每个元素到对应的结果。以下代码片段使用 map 输出了元素对应的平方数：
|
1 2 3 |
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); // 获取对应的平方数 List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList()); |
filter():filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：
|
1 2 3 4 5 6 7 8 |
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); // 获取空字符串的数量 int count = strings.stream().filter(string -> string.isEmpty()).count(); limit limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据： Random random = new Random(); random.ints().limit(10).forEach(System.out::println); |
sorted(): 用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：
|
1 2 3 4 5 6 7 8 9 |
Random random = new Random(); random.ints().limit(10).sorted().forEach(System.out::println); 并行（parallel）程序 parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量： List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); // 获取空字符串的数量 int count = strings.parallelStream().filter(string -> string.isEmpty()).count(); 我们可以很容易的在顺序运行和并行直接切换。 |
Collectors(): 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
|
1 2 3 4 5 6 |
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); System.out.println("筛选列表: " + filtered); String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", ")); System.out.println("合并字符串: " + mergedString); |
from:https://blog.csdn.net/shine_guo_star/article/details/94383319
View Details转: https://blog.csdn.net/sanchan/article/details/70753645 java8的optional的使用： http://www.jdon.com/idea/java/using-optional-effectively-in-java-8.html http://www.runoob.com/java/java8-optional-class.html Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。 Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。 Optional 类的引入很好的解决空指针异常。 类声明 以下是一个 java.util.Optional<T> 类的声明： public final class Optional<T> extends Object
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 |
在Java 8中stream().map()，您可以将对象转换为其他对象。查看以下示例： 1.大写字符串列表 1.1简单的Java示例将Strings列表转换为大写。 TestJava8.java package com.mkyong.java8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class TestJava8 { public static void main(String[] args) { List<String> alpha = Arrays.asList("a", "b", "c", "d"); //Before Java8 List<String> alphaUpper = new ArrayList<>(); for (String s : alpha) { alphaUpper.add(s.toUpperCase()); } System.out.println(alpha); //[a, b, c, d] System.out.println(alphaUpper); //[A, B, C, D] // Java 8 List<String> collect = alpha.stream().map(String::toUpperCase).collect(Collectors.toList()); System.out.println(collect); //[A, B, C, D] // Extra, streams apply to any data type. List<Integer> num = Arrays.asList(1,2,3,4,5); List<Integer> collect1 = num.stream().map(n -> n * 2).collect(Collectors.toList()); System.out.println(collect1); //[2, 4, 6, 8, 10] } } 2.对象列表 - >字符串列表 2.1 name从staff对象列表中获取所有值。 Staff.java package com.mkyong.java8; import java.math.BigDecimal; public class Staff { private String name; private int age; private BigDecimal salary; //... } TestJava8.java package com.mkyong.java8; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class TestJava8 { public static void main(String[] args) { List<Staff> staff = Arrays.asList( new Staff("mkyong", 30, new BigDecimal(10000)), new Staff("jack", 27, new BigDecimal(20000)), new Staff("lawrence", 33, new BigDecimal(30000)) ); //Before Java 8 List<String> result = new ArrayList<>(); for (Staff x : staff) { result.add(x.getName()); } System.out.println(result); //[mkyong, jack, lawrence] //Java 8 List<String> collect = staff.stream().map(x -> x.getName()).collect(Collectors.toList()); System.out.println(collect); //[mkyong, jack, lawrence] } } 对象列表 - >其他对象列表 3.1此示例说明如何将staff对象列表转换为对象列表StaffPublic。 Staff.java package com.mkyong.java8; import java.math.BigDecimal; public class Staff { private String name; private int age; private BigDecimal salary; //... } StaffPublic.java package com.mkyong.java8; public class StaffPublic { private String name; private int age; private String extra; //... } 3.2 Java 8之前。 BeforeJava8.java package com.mkyong.java8; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class BeforeJava8 { public static void main(String[] args) { List<Staff> staff = Arrays.asList( new Staff("mkyong", 30, new BigDecimal(10000)), new Staff("jack", 27, new BigDecimal(20000)), new Staff("lawrence", 33, new BigDecimal(30000)) ); List<StaffPublic> result = convertToStaffPublic(staff); System.out.println(result); } private static List<StaffPublic> convertToStaffPublic(List<Staff> staff) { List<StaffPublic> result = new ArrayList<>(); for (Staff temp : staff) { StaffPublic obj = new StaffPublic(); obj.setName(temp.getName()); obj.setAge(temp.getAge()); if ("mkyong".equals(temp.getName())) { obj.setExtra("this field is for mkyong only!"); } result.add(obj); } return result; } } 输出 [ StaffPublic{name='mkyong', age=30, extra='this field is for mkyong only!'}, StaffPublic{name='jack', age=27, extra='null'}, StaffPublic{name='lawrence', age=33, extra='null'} ] 1 2 3 4 5 3.3 Java 8的例子。 NowJava8.java package com.mkyong.java8; package com.hostingcompass.web.java8; import java.math.BigDecimal; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class NowJava8 { public static void main(String[] args) { List<Staff> staff = Arrays.asList( new Staff("mkyong", 30, new BigDecimal(10000)), new Staff("jack", 27, new BigDecimal(20000)), new Staff("lawrence", 33, new BigDecimal(30000)) ); // convert inside the map() method directly. List<StaffPublic> result = staff.stream().map(temp -> { StaffPublic obj = new StaffPublic(); obj.setName(temp.getName()); obj.setAge(temp.getAge()); if ("mkyong".equals(temp.getName())) { obj.setExtra("this field is for mkyong only!"); } return obj; }).collect(Collectors.toList()); System.out.println(result); } } [ StaffPublic{name='mkyong', age=30, extra='this field is for mkyong only!'}, StaffPublic{name='jack', age=27, extra='null'}, StaffPublic{name='lawrence', age=33, extra='null'} ] |
from:https://www.cnblogs.com/fengli9998/p/9002377.html
View Details公司一个项目要从.net framework平台转成.net core平台，都是为了跨平台啊。 老的项目中用了个小众的类库：DapperExtensions。 有个同事直接nuget安装了该类库的.net core版本：DapperExtensions.NetCore，然后一直报错；于是向我求助。 报错代码如下图： 报错信息： P.S 同事用的是异步调用，同步调用是没问题的。 由于此类库不再更新，官网也没有了……也找不到文档； 在网上很少的资料中，都是些简单的示例，使用的都是同步调用，但同事用的是异步调用。我们一块折腾了半个上午，也没解决。但还不想放弃啊……于是又双叒叕重新撸了n遍，豁然发现：生成的MySQL语句里怎么会有中括号！灯下黑~…… 于是，网上一通搜，终于找到一篇说SQL方言的文档，看了一下DapperExtensions的源码，发现也有设置SQL方言的方法：
|
1 |
DapperExtensions.DapperExtensions.SqlDialect = new MySqlDialect(); |
运行……还是报错……%~@#￥，没起作用！无奈……拉倒吧，把代码改为同步调用吧。 还是不想放弃，再看一眼吧——竟然发现DapperExtensions的源码中异步方法和同步方法的SQL方言竟然是单独设置的，这类库设计的也没谁了……，于是设置了一下异步的SQL方言为MySQL，终于解决了。代码如下：
|
1 |
DapperExtensions.DapperAsyncExtensions.SqlDialect = new MySqlDialect(); |
总结： 不要使用小众类库，尤其是个人开发的。因为出了问题太难解决了。 解决问题要细心，更要有耐心；放空思想，从头多撸几遍。 小众类库的代码设计考虑不周： a. 比如说，代码已经写为new MySqlConnection(ConnString)，SQL方言就应该自动设置为MySQL了。 b. 另一个，对于SQL方言，设置一次就行了，不应该设计成异步要单独设置。 解决过程实属不易，希望能帮助大家，谢谢~
View Details一、前言 ci/cd 持续集成持续交付，开发人员尝尝会遇到一些重复工作，比如一个asp.net的网站代码，写完之后要发布，然后再将发布内容移动到部署的服务器上再进行部署，就算你只改了一个页面上的一个字，也要将之前的发布部署过程重新做一遍。 CI 解决了这个重复性问题，开发人员只需git push 提交代码，剩下的工作交给CI , 做CI工作的有gitlab-ci/cd Jenkins k8s等，中小项目gitlab-ci比较合适，因为它更轻量级一些，本篇仅讨论gitlab的cicd功能。 二、环境 IP 角色 192.168.10.202(ubuntu) gitlab 192.168.10.208(centos) git,docker,gitlab-runner gitlab git docker 三者的安装 略。且本篇是以docker镜像方式部署 上图为gitlab-ci的过程，其实它只是省略了一些我们的手动发布部署过程，将其自动化，但原来的流程还是一个不能少。所以，我们要进行的第一步，就是手动实现一遍流程。 三、手动实现一遍 (gitlab服务器) 创建代码仓库—> (开发PC) git clone —> (开发pc) 修改代码，添加dockerfile —> (开发pc) git push —> (部署服务器) git pull —> (部署服务器) docker build ，docker run 1、创建代码仓库 在创建之前，需要在使用git的机器上设置好ssh，可以参考之前的https://www.cnblogs.com/hallejuayahaha/p/11996332.html 要注意的是，在部署机器上，gitlab-runner安装好后，需要添加一个gitlab-runner的用户，需要添加这个用的ssh，因为在ci自动化后，在部署服务器上的操作都是由这个用户来做的，所以不仅要添加它的ssh，也要docker 免去sudo的指令。 总之就是让gitlab-runner用户，在做部署过程中，不要受到权限的阻碍。 ******docker免去敲sudo******* 在安装完docker之后，也会出现一个docker用户组，将你要免去敲sudo的用户添加进去，就可以了
|
1 |
sudo usermod -aG docker gitlab-runner |
添加代码仓库 并将一个.netcore项目创建进去 添加dockerfile文件，仅需在项目上右键，docker支持，vs就可以自动添加。然后git push 这样开发pc端的代码就都提交到gitlab服务器上了， 2、部署端git pull ，docker build ， docker run 镜像已经成功启动，打开浏览器，输入ip + 暴露出来的端口8090 PS: .NETCORE web中，startup.cs文件中，有 app.UseHsts(); app.UseHttpsRedirection(); 这两行要注释掉，不然网站回一直往https跳转，没法进入http的80端口 整个手动流程成功。 […]
View Details1.配合使用调用app原生的方法（h5页面不需要回调和数据） 实例1
|
1 2 3 4 5 6 7 8 9 |
// 通知客户端，token失效 callTokenLostToApp(){ let boswer = vm.config.getBrowser() if(boswer == 'isiOS'){ window.webkit.messageHandlers.tokenExpiredTransmit.postMessage(1); }else if(boswer == 'isAndroid'){ window.tokenExpiredTransmit.jsMethod(1) } }, |
实例2
|
1 2 3 4 5 6 7 8 9 |
// 关闭页面 closePageApp(cb){ let boswer = vm.config.getBrowser() // IOS 关闭页面 if(boswer == 'isiOS'){ // 这段代码是固定的，必须要放到js中 window.webkit.messageHandlers.closePage.postMessage(1); // 安卓关闭页面 }else if(boswer == 'isAndroid'){ window.closePage.jsMethod(1) } }, |
2.配合使用调用app原生的方法（h5页面需要回调和数据） // 从App获取UUID(手机唯一标识)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
// 从App获取UUID(手机唯一标识) getSystemInfoFromApp(cb){ let boswer = vm.config.getBrowser() // IOS 获取UUID if(boswer == 'isiOS'){ // 这段代码是固定的，必须要放到js中 function setupWebViewJavascriptBridge(callback) { if (window.WebViewJavascriptBridge) { return callback(WebViewJavascriptBridge); } if (window.WVJBCallbacks) { return window.WVJBCallbacks.push(callback); } window.WVJBCallbacks = [callback]; var WVJBIframe = document.createElement('iframe'); WVJBIframe.style.display = 'none'; WVJBIframe.src = 'wvjbscheme://__BRIDGE_LOADED__'; document.documentElement.appendChild(WVJBIframe); setTimeout(function() { document.documentElement.removeChild(WVJBIframe) }, 0) } /*与OC交互的所有JS方法都要放在此处注册，才能调用通过JS调用OC或者让OC调用这里的JS*/ setupWebViewJavascriptBridge(function(bridge) { /*JS给ObjC提供公开的API，ObjC端通过注册，就可以在JS端调用此API时，得到回调。ObjC端可以在处理完成后，反馈给JS，这样写就是在载入页面完成时就先调用*/ bridge.callHandler('getSystemInfoFromApp', function(responseData) { if(cb && typeof cb == 'function'){ cb(responseData) }else{ return responseData } }) }) // 安卓获取UUID }else if(boswer == 'isAndroid'){ let systemInfo = window.AndroidWebView.getSystemInfoFromApp(); if(cb && typeof cb == 'function'){ cb(systemInfo) }else{ return systemInfo } } }, |
标红字段为调用的app端定义的方法名，需要app端定义方法配合 from:https://www.cnblogs.com/wendyAndJken/p/9318501.html
View Details使用IDEA创建gradle项目后，执行main方法时会自动运行gradle的一些build task，导致启动很慢，如下图： 解决方法： 打开设置页面，进行如下修改： from:https://zhoujun.blog.csdn.net/article/details/103372893
View Details一般情况下，DO是用来映射数据库记录的实体类，DTO是用来在网络上传输的实体类。两者的不同除了适用场景不同外还有就是DTO需要实现序列化接口。从DB查询到数据之后，ORM框架会把数据转换成DO对象，通常我们需要再把DO对象转换为DTO对象。同样的，插入数据到DB之前需要将DTO对象转换为DO对象然后交给ORM框架去执行JDBC。 通常用到的转换工具类BeanUtils是通过反射来实现的，实现源码如下
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
public static <T> T convertObject(Object sourceObj, Class<T> targetClz) { if (sourceObj == null) { return null; } if (targetClz == null) { throw new IllegalArgumentException("parameter clz shoud not be null"); } try { Object targetObj = targetClz.newInstance(); BeanUtils.copyProperties(sourceObj, targetObj); return (T) targetObj; } catch (Exception e) { throw new RuntimeException(e); } } private static void copyProperties(Object source, Object target, Class<?> editable, String[] ignoreProperties) throws BeansException { Assert.notNull(source, "Source must not be null"); Assert.notNull(target, "Target must not be null"); Class<?> actualEditable = target.getClass(); if (editable != null) { if (!editable.isInstance(target)) { throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]"); } actualEditable = editable; } PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable); List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null; for (PropertyDescriptor targetPd : targetPds) { if (targetPd.getWriteMethod() != null && (ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) { PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName()); if (sourcePd != null && sourcePd.getReadMethod() != null) { try { Method readMethod = sourcePd.getReadMethod(); if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) { readMethod.setAccessible(true); } Object value = readMethod.invoke(source); Method writeMethod = targetPd.getWriteMethod(); if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) { writeMethod.setAccessible(true); } writeMethod.invoke(target, value); } catch (Throwable ex) { throw new FatalBeanException("Could not copy properties from source to target", ex); } } } } } |
也可以通过mapstruct来实现，这种方式是在Mapper接口的包中生成一个对应mapper的实现类，实现类的源码如下。显然这种方式的实现更为普通，看起来没有BeanUtils的实现那么复杂。不过BeanUtils通过反射实现更为通用，可以为各种类型的DTO实现转换。而mapstruct只是帮我们生产了我们不想写的代码。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public Task doToDTO(TaskDO taskDO) { if (taskDO == null) { return null; } else { Task task = new Task(); task.setId(taskDO.getId()); //其他字段的set task.setGmtCreate(taskDO.getGmtCreate()); task.setGmtModified(taskDO.getGmtModified()); return task; } } |
对比以上两种方式，显然使用BeanUtils来进行转换时需要写的代码更少，内部的通过反射便可以进行get/set操作。而mapstruct实现上需要写的代码稍微多一点，但是这种方式的性能比通过反射实现更好。下面写一段代码来测试两种方式实现的性能差别。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public void testConvert() { System.out.println("####testConvert"); int num = 100000; TaskDO taskDO = new TaskDO(); long start = System.currentTimeMillis(); for (int i = 0; i < num; i ++) { Task task = ObjectConvertor.convertObject(taskDO, Task.class); } System.out.println(System.currentTimeMillis() - start); //--------------------------------------------- start = System.currentTimeMillis(); for (int i = 0; i < num; i ++) { Task task = taskMapper.doToDTO(taskDO); } System.out.println(System.currentTimeMillis() - start); } |
以上测试代码中分别使用两种方式对同一个DO对象进行n次转换，两次转换的耗时统计如下。单位：ms 次数 1 10 100 1000 10000 100000 1000000 10000000 Mapstruct 0 1 1 1 2 4 8 8 BeanUtil 9 7 11 26 114 500 1469 14586 可见当转换数量级增加时，使用BeanUtil的耗时急剧上升，而使用Mapstruct的耗时则保持在比较低的水平。 在一个系统中，ORM对DB的各种操作几乎都会涉及到DO和DTO之间的转换，参考以上表格的统计结果，更推荐使用Mapstruct。 from:https://www.cnblogs.com/umgsai/p/8570652.html
View Details1、PO即persistant Object 持久对象： 在O/R 映射（即ORM-ObjectRelationMapping）中出现的概念，通常对应数据模型（数据库），是与数据库汇总的表想影射的java对象，最简单的PO就是对应数据库中某个表中的一条记录，多个记录则用PO的集合。PO中不应该包含任何对数据库的操作。 2、DO即Domain Object 领域对象： 是从现实世界中抽象出来的有形或无形的业务实体。 3、TO即Transfer Object数据传输对象： 不同应用程序之间传输的对象 4、DTO即Data Transfer Object:数据传输对象： 泛指用于展示层与服务层之间的数据传输对象 5、VO即value Object： 通常用于业务层之间的数据传递，和PO一样仅包含数据，但是抽象出的业务对象，可以和表对应，用new 关键字创建，GC回收 6、BO即Business Object 业务对象: 主要是将业务逻辑封装为一个对象，这个对象可以包含一个或多个其他对象，如一个简历中包含教育经历、工作经历、社会关系等，可以将一个教育经历对应一个PO、工作经历对应一个PO、设计关系对应一个PO，然后简历一个对应简历的BO兑现处理简历，每个BO包含这个PO这样处理业务逻辑是，可以针对BO去处理。封装业务逻辑的java对象，通过调用DAO方法，结合PO,VO进行业务操作。 7、POJO即Plain Ordinary Java Object: 简单无规则的java对性，即在一些O/R 映射工具中，能做到维护数据库表记录的PO完全是一个符合Java Bean规范的纯java对象 from:https://blog.csdn.net/weixin_44122921/article/details/85038513
View Details将map集合转为json对象时遇到一个问题。map中 updateTime的value为日期格式如"2001-01-01"，在使用 JSONObject.toJSON(map).toString() 的时候, 得到的结果 updateTime 的值为 时间戳 解决方法: 使用fastjson 的 JSON.toJSONStringWithDateFormat(Object,dateformat,SerializerFeature.WriteDateUseDateFormat) 方法即可将时间戳转换为自定义格式类型的值 from:https://blog.csdn.net/qq_39564789/article/details/105176845
View Details