Function<String, String> f = s -> s.substring(2,4);
String apply = f.apply("asdas    asd ");
System.out.println(apply);

Predicate<String> p = t->t.length()>5;
System.out.println(p.test("3223"));
System.out.println(p.test("saf223"));

Consumer<String> consumer = c-> System.out.println("我使用了"+c);
consumer.accept("123");
consumer.accept("456");

Supplier<String> supplier = ()-> UUID.randomUUID().toString();
System.out.println(supplier.get());

Executors.newSingleThreadExecutor();//创建一个只有一个线程的线程池
Executors.newFixedThreadPool();//创建一个固定数目的线程的线程池
Executors.newCachedThreadPool();//缓存池，会复用之前使用过的线程

public static void main(String[] args) {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
        executorService.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
    }
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
    2,
    5,
    3,
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(3),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);

Runtime.getRuntime().availableProcessors()//动态获取cpu核数

public enum UserType {
    /**
     * ORDINARY_VIP: 普通会员
     * SILVER_VIP: 白银会员
     * GOLD_VIP： 黄金会员
     * PLATINUM_VIP：白金会员
     */
    ORDINARY_VIP(1),
    SILVER_VIP(2),
    GOLD_VIP(3),
    PLATINUM_VIP(4);
    private int code;
    UserType(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

private static double getResult(long money, int type){
    double result = money;
    if(money >= 1000){
        if(type == UserType.SILVER_VIP.getCode()){
            result = money - 50;
        }else if(type == UserType.GOLD_VIP.getCode()){
            result = money * 0.8;
        }else if(type == UserType.PLATNUM_VIP.getCode()){
            result = (money - 50)*0.7;
        }
    }
    return result;
}

public static double getResult(long money,int type){
    double result = money;
    if(money<1000){
        return result;
    }
    if(type== UserType.ORDINARY_VIP.getCode()){
        result = new OrdinaryStrategy().compute(money);
    }else if(type == UserType.SILVER_VIP.getCode()){
        result = new SilverStrategy().compute(money);
    }else if(type == UserType.GOLD_VIP.getCode()){
        result = new GoldStrategy().compute(money);
    }else if(type==UserType.PLATINUM_VIP.getCode()){
        result = new PlatinumStrategy().compute(money);
    }
    return result;
}

public interface Strategy {
    double compute(long money);
}

public class OrdinaryStrategy implements Strategy{
    @Override
    public double compute(long money) {
        return money;
    }
}

public class GoldStrategy implements Strategy{
    @Override
    public double compute(long money) {
        return money*0.8;
    }
}

public class PlatinumStrategy implements Strategy{
    @Override
    public double compute(long money) {
        return (money-50)*0.7;
    }
}

public class SilverStrategy implements Strategy{
    @Override
    public double compute(long money) {
        return money-50;
    }
}

public static double getResult(long money,int type){
    double result = money;
    if(money<1000){
        return result;
    }
    if(type== UserType.ORDINARY_VIP.getCode()){
        result = new OrdinaryStrategy().compute(money);
    }else if(type == UserType.SILVER_VIP.getCode()){
        result = new SilverStrategy().compute(money);
    }else if(type == UserType.GOLD_VIP.getCode()){
        result = new GoldStrategy().compute(money);
    }else if(type==UserType.PLATINUM_VIP.getCode()){
        result = new PlatinumStrategy().compute(money);
    }
    return result;
}

public class StrategyFactory {
    public static Map<Integer,Strategy> map;
    private StrategyFactory(){
        map = new HashMap<>();
        init();
    }
    private void init(){
        map.put(UserType.ORDINARY_VIP.getCode(), new OrdinaryStrategy());
        map.put(UserType.SILVER_VIP.getCode(), new SilverStrategy());
        map.put(UserType.GOLD_VIP.getCode(),new GoldStrategy());
        map.put(UserType.PLATINUM_VIP.getCode(),new PlatinumStrategy());
    }
}

public static double getResult(int userType, long money){
    if(money<1000){
        return money;
    }
    if(StrategyFactory.map.get(userType)==null){
        throw new IllegalArgumentException("参数错误，无此类型的用户");
    }
    return map.get(userType).compute(money);
}

public interface Strategy {
    double compute(long money);
    int getType();
}

public class GoldStrategy implements Strategy {
    @Override
    public double compute(long money) {
        return money*0.8;
    }

    @Override
    public int getType() {
        return UserType.GOLD_VIP.getCode();
    }

}

public class OrdinaryStrategy implements Strategy {
    @Override
    public double compute(long money) {
        return money;
    }

    @Override
    public int getType() {
        return UserType.ORDINARY_VIP.getCode();
    }
}

public class PlatinumStrategy implements Strategy {
    @Override
    public double compute(long money) {
        return (money-50)*0.7;
    }

    @Override
    public int getType() {
        return UserType.PLATINUM_VIP.getCode();
    }
}

public class SilverStrategy implements Strategy {
    @Override
    public double compute(long money) {
        return money-50;
    }

    @Override
    public int getType() {
        return UserType.SILVER_VIP.getCode();
    }
}

public class StrategyFactory {
    private static Map<Integer, Strategy> map;

    public StrategyFactory() {
        map=new HashMap<>();
        init();
    }
    private void init() {
        List<Strategy> strategies=new ArrayList<>();
        strategies.add(new GoldStrategy());
        strategies.add(new OrdinaryStrategy());
        strategies.add(new PlatinumStrategy());
        strategies.add(new SilverStrategy());
        map=strategies.stream().collect(Collectors.toMap(Strategy::getType,strategy -> strategy));
    }
}

public static double getResult(int userType, long money){
    if(money<1000){
        return money;
    }
    if(StrategyFactory.map.get(userType)==null){
        throw new IllegalArgumentException("参数错误，无此类型的用户");
    }
    return map.get(userType).compute(money);
}

@GetMapping("/fileDownLoad.do")
public String fileDownLoad(String fileName,HttpServletRequest req,HttpServletResponse resp) throws IOException {
    String realPath = req.getServletContext().getRealPath("\\download")+"\\";
    File file = new File(realPath.concat(fileName));
    resp.setHeader("Content-disposition","attachment; filename="+ URLEncoder.encode(file.getName(),"UTF-8"));
    ServletOutputStream outputStream = resp.getOutputStream();
    FileInputStream fis = new FileInputStream(file);
    byte[] buffer = new byte[1024];
    int len=0;
    while((len=fis.read(buffer))>0){
        outputStream.write(buffer,0,len);
    }
    outputStream.flush();
    fis.close();
    outputStream.close();
    return "filedownload";
}

@PostMapping("/singleFileUpload.do")
public String singleFileUploadDo(@RequestParam(value = "avatar",required = false) CommonsMultipartFile avatar,HttpServletRequest req, Model model) throws IOException {
    //真实的保存上传文件的文件夹
    String realSaveDirPath = req.getSession().getServletContext().getRealPath("/upload");
    File dir = new File(realSaveDirPath);
    if(!dir.exists()){
        dir.mkdirs();
    }
    //文件的全称，包括后缀
    String avatarWholeName = avatar.getOriginalFilename();
    //文件的后缀
    String suffix = avatarWholeName.substring(avatarWholeName.lastIndexOf('.')+1);
    //这里可以对文件后缀做出一些逻辑处理，这里就不作处理了
    //这里为了保证文件名一定不一致，所以加入一个UUID随机值
    String uuidPath = UUID.randomUUID().toString().replaceAll("-","");
    String realFileName = uuidPath.concat(avatarWholeName);
    //文件的真实保存全路径
    String realSavePath = realSaveDirPath.concat("/").concat(realFileName);
    //这里也可以自己用流读写
    avatar.transferTo(new File(realSavePath));
    return "singleFileUpload";
}

@PostMapping("/multiFileUpload.do")
public String multiFileUploadDo(@RequestParam(value = "file",required = false) CommonsMultipartFile[] files,HttpServletRequest req, Model model) throws IOException {
    //真实的保存上传文件的文件夹
    String realSaveDirPath = req.getSession().getServletContext().getRealPath("/upload/multipart");
    File dir = new File(realSaveDirPath);
    if(!dir.exists()){
        dir.mkdirs();
    }
    for (int i = 0; i < files.length; i++) {
        //文件的全称，包括后缀
        String avatarWholeName = files[i].getOriginalFilename();
        //文件的后缀
        String suffix = avatarWholeName.substring(avatarWholeName.lastIndexOf('.')+1);
        //这里可以对文件后缀做出一些逻辑处理，这里就不作处理了
        //这里为了保证文件名一定不一致，所以加入一个UUID随机值
        String uuidPath = UUID.randomUUID().toString().replaceAll("-","");
        String realFileName = uuidPath.concat(avatarWholeName);
        //文件的真实保存全路径
        String realSavePath = realSaveDirPath.concat("/").concat(realFileName);
        //这里也可以自己用流读写
        files[i].transferTo(new File(realSavePath));
    }
    return "multiFileUpload";
}

@PostMapping("/multiFileUpload.do")
public Map multiFileUploadDo(HttpServletRequest request) throws IOException {
    String realPath = request.getServletContext().getRealPath("\\multipartUpload")+"\\";
    CommonsMultipartResolver cmr = new CommonsMultipartResolver(request.getServletContext());
    if(cmr.isMultipart(request)){
        MultipartHttpServletRequest req = (MultipartHttpServletRequest) request;
        MultiValueMap<String, MultipartFile> multiFileMap = req.getMultiFileMap();
        for (String fieldName : multiFileMap.keySet()) {
            String uuidPath = UUID.randomUUID().toString().replaceAll("-","");
            //创建存放文件的文件夹
            File dir = new File(realPath + uuidPath + fieldName);
            dir.mkdirs();
            List<MultipartFile> multipartFiles = multiFileMap.get(fieldName);
            for (MultipartFile f : multipartFiles) {
                //如果文件为空，则忽略，不然会报错
                if(!f.isEmpty()){
                    f.transferTo(new File(dir.getPath()+"\\"+f.getOriginalFilename()));
                }
            }
        }
    }
    return "multiFileUpload";
}

@PostMapping("/reg.do")
@ResponseBody
public Map reg(User user,String relativePath){
    user.setAvatarUrl("\\upload\\".concat(relativePath));
    HashMap<String, String> map = new HashMap<>();
    System.out.println(user);
    map.put("result","success");
    return map;
}

@PostMapping("/singleFileUpload.do")
@ResponseBody
public Map singleFileUploadDo(@RequestParam(value = "avatar",required = false)CommonsMultipartFile avatar,
                              HttpServletRequest req) throws IOException {
    Map<String, String> map = new HashMap<>();
    if(avatar==null||avatar.isEmpty()){
        map.put("result","fail");
        return map;
    }
    //真实的保存上传文件的文件夹
    String realSaveDirPath = req.getSession().getServletContext().getRealPath("/upload");
    File dir = new File(realSaveDirPath);
    if(!dir.exists()){
        dir.mkdirs();
    }
    //文件的全称，包括后缀
    String avatarWholeName = avatar.getOriginalFilename();
    //文件的后缀
    String suffix = avatarWholeName.substring(avatarWholeName.lastIndexOf('.')+1);
    //这里可以对文件后缀做出一些逻辑处理，这里就不作处理了
    //这里为了保证文件名一定不一致，所以加入一个UUID随机值
    String uuidPath = UUID.randomUUID().toString().replaceAll("-","");
    String realFileName = uuidPath.concat(avatarWholeName);
    //文件的真实保存全路径
    String realSavePath = realSaveDirPath.concat("/").concat(realFileName);
    //这里也可以自己用流读写
    avatar.transferTo(new File(realSavePath));
    map.put("result","success");
    //用来给页面显示图片
    map.put("relativePath","\\upload\\".concat(realFileName));
    //用来给前端判断是否需要再次上传
    map.put("fileName",avatarWholeName);
    return map;
}