项目中常用写法（Java）

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));