花里胡哨职场java常用小技巧
list去掉某一元素，其余元素相同去重
List<EcologyRelation> collect = value.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(f -> f.getFileId() + f.getComponentId() + f.getUserId() + f.getModelId() + f.getProjectId() + f.getModelName()))), ArrayList::new));
HashSet<EcologyRelation> set=new HashSet<>();
set.addAll(collect);
for (Map.Entry entry : map.entrySet()) {
//文档id
Integer fileId = (Integer) entry.getKey();
List<EcologyRelation> value = (List<EcologyRelation>) entry.getValue();
//设置模型名称
for (EcologyRelation e : value) {
if (e.getModelId() != null) {
e.setModelName(MODEL_ID_NAME_MAP.get((long) e.getModelId()));
}
}
JSONObject jsonObject = new JSONObject();
jsonObject.put("fid", fileId);
jsonObject.put("status", 1);
jsonObject.put("ecologyRelation", value);
m.put(fileId, jsonObject);
}
mybatis
直接返回一个list集合，不用写那么多的vo接收具体的参数
dao : List<Map<String, Object>> getTree(@Param("list")String list);
xml: <select id="getTree" resultType="java.util.HashMap">
select cast(id as char) as id , group_concat(distinct id,':',name) as rid，concat(name,'/',IFNULL(age,' ')) as info from tablename where id in(${list}) group id
</select>
这条查询的意思是查询list,例如（1,2,3）这三个id，以它们分组查询，查询id，分组查询rid, name和age 连接起来
结果为
id rid info
1 1:name name/age
2 2:name name/age
3 3:name name/age
cast(id as char) as id ,当出现id格式报错时写成这样，正常不会出现这种报错
group_concat（distinct id,':',name） 分组查询 distinct 去重 这一条输出的正常后面是不会有分组的，它本身就是分组,(我是懒的写两条sql)
concat(name,'/',IFNULL(age,'')) 连接多个字段值
ifNull(max(label_id),0) 查询函数大值时，尽量吧ifNull带上，防止出问题，偶发性的问题也要避免
//批量删除
int deleteBatch(@Param("list")List<Integer> list, @Param("tableName") String tableName);
<delete id="deleteBatch" parameterType="list">
delete from ${tableName} where
id in
<foreach collection="list" item="e" separator="," open="(" close=")" index="index">
#{e}
</foreach>
</delete>
//模糊查询
select * from ${tableName} where name like concat('%', concat(#{name},'%'))
根据条件创建表并复制部分表数据
Create table ${newTableName} SELECT * FROM ${tableName} where model_id in (${list})
根据条件复制表数据
INSERT INTO ${newTableName} SELECT * FROM ${tableName} where model_id in (${list})
批量新增
insert into ${tableName} (user_id,project_id,model_id)
values
<foreach collection="list" item="item" index="index" separator=",">
(#{item.userId},#{item.projectId},#{item.modelId})
</foreach>
QueryWrapper<实体类> wrapper=new QueryWrapper<>(); 的使用
wrapper.eq("label_id",lableId);
service.函数方法
IPage<HistoryRecordsInfo> page = new Page<>(current, size);
LambdaQueryWrapper<实体类> lambdaQueryWrapper = Wrappers.<实体类>lambdaQuery().eq(实体类::getId, 传参id).between(实体类::get时间,getStartOfDay(传参时间),getEndOfDay(传参时间)).orderByDesc(实体类::get时间);
baseMapper.selectPage(page, lambdaQueryWrapper);
QueryWrapper userQueryWrapper = new QueryWrapper();
Map<String, Object> map = new HashMap<>();
map.put("user_id", userId);
map.put("project_id", projectId);
map.put("model_id", modelId);
userQueryWrapper.allEq(map);
userQueryWrapper.like(true, "name", name);
userQueryWrapper.eq(true, "component_id", componentId);
public static void main(String[] args) {
String startStr = "2020-08-26";
String endStr = "2022-02-26";
List<String> list = getYearBetweenDate(startStr, endStr);
System.out.println(list);
}
public static List<String> getMonthBetweenDate(String startTime, String endTime){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
// 声明保存日期集合
List<String> list = new ArrayList<String>();
try {
// 转化成日期类型
Date startDate = sdf.parse(startTime);
Date endDate = sdf.parse(endTime);
//用Calendar 进行日期比较判断
Calendar calendar = Calendar.getInstance();
while (startDate.getTime()<=endDate.getTime()){
// 把日期添加到集合
list.add(sdf.format(startDate));
// 设置日期
calendar.setTime(startDate);
//把日期增加一天
calendar.add(Calendar.MONTH, 1);
// 获取增加后的日期
startDate=calendar.getTime();
}
} catch (ParseException e) {
e.printStackTrace();
}
return list;
}
public static List<String> getYearBetweenDate(String startTime, String endTime){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
// 声明保存日期集合
List<String> list = new ArrayList<String>();
try {
// 转化成日期类型
Date startDate = sdf.parse(startTime);
Date endDate = sdf.parse(endTime);
//用Calendar 进行日期比较判断
Calendar calendar = Calendar.getInstance();
while (startDate.getTime()<=endDate.getTime()){
// 把日期添加到集合
list.add(sdf.format(startDate));
// 设置日期
calendar.setTime(startDate);
//把日期增加一天
calendar.add(Calendar.YEAR, 1);
// 获取增加后的日期
startDate=calendar.getTime();
}
} catch (ParseException e) {
e.printStackTrace();
}
return list;
}
、、、分页
Page<EcologyUrlType> page = new Page<EcologyUrlType>(current, size);
IPage<EcologyUrlType> getUrlTypePageList = baseMapper.getUrlTypePageList(page, projectId);
IPage<EcologyUrlType> getUrlTypePageList(Page<EcologyUrlType> page,@Param("projectId")Integer projectId);
常用的方法
//获取一天中的开始时间public static Date getStartOfDay(String startDate) {
ZoneId zone = ZoneId.systemDefault();
LocalDate localDate = Instant.ofEpochMilli(Long.valueOf(startDate)).atZone(ZoneOffset.ofHours(8)).toLocalDate();
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.MIN);
LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);
return Date.from(startOfDay.atZone(zone).toInstant());
}
//获取一天中的结束时间
public static Date getEndOfDay(String endDate) {
ZoneId zone = ZoneId.systemDefault();
LocalDate localDate = Instant.ofEpochMilli(Long.valueOf(endDate)).atZone(ZoneOffset.ofHours(8)).toLocalDate();
LocalDateTime localDateTime = LocalDateTime.of(localDate, LocalTime.MAX);
LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
return Date.from(endOfDay.atZone(zone).toInstant());
}
//生成静态文件
public String generateResourceFile() {
/** 开始生成文件 **/
String dir = langDeskPath;
File d = new File(dir);
if (!d.exists()) {
d.mkdirs();
}
String file = dir + "message.js";
File f = new File(file);
if (f.exists()) {
f.delete();
}
try {
f.createNewFile();
List<String> contentList = new ArrayList<>();
contentList.add("var bdipLang = {\n\tlangType: 'ZH_CN' ,");
contentList.add("\tgetLang: function(id){\n\t\treturn this[this.langType][id];\n\t},");
contentList.add("ZH_CN:{\t\t");
List<CloudLanguageInfo> collect = resourceData.stream().filter(item -> item.getLanguageId() == 7).collect(Collectors.toList());
for (CloudLanguageInfo info : collect) {
contentList.add(new StringBuffer()
.append("\t\"").append(info.getLabelId())
.append("\":\"").append(info.getLabelValue())
.append("\",").toString());
}
contentList.add("\t},\nZH_TW:{\t\t");
List<CloudLanguageInfo> collect1 = resourceData.stream().filter(item -> item.getLanguageId() == 9).collect(Collectors.toList());
for (CloudLanguageInfo info : collect1) {
contentList.add(new StringBuffer()
.append("\t\"").append(info.getLabelId())
.append("\":\"").append(info.getLabelValue())
.append("\",").toString());
}
contentList.add("\t},\nEN:{\t\t");
List<CloudLanguageInfo> collect2 = resourceData.stream().filter(item -> item.getLanguageId() == 8).collect(Collectors.toList());
for (CloudLanguageInfo info : collect2) {
contentList.add(new StringBuffer()
.append("\t\"").append(info.getLabelId())
.append("\":\"").append(info.getLabelValue())
.append("\",").toString());
}
contentList.add("\t},");
contentList.add("}");
FileUtil.writeUtf8Lines(contentList, f);
} catch (IOException e) {
e.printStackTrace();
}
return file;
}
分页public class ListPaging{
/**
* 数据集合的分页方法，根据传入总共的数据跟页码，返回页码所需要显示多少条的数据
* <BR/>采用泛型的方法，即为，list中为什么类型的数据就返回什么类型的数据
* @param f 带有需要进行分页的数据集合
* @param pageNo 第几页
* @param dataSize 显示多少条数据
* @return 进过分页之后返回的数据
*/
public static <F> List<F> datepaging(List<F> f, int pageNo, int dataSize) {
/*
* 经过测试发现当pageNo为0或者小于时，也就是第0页时，程序会报错，所以需要处理一下pageNo的值
*
* 先进行空值的判断，避免程序出现null异常
*
* 当pageNo的值小于等于0时，我们让它的值为1
*/
//参数的校验
if (f == null) {//当传入过来的list集合为null时，先进行实例化
f = new ArrayList<F>();
}
if ((Object) pageNo == null) {//当传入过来的pageNo为null时，先进行赋值操作
pageNo = 1;
}
if ((Object) dataSize == null) {//当传入过来的dataSize为null时，先进行赋值操作
dataSize = 1;
}
if (pageNo <= 0) {
pageNo = 1;
}
//记录一下数据一共有多少条
int totalitems = f.size();
//实例化一个接受分页处理之后的数据
List<F> afterList = new ArrayList<F>();
/*
* 进行分页处理,采用for循环的方式来进行处理
*
* 首先for循环中，i应该从哪里开始:i应该从 (当前是第几页 -1 乘以 条数) 开始
*
* 然后for循环应该到哪里结束，也就是i应该小于:判断(开始的索引+显示条数)是不是大于总条数，如果大于就是总条数，如果小于就是(开始的索引+显示条数)
*
* 然后让i++
*/
for
(int i = (pageNo - 1) * dataSize;
i < (((pageNo - 1) * dataSize) + dataSize >
totalitems ? totalitems : ((pageNo - 1) * dataSize) + dataSize);
i++) {
//然后将数据存入afterList中
afterList.add(f.get(i));
}
//然后将处理后的数据集合进行返回
return afterList;
}
// 返回对象集合以类属性一升序排序
list.stream().sorted(Comparator.comparing(类::属性一));
// 返回对象集合以类属性一降序排序 注意两种写法
list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序
// 返回对象集合先以类属性一升序，再以属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));
// 返回 对象集合以类属性一降序 属性二升序 注意两种写法
// 先以属性一升序,升序结果进行属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));
// 先以属性一降序,再进行属性二升序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));
// 返回 对象集合以类属性一降序 属性二降序 注意两种写法
// 先以属性一升序,升序结果进行属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));
// 先以属性一降序,再进行属性二降序
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));
// 返回 对象集合以类属性一升序 属性二降序 注意两种写法
// 先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());
// 先以属性一升序,再进行属性二降序 list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,