项目中常用写法(Java)
- Java
- 新建JSONObject
- 递归
- 使用反射根据取得的返回值,父类相对应转成成对应的子类,并且取得子类属性值
- 查看某个值在不在数组里:
- list转化成字符串用逗号分割:
- 截取字符串某个字之前的文字:
- 比较时间
- 判断集合是否为空
- lambda 集合对象,获取所有对象中的某个字段,形成新集合
- lambda 集合对象,根据对象中某个字段进行排序
- lambda 集合对象,过滤对象某个值等于某个值,生成新的list
- lambda 集合去重复给一个新list:
- list遍历:
- 定时任务:
- java反射调用某个方法并传参,且调用的方法中某个实体注入为空的解决方法:
- java定义枚举变量和获取对应变量值:
- 定时任务:
- 字符串要补齐4位置,使用空格补齐:
- 获取数据转化成JsonObject获取数据某个字段然后再转化成数组
- 判断字符串是否为空,如果是空,变成null
- 数组转化成list遍历
- 判断字符串是否为空:
- 字符串拼接:
- 字符串第一个匹配的字符去掉:
- 字符串转化成数组:
- 字符串转化成日期格式:
- 删除字符串中的中括号[]:
- 去掉字符串中的双引号:
- 去掉字符串中的双引号:
- 判断集合是否是空,并且某个字符串是否包含在内:
- 判断字符串不为空:
- JsonArray类型去重:
- 异步执行:
- 截取文件扩展名:
- 判断字符串是否在数组中:
- map的value放到list中:
- 前端传递的值后端request接受:
- 字符串逗号分隔转化成list:
- 判断文件是不是图片类型:
- file转MultipartFile:
- MultipartFile转file:
- 相同实体类值拷贝:
- list转化成String[]:
- 获取总毫秒数:
- list对象,根据相同id某些属性值合并或者计算:
- 复制新的实体类:
- 字符串合并去重:
- list集合获取所有id组成新list:
- 字符串补充左0:
- list集合根据id去重后生成新list:
Java
项目中常用的书写方式
新建JSONObject
JSONObject reslist = new JSONObject();
递归
sfresult = getParetId(currCorp.getLevel(),currCorp,sf,sn,zzq);
private String getParetId (Integer id,ICorp currCorp,Boolean sf,Boolean sn, Boolean zzq){
String sfresults = "";
if(id == 2) {
sfresults = getReturn(sf,sn,zzq,currCorp);
} else {
id = (organService.getCorp(currCorp.getPcorpId())).getLevel();
currCorp = organService.getCorp(currCorp.getPcorpId());
sf = currCorp.getName().contains("省");
sn = currCorp.getName().contains("市");
zzq = currCorp.getName().contains("自治区");
sfresults = getParetId(id,currCorp,sf,sn,zzq);
}
return sfresults;
}
使用反射根据取得的返回值,父类相对应转成成对应的子类,并且取得子类属性值
Class classtype = Class.forName(ajjc.getClass().getName());
Optional aa = safeCast(classtype,ajjc); //父类转化成对应的子类
Field fields = aa.get().getClass().getDeclaredField("sasj");// 获取反射的属性
fields.setAccessible(true);
Date sasj = (Date) fields.get(aa.get()); // 获取反射的属性的值
// 类型转化,父类型转化成对应的子类型
public static <T,U> Optional<T> safeCast (Class<T> clazz,U obj){
if (clazz.isInstance(obj)){
return Optional.of((T) obj);
}
return Optional.empty();
}
查看某个值在不在数组里:
// 类型转化,父类型转化成对应的子类型
private static final String[] YWLX_AY = {"164","166","170","200","201","202","203","206","209","214","232","233","314","315","4188","51"};
Arrays.asList(YWLX_AY).contains(res.getBszm())
list转化成字符串用逗号分割:
StringUtils.join(collect,",")
截取字符串某个字之前的文字:
currCorp.getName().substring(0, currCorp.getName().indexOf("省"))
比较时间
import java.time.LocalDate;
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate.now().toEpochDay() <= LocalDate.parse(time.getTargetend(), formatter).toEpochDay()
判断集合是否为空
CollectionUtils.isEmpty()
lambda 集合对象,获取所有对象中的某个字段,形成新集合
List<String> Zdkhxm = list.stream().map(o -> o.getZdkhxm_bh()).collect(Collectors.toList());
lambda 集合对象,根据对象中某个字段进行排序
kpiList = kpiList.stream().sorted(Comparator.comparing(TargetManagementKpi::getXssx_kpi)).collect(Collectors.toList());
lambda 集合对象,过滤对象某个值等于某个值,生成新的list
List<CustomerInfo> info = customerList.stream().filter(fitem -> item.getUser_id().equals(fitem.getUserid())).collect(Collectors.toList());
lambda 集合去重复给一个新list:
List<String> collect = newaylist.stream().distinct().collect(Collectors.toList());
list遍历:
aylist.forEach(res -> {
});
定时任务:
@Scheduled(cron = "0 0 0 2 4 ?")
java反射调用某个方法并传参,且调用的方法中某个实体注入为空的解决方法:
ResponseData data = new ResponseData();
Class<?> clazz = Class.forName("com.aa.bb.impl.xxService");
//参数1是方法名 参数2是方法参数
Method method = clazz.getDeclaredMethod("getdata",params.getClass());
//创建bean 如果使用clazz.newInstance()创建 在调用getdata方法中 的实体类注入为null 所以需要使用;SpringContextUtil.getBeanByClass创建实体类
data = (ResponseData) method.invoke(SpringContextUtil.getBeanByClass(clazz), params) ;
ResponseData data = new ResponseData();
SpringContextUtil文件
@Component
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
@SuppressWarnings("unchecked")
public static <T> T getBeanByName(String name) {
return (T) applicationContext.getBean(name);
}
@SuppressWarnings("unchecked")
public static <T> T getBeanByClass(Class<?> clazz) {
return (T) applicationContext.getBean(clazz);
}
}
java定义枚举变量和获取对应变量值:
public enum AaEnum {
AA("aa","01"),
BB("bb","02"),
CC("cc","03"),
DD("dd","04"),
EE("ee","05");
/**注入bean名字*/
private String name;
/**类型*/
private String lx;
/**
* 构造方法
* @param name
* @param lx
*/
AaEnum (String name, String lx){
this.name=name;
this.lx=lx;
}
public String getName() {
return name;
}
public String getLx() {
return lx;
}
}
AaEnum.AA.getLx()
定时任务:
@Scheduled(cron = "0 0 0 2 4 ?")
字符串要补齐4位置,使用空格补齐:
String.format("%04d", 125)
获取数据转化成JsonObject获取数据某个字段然后再转化成数组
String[] aaArr = ((JSONObject)paramsData.getData()).get("aa").toString().split(",");
判断字符串是否为空,如果是空,变成null
aaDTO.setAa(String.valueOf(aaJSONObject.get("aa")));
数组转化成list遍历
Arrays.asList(aaDTO.getarray()).forEach(item->{
System.out,println("aa");
});
判断字符串是否为空:
StringUtils.isNotBlank(String.valueOf(aa))
字符串拼接:
StringBuilder sb = new StringBuilder();
sb.append(aa).append(bb);
String sqlResult = sb.toString();
字符串第一个匹配的字符去掉:
String aa = "";
aa = aa.replaceFirst("AND", "");
字符串转化成数组:
String[] times = String.valueOf(timedata).split(",");
字符串转化成日期格式:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date start = sdf.parse("aa");
sdf.format(start);
删除字符串中的中括号[]:
StringUtils.strip(String.valueOf(param), "[]")
去掉字符串中的双引号:
String aa = aa.replace("\"", "");
去掉字符串中的双引号:
String aa = aa.replace("\"", "");
判断集合是否是空,并且某个字符串是否包含在内:
private boolean isProperty(List<String> aa, String bb) {
return (Optional.of(aa).orElse(new ArrayList<>()).contains(bb)
|| "bhAj".equals(bb)) && !"bh".equals(bb);
}
判断字符串不为空:
StringUtils.isNotBlank(ObjectUtils.toString(item.get("aa")))
JsonArray类型去重:
JSONArray result = new JSONArray();
List<String> list = List<String> list = result.toJavaList(String.class);
HashSet hs = new HashSet(list);
result = JSONArray.parseArray(JSON.toJSONString(hs));
// JsonArray转化成List:JSONObject.parseArray(result.toJSONString(), String.class);
异步执行:
// 异步调用上传到aws3
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(()->{
// 异步内容
});
executor.shutdown();
截取文件扩展名:
String aa = "E:\dc\Advertising-back\resourcesupload\aa.jpg";
aa.substring(item.getAdvertisementUrl().lastIndexOf(".")+1);
判断字符串是否在数组中:
String aa = "jpg";
String [] normal = new String[] {"mp4","MP4","webm","WEBM","ogg","OGG","mkv","MKV"};
Arrays.asList(normal).contains(aa);
map的value放到list中:
List<MultipartFile> list = new ArrayList<>();
Map<String, MultipartFile> files = multipartRequest.getFileMap();
list = new ArrayList<>(files.values());
前端传递的值后端request接受:
request.getParameter("name")
字符串逗号分隔转化成list:
List<String> list = Arrays.asList("aa,bb,cc".split(","))
判断文件是不是图片类型:
if(MeragePicUtil.isImage(item)){
// 是图片类型
}
public static boolean isImage(File file){
Image image = null;
try {
image = ImageIO.read(file);
} catch (IOException e) {
throw new RuntimeException(e);
}
return image != null;
}
file转MultipartFile:
public static MultipartFile fileToMultipartFile(File file) {
MultipartFile result = null;
if (null != file) {
try (FileInputStream input = new FileInputStream(file)) {
result = new MockMultipartFile(file.getName().concat("temp"), file.getName(), "text/plain", input);
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
MultipartFile转file:
public static File MultipartFileTofile(MultipartFile file) throws IOException {
MultipartFile result = null;
String basePath = ResourceUtils.getURL("resources/").getPath() + "upload/";
SimpleDateFormat formatter_RR = new SimpleDateFormat("yyyyMMddHHmmssSSS");
String str1 = file.getOriginalFilename().substring(0, file.getOriginalFilename().indexOf("."));
String str2 = file.getOriginalFilename().substring(str1.length()+1, file.getOriginalFilename().length());
File files = new File(basePath,formatter_RR.format(new Date()) + "." + str2);
FileUtils.copyInputStreamToFile(file.getInputStream(), files);
return files;
}
相同实体类值拷贝:
AdvertisementVo advertisementVo = new AdvertisementVo();
BeanUtils.copyProperties(item, advertisementVo);
list转化成String[]:
List<String> aa = new ArrayList<String>();
String[] urlids = aa.toArray(new String[aa.size()]);
获取总毫秒数:
System.currentTimeMillis();
list对象,根据相同id某些属性值合并或者计算:
public List<AdvertisementUrl> contantData(List<AdvertisementUrl> list) {
HashMap<String, AdvertisementUrl> tempMap = new HashMap<String, AdvertisementUrl>();
for (AdvertisementUrl advertisementUrl : list) {
String temp = advertisementUrl.getAdvertisementBh().toString();
if (tempMap.containsKey(temp)) {
AdvertisementUrl p = new AdvertisementUrl();
BeanUtils.copyProperties(advertisementUrl, p);
p.setAdvertisementUrl(tempMap.get(temp).getAdvertisementUrl() + "," + advertisementUrl.getAdvertisementUrl());
tempMap.put(temp, p);
} else {
tempMap.put(temp, advertisementUrl);
}
}
//去除重复 编号id 的 list
List<AdvertisementUrl> newList = new ArrayList<AdvertisementUrl>();
for (String temp : tempMap.keySet()) {
newList.add(tempMap.get(temp));
}
return newList;
}
复制新的实体类:
DeviceVo dev = SerializationUtils.clone(device);
字符串合并去重:
public String explicitUseStringBuider(String oldString, String newString) {
StringBuilder result = new StringBuilder(oldString);
if(StringUtils.contains(oldString,newString)){
return result.toString();
}
result.append(",");
result.append(newString);
return result.toString();
}
list集合获取所有id组成新list:
List<String> placeNum = placement.stream().map(Placement::getPlacementNum).collect(Collectors.toList());
字符串补充左0:
String normalizeMonth = StringUtils.leftPad(String.valueOf(calendar.get(Calendar.MONTH) + 1), 2, '0');
list集合根据id去重后生成新list:
newList = newList.stream()
.collect(Collectors.toMap(Costcalculationview::getJcid, Function.identity(), (a, b) -> a))
.values()
.stream()
.collect(Collectors.toList());
List<Costcalculationview> distinctMap = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Costcalculationview :: getJcid))), ArrayList::new));