javaCode

1、instanceof

result instanceof R

检查变量result的类型是否为R或其子类的实例。如果是，则返回true，否则返回false。instanceof关键字用于判断一个对象是否属于某个特定的类或接口的实例。

2、aop实现步骤

1. 引入AOP依赖： 首先，在项目中引入AOP框架的相关依赖，比如在Java的Spring框架中，可以使用Spring AOP。

2. 定义切面（Aspect）： 创建一个Java类，这个类就是切面，用来包含横切关注点（如日志记录、事务管理等）的代码逻辑。切面类通常使用注解 @Aspect 标记，并包含各种通知（advice）方法，如前置通知、后置通知、异常通知等。

3. 配置切点（Pointcut）： 切点定义了在哪些连接点（Join Point）上应用切面的逻辑。连接点是程序执行过程中能够插入切面的点，比如方法调用、异常处理等。可以使用注解 @Pointcut 来定义切点表达式，以匹配符合条件的连接点。

4. 编写通知（Advice）： 在切面类中编写各种通知方法，用来描述切面的具体行为。通知包括前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）等。

5. 织入（Weaving）： 织入是将切面逻辑应用到目标对象的过程。可以通过编译时织入、类加载时织入或者运行时动态代理等方式来实现织入。

6. 配置AOP： 在配置文件（如Spring配置文件）中配置AOP相关的内容，包括指定切面类、切点表达式、通知类型等。

7. 测试AOP功能： 编写测试代码，验证AOP功能是否正常工作，比如调用被切入的方法，观察AOP切面的行为是否按预期执行。

   package com.example.demo;
   
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.Pointcut;
   import org.springframework.stereotype.Component;
   
   @Aspect
   @Component
   public class LoggingAspect {
   
       @Pointcut("execution(* com.example.demo.CalculatorService.*(..))")
       public void calculatorMethods() {}
   
       @Before("calculatorMethods()")
       public void logBeforeMethodExecution() {
           System.out.println("调用方法前记录日志：" + System.currentTimeMillis());
       }
   }
   

   3、enum

   public enum ResponseEnum {
       SUCCESS("0", "操作成功"),
       FAIL("1", "操作失败"),
   
       private String code;
       private String name;
   
       ResponseEnum(String code, String name) {
           this.code = code;
           this.name = name;
       }
   
       public String getCode() {
           return code;
       }
   
       public void setCode(String code) {
           this.code = code;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   }

   4、日期工具

   public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
   
       private static final FastDateFormat[] FORMAT = new FastDateFormat[]{
               FastDateFormat.getInstance("yyyyMM"),
               FastDateFormat.getInstance("yyyy-MM-dd"),
               FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss"),
               FastDateFormat.getInstance("yyyy-MM-dd HH:mm"),
               FastDateFormat.getInstance("HH:mm"),
               FastDateFormat.getInstance("yyyyMMddHHmmss"),
               FastDateFormat.getInstance("HH:mm:ss"),
               FastDateFormat.getInstance("yyyy-MM"),
               FastDateFormat.getInstance("yyyy/MM/dd"),
               FastDateFormat.getInstance("yyyyMMdd")
       } ;
   
       /**
        * 将日期格式化
        * @param date
        * @return
        */
       public static String format(Date date, int idx) {
           PreconditonsEx.checkArgument(idx < FORMAT.length, ResponseEnum.EXCEPTION.getCode(), "时间转换idx越界！");
           PreconditonsEx.checkArgument(date != null, ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！");
           return FORMAT[idx].format(date) ;
       }
   
       /**
        * 将字符串转日期
        * @param date
        */
       public static Date parse(String date, int idx) {
           PreconditonsEx.checkArgument(idx < FORMAT.length, ResponseEnum.EXCEPTION.getCode(), "时间转换idx越界！");
           PreconditonsEx.checkArgument(StringUtils.isNotBlank(date), ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！");
           try {
               return FORMAT[idx].parse(date) ;
           } catch (Exception e) {
               throw new BizException( ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！") ;
           }
       }
   
       /**
        * 获取日期的年份
        * @param date
        * @return
        */
       public static int getYear(Date date){
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(date);
           int year = calendar.get(Calendar.YEAR);
           return year;
       }
   
       /**
        * 时间相减
        * @param fromDate
        * @param toDate
        * @return
        */
       public static long sub(Date fromDate, Date toDate) {
           long res = fromDate.getTime() - toDate.getTime() ;
           return res > 0 ? res/1000 : 0 ;
       }
   
   
       /**
        * 判断两个时间段是否重叠
        * https://blog.csdn.net/SakuyaM/article/details/107022611
        * @param slot1
        * @param slot2
        * @return
        */
       public static boolean overlapped(TimeSlot slot1, TimeSlot slot2) {
           TimeSlot previous, next;
           previous = slot1.startTime.isBefore(slot2.startTime) ? slot1 : slot2;
           next = slot2.startTime.isAfter(slot1.startTime) ? slot2 : slot1;
           // 这里业务需要，允许时间点的重叠
           // 例如某个时间段的起始时间：2020-06-29 00:00:00
           // 和另一个时间段的终止时间：2020-06-29 00:00:00
           // 它们俩可以有交点。如果不需要这种逻辑只把le改成lt
           // ，ge改成gt就可
           return !(le(previous, next) || ge(previous, next));
       }
   
       /**
        * 构造一个时间段
        * @param startTime
        * @param endTime
        * @return
        */
       public static TimeSlot buildSlot(LocalDateTime startTime, LocalDateTime endTime) {
           return new TimeSlot(startTime, endTime);
       }
   
       /**
        * less equal
        * 小于等于
        * @param prev
        * @param next
        * @return
        */
       private static boolean le(TimeSlot prev, TimeSlot next) {
           return lt(prev, next) || next.endTime.isEqual(prev.startTime);
       }
   
       /**
        * greater equal
        * 大于等于
        * @param prev
        * @param next
        * @return
        */
       private static boolean ge(TimeSlot prev, TimeSlot next) {
           return gt(prev, next) || prev.endTime.isEqual(next.startTime);
       }
   
       /**
        * greater than
        * 大于
        * @param prev
        * @param next
        * @return
        */
       private static boolean gt(TimeSlot prev, TimeSlot next) {
           return prev.endTime.isBefore(next.startTime);
       }
   
       /**
        * less than
        * 小于
        * @param prev
        * @param next
        * @return
        */
       private static boolean lt(TimeSlot prev, TimeSlot next) {
           return next.endTime.isBefore(prev.startTime);
       }
   
       /**
        * 时间段类
        */
       @Data
       static class TimeSlot{
           private LocalDateTime startTime;
           private LocalDateTime endTime;
   
           public TimeSlot(LocalDateTime startTime, LocalDateTime endTime) {
               if (startTime.isAfter(endTime)) {
                   this.startTime = endTime;
                   this.endTime = startTime;
               } else {
                   this.startTime = startTime;
                   this.endTime = endTime;
               }
           }
       }
   
       /**
        * Date-localDate
        * @param date
        * @return
        */
       public static LocalDate dateToLocalDate(Date date) {
           return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
       }
   }

   import lombok.Data;
   import org.apache.commons.lang3.time.FastDateFormat;
   
   import java.text.ParseException;
   import java.text.SimpleDateFormat;
   import java.time.LocalDateTime;
   import java.util.*;
   
   
   public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
   
       private static final FastDateFormat[] FORMAT = new FastDateFormat[]{
               FastDateFormat.getInstance("yyyyMM"),
               FastDateFormat.getInstance("yyyy-MM-dd"),
               FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss"),
               FastDateFormat.getInstance("yyyy-MM-dd HH:mm"),
               FastDateFormat.getInstance("HH:mm"),
               FastDateFormat.getInstance("yyyyMMddHHmmss"),
               FastDateFormat.getInstance("HH:mm:ss"),
               FastDateFormat.getInstance("yyyy-MM"),
               FastDateFormat.getInstance("yyyy/MM/dd"),
               FastDateFormat.getInstance("yyyyMMdd")
       } ;
   
       /**
        * 将日期格式化
        * @param date
        * @return
        */
       public static String format(Date date, int idx) {
           PreconditonsEx.checkArgument(idx < FORMAT.length, ResponseEnum.EXCEPTION.getCode(), "时间转换idx越界！");
           PreconditonsEx.checkArgument(date != null, ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！");
           return FORMAT[idx].format(date) ;
       }
   
       /**
        * 将字符串转日期
        * @param date
        */
       public static Date parse(String date, int idx) {
           PreconditonsEx.checkArgument(idx < FORMAT.length, ResponseEnum.EXCEPTION.getCode(), "时间转换idx越界！");
           PreconditonsEx.checkArgument(StringUtils.isNotBlank(date), ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！");
           try {
               return FORMAT[idx].parse(date) ;
           } catch (Exception e) {
               throw new BizException( ResponseEnum.EXCEPTION.getCode(), "时间不允许为空！") ;
           }
       }
   
       /**
        * 获取日期的年份
        * @param date
        * @return
        */
       public static int getYear(Date date){
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(date);
           int year = calendar.get(Calendar.YEAR);
           return year;
       }
   
       /**
        * 获取日期的年份
        * @param date
        * @return
        */
       public static int getMonth(Date date){
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(date);
           return calendar.get(Calendar.MONTH)+1;
       }
       /**
        * 获取日期的年份
        * @param date
        * @return
        */
       public static int getDay(Date date){
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(date);
           return calendar.get(Calendar.DATE);
       }
       /**
        * 时间相减
        * @param fromDate
        * @param toDate
        * @return
        */
       public static long sub(Date fromDate, Date toDate) {
           long res = fromDate.getTime() - toDate.getTime() ;
           return res > 0 ? res/1000 : 0 ;
       }
   
   
       /**
        * 判断两个时间段是否重叠
        * https://blog.csdn.net/SakuyaM/article/details/107022611
        * @param slot1
        * @param slot2
        * @return
        */
       public static boolean overlapped(TimeSlot slot1, TimeSlot slot2) {
           TimeSlot previous, next;
           previous = slot1.startTime.isBefore(slot2.startTime) ? slot1 : slot2;
           next = slot2.startTime.isAfter(slot1.startTime) ? slot2 : slot1;
           // 这里业务需要，允许时间点的重叠
           // 例如某个时间段的起始时间：2020-06-29 00:00:00
           // 和另一个时间段的终止时间：2020-06-29 00:00:00
           // 它们俩可以有交点。如果不需要这种逻辑只把le改成lt
           // ，ge改成gt就可
           return !(le(previous, next) || ge(previous, next));
       }
   
       /**
        * 构造一个时间段
        * @param startTime
        * @param endTime
        * @return
        */
       public static TimeSlot buildSlot(LocalDateTime startTime, LocalDateTime endTime) {
           return new TimeSlot(startTime, endTime);
       }
   
       /**
        * less equal
        * 小于等于
        * @param prev
        * @param next
        * @return
        */
       private static boolean le(TimeSlot prev, TimeSlot next) {
           return lt(prev, next) || next.endTime.isEqual(prev.startTime);
       }
   
       /**
        * greater equal
        * 大于等于
        * @param prev
        * @param next
        * @return
        */
       private static boolean ge(TimeSlot prev, TimeSlot next) {
           return gt(prev, next) || prev.endTime.isEqual(next.startTime);
       }
   
       /**
        * greater than
        * 大于
        * @param prev
        * @param next
        * @return
        */
       private static boolean gt(TimeSlot prev, TimeSlot next) {
           return prev.endTime.isBefore(next.startTime);
       }
   
       /**
        * less than
        * 小于
        * @param prev
        * @param next
        * @return
        */
       private static boolean lt(TimeSlot prev, TimeSlot next) {
           return next.endTime.isBefore(prev.startTime);
       }
   
       /**
        * 时间段类
        */
       @Data
       static class TimeSlot{
           private LocalDateTime startTime;
           private LocalDateTime endTime;
   
           public TimeSlot(LocalDateTime startTime, LocalDateTime endTime) {
               if (startTime.isAfter(endTime)) {
                   this.startTime = endTime;
                   this.endTime = startTime;
               } else {
                   this.startTime = startTime;
                   this.endTime = endTime;
               }
           }
       }
   
       /**
        * 获得当日0点
        *
        * @author shijian
        *
        */
       public static Date getZero() {
           Date result = null;
           try {
               Calendar calendar = Calendar.getInstance();
               calendar.setTime(new Date());
               calendar.set(Calendar.HOUR_OF_DAY, 0);
               calendar.set(Calendar.MINUTE, 0);
               calendar.set(Calendar.SECOND, 0);
               result = calendar.getTime();
           } catch (Exception e) {
              LogUtils.error("获取当日0点时间异常",e);
           }
           return result;
   
       }
   
       /**
        * 获得当日最后时间
        *
        * @author shijian
        *
        */
       public static Date getEnd(){
           Date result = null;
           try {
               Calendar calendar = Calendar.getInstance();
               calendar.setTime(new Date());
               calendar.set(Calendar.HOUR_OF_DAY, 23);
               calendar.set(Calendar.MINUTE, 59);
               calendar.set(Calendar.SECOND, 59);
               result = calendar.getTime();
           } catch (Exception e) {
               LogUtils.error("获取当日0点时间异常",e);
           }
           return result;
   
       }
   
       // 返回时间格式如：2020-02-17 00:00:00
       public static Date getStartOfDay(Date time) {
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(time);
           calendar.set(Calendar.HOUR_OF_DAY, 0);
           calendar.set(Calendar.MINUTE, 0);
           calendar.set(Calendar.SECOND, 0);
           calendar.set(Calendar.MILLISECOND, 0);
           return calendar.getTime();
       }
       // 返回时间格式如：2020-02-19 23:59:59
       public static Date getEndOfDay(Date time) {
           Calendar calendar = Calendar.getInstance();
           calendar.setTime(time);
           calendar.set(Calendar.HOUR_OF_DAY, 23);
           calendar.set(Calendar.MINUTE, 59);
           calendar.set(Calendar.SECOND, 59);
           calendar.set(Calendar.MILLISECOND, 999);
           return calendar.getTime();
       }
   
       /**
        * 离职短信从此日期开始
        * @return
        */
       public static Date getQuitMessageInitTime(){
           Calendar calendar = Calendar.getInstance();
           calendar.set(2022,5,29);
           calendar.set(Calendar.HOUR_OF_DAY, 0);
           calendar.set(Calendar.MINUTE, 0);
           calendar.set(Calendar.SECOND, 0);
           return calendar.getTime();
       }
   
   
       public static List<Date> getQuarterToDate(int year,int quarter){
           List<Date> list = new ArrayList<>();
           String startDate = "";
           String endDate = "";
           if (quarter == 1){
               startDate = year+"-01-01";
               endDate = year+"-03-31";
           }
           if (quarter == 2){
               startDate = year+"-04-01";
               endDate = year+"-06-30";
           }
           if (quarter == 3){
               startDate = year+"-07-01";
               endDate = year+"-09-30";
           }
           if (quarter == 4){
               startDate = year+"-10-01";
               endDate = year+"-12-31";
           }
           list.add(parse(startDate,1));
           list.add(parse(endDate,1));
           return list;
       }
   
       /**
        * 将CST的时间字符串转换成日期格式字符串
        * @param cst
        * @return
        * @throws ParseException
        */
       public static Date getCstToDate(String cst){
           SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
           try {
               return sdf.parse(cst);
           } catch (ParseException e) {
               e.printStackTrace();
           }
           return null;
       }
   
       /**
        * 获取开始日期 和 结束日期的时间差
        * @param startDate
        * @param endDate
        * @return
        */
       public static long getDateInterval(String startDate,String endDate){
           if (StringUtils.isNotEmpty(startDate) && StringUtils.isNotEmpty(endDate)){
               Date start = parse(startDate, 1);
               Date end = parse(endDate, 1);
               long l = (end.getTime() - start.getTime() + 1000000) / (60 * 60 * 24 * 1000);
               if (l < 0){
                   return (start.getTime() - end.getTime() + 1000000) / (60 * 60 * 24 * 1000);
               }
               return l;
           }
           return -1;
       }
   
       /**
        * 获取量时间差
        * @param startDate
        * @param endDate
        * @return
        */
       public static long getDatePoor(String startDate,String endDate){
           if (StringUtils.isNotEmpty(startDate) && StringUtils.isNotEmpty(endDate)){
               Date start = parse(startDate, 1);
               Date end = parse(endDate, 1);
               return (end.getTime() - start.getTime() + 1000000) / (60 * 60 * 24 * 1000);
           }
           return -1;
       }
   
       /**
        * 获取开始日期 和 结束日期的时间差
        * @param startDate
        * @param endDate
        * @return
        */
       public static long getDateInterval(Date startDate,Date endDate){
           if (startDate != null && endDate != null){
               Date start = parse(format(startDate, 1), 1);
               Date end = parse(format(endDate, 1), 1);
               long l = (end.getTime() - start.getTime() + 1000000) / (60 * 60 * 24 * 1000);
               if (l < 0){
                   return (start.getTime() - end.getTime() + 1000000) / (60 * 60 * 24 * 1000);
               }
               return l;
           }
           return -1;
       }
   
       /**
        * 根据出生年月日计算年龄
        * @param birthday
        * @return
        */
       public static int getAgeByBirth(Date birthday){
   
           //获取当前时间
           Calendar cal = Calendar.getInstance();
   
           //获取出生日期的Calendar对象
           Calendar bir = Calendar.getInstance();
           bir.setTime(birthday);
           //如果出生日期大于当前日期，则返回0
           if(cal.before(birthday)){
               return 0;
           }
           //取出当前年月日
           int nowYear = cal.get(Calendar.YEAR);
           int nowMonth = cal.get(Calendar.MONTH);
           int nowDay = cal.get(Calendar.DAY_OF_MONTH);
   
           //取出出生日期的年月日
           int birthYear = bir.get(Calendar.YEAR);
           int birthMonth = bir.get(Calendar.MONTH);
           int birthDay = bir.get(Calendar.DAY_OF_MONTH);
   
           //计算年份
           int age = nowYear - birthYear;
   
           //计算月份和日，看看是否大于当前月日，如果小于则减去一岁
           if(nowMonth < birthMonth || (nowMonth == birthMonth && nowDay < birthDay)){
               age--;
           }
           return age;
       }
   
       public static void main(String[] args) {
   
   
       }
   
   }

8. 5、邮件email

   @Component
   @ConfigurationProperties(prefix="email")
   public class EmaiUtil {
       private MimeMessage mimeMsg; // MIME邮件对象
       private Session session; // 邮件会话对象
       private Properties props; // 系统属性
       private boolean needAuth = true; // smtp是否需要认证
       private String username = ""; // smtp认证用户名和密码
       private String password = "";
       private Multipart mp; // Multipart对象,邮件内容,标题,附件等内容均添加到其中后再生成MimeMessage对象
   
       private static String address;
       private static String accountNo ;
       private static String pwd ;
       private static String server;
   
       public String getAddress() {
           return address;
       }
   
       public void setAddress(String address) {
           this.address = address;
       }
   
       public String getAccountNo() {
           return accountNo;
       }
   
       public void setAccountNo(String accountNo) {
           this.accountNo = accountNo;
       }
   
       public String getPwd() {
           return pwd;
       }
   
       public void setPwd(String pwd) {
           this.pwd = pwd;
       }
   
       public String getServer() {
           return server;
       }
   
       public void setServer(String server) {
           this.server = server;
       }
   
       /**
        *
        */
       public EmaiUtil() {
           setSmtpHost("");// 如果没有指定邮件服务器,就从getConfig类中获取
           createMimeMessage();
       }
   
       /**
        * @param smtp smtp
        */
       public EmaiUtil(String smtp) {
           setSmtpHost(smtp);
           createMimeMessage();
       }
   
       /**
        * @param hostName hostName
        */
       public void setSmtpHost(String hostName) {
           if(props == null) {
               props = System.getProperties(); // 获得系统属性对象
           }
           props.put("mail.smtp.host", hostName); // 设置SMTP主机
       }
   
       /**
        * @return boolean
        */
       public boolean createMimeMessage() {
           try {
               session = Session.getDefaultInstance(props, null); // 获得邮件会话对象
           } catch(Exception e) {
               System.err.println("获取邮件会话对象时发生错误！" + e);
               return false;
           }
           try {
               mimeMsg = new MimeMessage(session);
               mp = new MimeMultipart();
               return true;
           } catch(Exception e) {
               System.err.println("创建MIME邮件对象失败！" + e);
               return false;
           }
       }
   
       /**
        * @param need need
        */
       public void setNeedAuth(boolean need) {
           this.needAuth = need;
           if(props == null) {
               props = System.getProperties();
           }
           if(this.needAuth) {
               props.put("mail.smtp.auth", "true");
               props.put("mail.smtp.timeout", "50000");
           } else {
               props.put("mail.smtp.auth", "false");
               props.put("mail.smtp.timeout", "50000");
           }
       }
   
       /**
        * @param name name
        * @param pass pass
        */
       public void setNamePass(String name, String pass) {
           username = name;
           password = pass;
       }
   
       /**
        * @param mailSubject mailSubject
        * @return boolean
        */
       public boolean setSubject(String mailSubject) {
           try {
               mimeMsg.setSubject(mailSubject);
               return true;
           } catch(Exception e) {
               System.err.println("设置邮件主题发生错误！");
               return false;
           }
       }
   
       /**
        * @param mailBody mailSubject
        * @return boolean
        */
       public boolean setBody(String mailBody) {
           try {
               BodyPart bp = new MimeBodyPart();
               bp.setContent("" + mailBody, "text/html;charset=GB2312");
               mp.addBodyPart(bp);
               return true;
           } catch(Exception e) {
               System.err.println("设置邮件正文时发生错误！" + e);
               return false;
           }
       }
   
       /**
        * @param filename mailSubject
        * @return boolean
        */
       public boolean addFileAffix(String filename) {
           try {
               BASE64Encoder enc = new BASE64Encoder();
               BodyPart bp = new MimeBodyPart();
               FileDataSource fileds = new FileDataSource(filename);
               bp.setDataHandler(new DataHandler(fileds));
               bp.setFileName("=?GBK?B?" + enc.encode((fileds.getName()).getBytes("GBK")) + "?=");
               mp.addBodyPart(bp);
               return true;
           } catch(Exception e) {
               System.err.println("增加邮件附件：" + filename + "发生错误！" + e);
               return false;
           }
       }
   
       /**
        * @param from from
        * @return boolean
        */
       public boolean setFrom(String from) {
           try {
               mimeMsg.setFrom(new InternetAddress(from)); // 设置发信人
               return true;
           } catch(Exception e) {
               return false;
           }
       }
   
       /**
        * @param to to
        * @return boolean
        */
       public boolean setTo(String to) {
           if(to == null) {
               return false;
           }
           try {
               mimeMsg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(to));
               return true;
           } catch(Exception e) {
               return false;
           }
       }
   
       /**
        * @param copyto copyto
        * @return boolean
        */
       public boolean setCopyTo(String copyto) {
           if(copyto == null) {
               return false;
           }
           try {
               mimeMsg.setRecipients(Message.RecipientType.CC, (Address[]) InternetAddress.parse(copyto));
               return true;
           } catch(Exception e) {
               return false;
           }
       }
   
       /**
        * @return boolean
        */
       public boolean sendout() {
           try {
               mimeMsg.setContent(mp);
               mimeMsg.saveChanges();
               Session mailSession = Session.getInstance(props, null);
               Transport transport = mailSession.getTransport("smtp");
               transport.connect((String) props.get("mail.smtp.host"), username, password);
               transport.sendMessage(mimeMsg, mimeMsg.getRecipients(Message.RecipientType.TO));
               transport.close();
               return true;
           } catch(Exception e) {
               System.err.println("邮件发送失败！" + e);
               return false;
           }
       }
   
       /**
        * @return 发送所有邮件人与抄送
        */
       public boolean sendoutAll() {
           try {
               mimeMsg.setContent(mp);
               mimeMsg.saveChanges();
               Session mailSession = Session.getInstance(props, null);
               Transport transport = mailSession.getTransport("smtp");
               transport.connect((String) props.get("mail.smtp.host"), username, password);
               transport.sendMessage(mimeMsg, mimeMsg.getAllRecipients());
               transport.close();
               return true;
           } catch(Exception e) {
               System.err.println("邮件发送失败！" + e);
               return false;
           }
       }
   
       /**
        * @param subject subject
        * @param body Body
        * @param attach attach
        * @param to to
        * @return boolean
        */
       public static boolean sendMail(String subject, String body, String attach, String to) {
           String smtp = "10.8.0.25";
           EmaiUtil themail = new EmaiUtil(smtp);
           themail.setNeedAuth(false);
           if(themail.setSubject(subject) == false) {
               return false;
           }
           if(themail.setBody(body) == false) {
               return false;
           }
           if(themail.setTo(to) == false) {
               return false;
           }
           if(themail.setFrom("koaadmin@yutong.com") == false) {
               return false;
           }
           
           if(attach != null && attach.trim().length() > 0) 
               if(themail.addFileAffix(attach) == false) {
                   return false;
               }
           if(themail.sendout() == false) {
               return false;
           }
           return true;
       }
   
       /**
        * @param subject 主题
        * @param body 内容
        * @param attach 附件
        * @param to 收信人
        * @param cc 抄送
        * @return boolean
        */
       public static boolean sendMailWithCC(String subject, String body, String attach, String to, String cc) {
           String smtp = "10.8.0.25";
           EmaiUtil themail = new EmaiUtil(smtp);
           themail.setNeedAuth(false);
           if(themail.setSubject(subject) == false) {
               return false;
           }
           if(themail.setBody(body) == false) {
               return false;
           }
           if(themail.setTo(to) == false) {
               return false;
           }
           if(themail.setCopyTo(cc) == false) {
               return false;
           }
           if(themail.setFrom("koaadmin@yutong.com") == false) {
               return false;
           }
           if(attach != null && attach.trim().length() > 0) 
               if(themail.addFileAffix(attach) == false) {
                   return false;
               }
           if(themail.sendoutAll() == false) {
               return false;
           }
           return true;
       }
   
       /**
        * @param subject subject
        * @param body Body
        * @param attach attach
        * @param to to
        * @return boolean
        */
       public static boolean sendMailCustom(String subject, String body, String attach, String to) {
           String smtp = "10.8.0.25";
           EmaiUtil themail = new EmaiUtil(smtp);
           themail.setNeedAuth(true);
           if(themail.setSubject(subject) == false) {
               return false;
           }
           if(themail.setBody(body) == false) {
               return false;
           }
           if(themail.setTo(to) == false) {
               return false;
           }
           if(themail.setFrom("SERV@yutong.com") == false) {
               return false;
           }
           
           if(attach != null && attach.trim().length() > 0) 
               if(themail.addFileAffix(attach) == false) {
                   return false;
               }
           themail.setNamePass("ygwtf", "123456");
           if(themail.sendout() == false) {
               return false;
           }
           return true;
       }
       /**
        * Just do it as this
        *
        * @param args args
        */
       public static void main(String[] args) {
   //        send(Constant.MAIL_ADDRESS, "obmsender@yutong.com", "标题", "<b>内容</b>");
   //        System.out.println(sendMail("scmadmin@yutong.com", "fadsssssssssssssssssssssss", "", "gengyd@yutong.com"));
           /*StringBuffer mailContent = new StringBuffer();
           mailContent.append("尊敬的<u>028</u>供应商<br>");
           mailContent.append("&nbsp;&nbsp;&nbsp;&nbsp;我司在<u>2014.02.02</u>向贵公司采购了<u>");
               
           mailContent.append("8103-13884（空格）空调总成,左四4P,6932HG@松芝LPP-III/F-DS</u>");
           mailContent.append("根据双方友好签订的商务合作要求，请贵公司在<u>2014.04.04</u>日之前，通过该");
           mailContent.append("邮件将此物料所属的<u>备件图册/清单、维修手册、保养手册、使用说明书</u>提供给宇通技术中")
               .append("心办公室服务资料模块。");
           mailContent.append("<br>")
               .append("注：一次回复，其附件内容大小不允许超过20M。")
               .append("<br>联系电话0371-66783322");
           sendMailCustom("subject", mailContent.toString(), null, "ygwtf@yutong.com");*/
           //send("ygwtf@yutong.com","test","test");
           System.out.println(RandomUtils.nextInt(0,2));
       }
   
   
       /**
        * 发送简单邮件
        *
        * @param strTo 收件人地址
        * @param strTitle 邮件标题
        * @param strContent 邮件正文
        */
       public static void sendToOne(String strTo, String strTitle, String strContent) {
           try {
               // 建立邮件会话
               Properties props = new Properties(); // 用来在一个文件中存储键-值对的，其中键和值是用等号分隔的，
               // 存储发送邮件服务器的信息
               props.put("mail.smtp.host", server);
               // 同时通过验证
               props.put("mail.smtp.auth", "true");
               // 根据属性新建一个邮件会话
               Session s = Session.getInstance(props);
               s.setDebug(true); // 有他会打印一些调试信息。
               // 由邮件会话新建一个消息对象
               MimeMessage message = new MimeMessage(s);
               // 设置邮件
               InternetAddress from = new InternetAddress(address); // pukeyouxintest2@163.com
               message.setFrom(from); // 设置发件人的地址
               //
               // //设置收件人,并设置其接收类型为TO
               InternetAddress to = new InternetAddress(strTo); // pukeyouxintest3@163.com
               message.setRecipient(Message.RecipientType.TO, to);
               // 设置标题
               message.setSubject(strTitle); // java学习
               // 设置信件内容
               // message.setText(str_content); //发送文本邮件 //你好吗？
               message.setContent(strContent, "text/html;charset=gbk"); // 发送HTML邮件 //<b>你好</b><br><p>大家好</p>
               // 设置发信时间
               message.setSentDate(new Date());
               // 存储邮件信息
               message.saveChanges();
               // 发送邮件
               Transport transport = s.getTransport("smtp");
               // 以smtp方式登录邮箱,第一个参数是发送邮件用的邮件服务器SMTP地址,第二个参数为用户名,第三个参数为密码
               transport.connect(server, accountNo, pwd);
               // 发送邮件,其中第二个参数是所有已设好的收件人地址
               transport.sendMessage(message, message.getAllRecipients());
               transport.close();
           } catch(Exception e) {
               e.printStackTrace();
           }
       }
   
       /**
        * 发送简单邮件
        *
        * @param strTo 收件人地址
        * @param strTitle 邮件标题
        * @param strContent 邮件正文
        */
       public static void sendToMany(String[] strTo, String strTitle, String strContent) {
           try {
               // 建立邮件会话
               Properties props = new Properties(); // 用来在一个文件中存储键-值对的，其中键和值是用等号分隔的，
               // 存储发送邮件服务器的信息
               props.put("mail.smtp.host", server);
               // 同时通过验证
               props.put("mail.smtp.auth", "true");
               // 根据属性新建一个邮件会话
               Session s = Session.getInstance(props);
               s.setDebug(true); // 有他会打印一些调试信息。
               // 由邮件会话新建一个消息对象
               MimeMessage message = new MimeMessage(s);
               // 设置邮件
               InternetAddress from = new InternetAddress(address); // pukeyouxintest2@163.com
               message.setFrom(from); // 设置发件人的地址
               //
               // //设置收件人,并设置其接收类型为TO
               for(String add : strTo){
                   InternetAddress to = new InternetAddress(add); // pukeyouxintest3@163.com
                   message.addRecipient(Message.RecipientType.TO, to);
               }
   
               // 设置标题
               message.setSubject(strTitle); // java学习
               // 设置信件内容
               // message.setText(str_content); //发送文本邮件 //你好吗？
               message.setContent(strContent, "text/html;charset=gbk"); // 发送HTML邮件 //<b>你好</b><br><p>大家好</p>
               // 设置发信时间
               message.setSentDate(new Date());
               // 存储邮件信息
               message.saveChanges();
               // 发送邮件
               Transport transport = s.getTransport("smtp");
               // 以smtp方式登录邮箱,第一个参数是发送邮件用的邮件服务器SMTP地址,第二个参数为用户名,第三个参数为密码
               transport.connect(server, accountNo, pwd);
               // 发送邮件,其中第二个参数是所有已设好的收件人地址
               transport.sendMessage(message, message.getAllRecipients());
               transport.close();
           } catch(Exception e) {
               e.printStackTrace();
           }
       }
   }

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/systemboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
    username: root
    password: 123456
    #邮箱的配置
  mail:
    host: smtp.qq.com #发送邮件服务器
    username: 16133003@qq.com #QQ邮箱
    password: rhilaprdumauejcasd #客户端授权码 注意会失效，qq邮箱生成
    protocol: smtp #发送邮件协议
    #    properties.mail.smtp.port: 587 #端口号465或587
    default-encoding: utf-8
    port: 587

@Component
public class SendEmail {

    @Autowired
    private JavaMailSender javaMailSender;

    @Value("${spring.mail.username}")
    private String fromEmail;

//    @Scheduled(cron = "*/5 * * * * ?")
    public void sendMail() {
        long startTime = System.currentTimeMillis();
        //初始化邮件对象
        SimpleMailMessage mail = new SimpleMailMessage();
        //主题
        mail.setSubject("测试主题");
        //文本
        mail.setText("测试email");
        //发送人
        mail.setFrom(fromEmail);
        //接受人
        mail.setTo("3528306@qq.com");
        javaMailSender.send(mail);
        long endTime = System.currentTimeMillis();
        long mill = (endTime - startTime) / 1000;
        System.out.println("发送邮件耗时：" + mill + "：秒");
    }

}

6、加密解密crypto

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class CryptoExample {
    public static void main(String[] args) throws Exception {
        // 生成对称密钥
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(256); // 设置密钥长度为 256 位
        SecretKey secretKey = keyGenerator.generateKey();

        // 加密
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] encryptedData = cipher.doFinal("Hello, World!".getBytes(StandardCharsets.UTF_8));
        String encryptedText = Base64.getEncoder().encodeToString(encryptedData);
        System.out.println("Encrypted Text: " + encryptedText);

        // 解密
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedText));
        String decryptedText = new String(decryptedData, StandardCharsets.UTF_8);
        System.out.println("Decrypted Text: " + decryptedText);
    }
}

import sun.misc.BASE64Decoder;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


public class AESUtils {

    static String key = "123456.qyxxglc.p";  //16位
    static String iv = "0123456789abcde9";  //16位

    public static void main(String[] args) throws Exception {
        String s = encryptAES("1223f");
        System.out.println(s);
        String s1 = decryptAES(s);
        System.out.println(s1);
    }

    /**
     * 加密
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptAES(String data) throws Exception {

        try {

            Cipher cipher = Cipher.getInstance("AES/CBC/NOPadding");   //参数分别代表 算法名称/加密模式/数据填充方式
            int blockSize = cipher.getBlockSize();

            byte[] dataBytes = data.getBytes();
            int plaintextLength = dataBytes.length;
            if (plaintextLength % blockSize != 0) {
                plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
            }

            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);

            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());

            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);

            return new sun.misc.BASE64Encoder().encode(encrypted);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解密
     * @param data
     * @return
     * @throws Exception
     */
    public static String decryptAES(String data) throws Exception {
        try {
            byte[] encrypted1 = new BASE64Decoder().decodeBuffer(data);

            Cipher cipher = Cipher.getInstance("AES/CBC/NOPadding");
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());

            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);

            byte[] original = cipher.doFinal(encrypted1);
            String originalString = new String(original,"UTF-8");
            return originalString.trim();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

7、xxl-job配置

@Configuration
public class XxlJobConfig {

    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {

        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        //地址
        xxlJobSpringExecutor.setAdminAddresses("http://10.xx.xxx.xx:8080");
        //应用名称
        xxlJobSpringExecutor.setAppname(appName);
        //ip
        xxlJobSpringExecutor.setIp(ip);
        //端口号
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        //日志路径
        xxlJobSpringExecutor.setLogPath("/data/applogs/");
        //日志保留天数
        xxlJobSpringExecutor.setLogRetentionDays(10);

        return xxlJobSpringExecutor;
    }

}


controller
@XxlJob("synInfo")

8、定时任务

@EnableScheduling 开启定时任务

@Scheduled(cron = "*/5 * * * * ?") 5秒

9、动态sql,replace 存在就替换，不存在新增

<insert id="insertBatch" >
        replace into hard_org_info (org_code,org_code_path,org_name,org_name_path,org_parent,rank) values
        <foreach collection="batch" separator="," item="batch">
            (
            #{batch.orgCode},
            #{batch.orgCodePath},
            #{batch.orgName},
            #{batch.orgNamePath},
            #{batch.orgParent},
            #{batch.rank}
            )
        </foreach>
    </insert>

10、定义变量

public class Constants {

    public interface Scope {

        String SCOPE_0 = "0";

        String SCOPE_1 = "1";

        String[] SCOPE_ARR = {"0", "1"};
    }
}


@AllArgsConstructor
@Getter
public enum StateEnum {
    DRAFT(0),
    TRACKING(1),
    CLOSE(2);
    private final int code;
}

11、验证码

        <dependency>
			<groupId>com.google.zxing</groupId>
			<artifactId>core</artifactId>
			<version>3.3.3</version>
		</dependency>

@Configuration
public class KaptchaConfig {

	@Bean
	public DefaultKaptcha producer() {
		Properties properties = new Properties();
		properties.put("kaptcha.border", "no");
		properties.put("kaptcha.textproducer.font.color", "black");
		properties.put("kaptcha.textproducer.char.space", "5");
		Config config = new Config(properties);
		DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
		defaultKaptcha.setConfig(config);
		return defaultKaptcha;
	}

	public static void main(String[] args) {
		KaptchaConfig kaptchaConfig = new KaptchaConfig();
		DefaultKaptcha producer = kaptchaConfig.producer();
		System.out.println(producer.createText());
	}
}

12、开启线程回调

// 开启线程更新订单状态，立马回应微信， 防止重复回调
		ThreadUtil.execute(new Runnable() {
			@Override
			public void run() {
				OrderType orderType = JSON.parseObject(notifyResult.getAttach(), OrderType.class);
				if (OrderTypeConstants.order_room == orderType.getType()) {
					log.info("房间预定，支付成功回调");
					hotelOrderService.updateOrderStatus2Payed(notifyResult.getOutTradeNo());
				}
				if (OrderTypeConstants.order_recharge == orderType.getType()) {
					log.info("进入充值回调");
					hotelRechargeService.cardRechargeHandler(notifyResult.getOutTradeNo(), orderType.getFormId());
				}
				if (OrderTypeConstants.order_becomvip == orderType.getType()) {
					log.info("进入办卡成功回调");
					hotelMemberLevelService.becomeVipCallBack(notifyResult.getOutTradeNo(), orderType.getFormId());
				}
			}
		});

13、explain参数

id：表示查询的序列号。。
select_type：表示查询的类型。常见的值包括 SIMPLE（简单查询）、PRIMARY（主查询）、SUBQUERY（子查询）、DERIVED（派生表查询）等。
type：访问表的方式。常见的值包括 ALL（全表扫描）、index（索引扫描）、range（范围扫描）、ref（基于索引的等值查询）等。
possible_keys：可能用于查询的索引列表。
key：实际选择的索引。
rows：扫描的行数。

14、事务@Transactional参数

@Transactional(readOnly = true)该注解表示被标记的方法或类在事务管理下是只读的，不会对数据库进行修改操作

@Transactional(rollbackFor = {Exception.class, BizException.class}): 这里使用了 Spring 框架的 @Transactional 注解，并指定了在方法执行时遇到 Exception 类型的异常或者 BizException 类型的异常时都要进行事务回滚。

15、springcloud和dubbo

Spring Cloud 是一个用于构建分布式系统的开源框架；

优点：整合丰富的组件（nacos/gateway/Feign）

服务治理全面：Spring Cloud 提供了完善的服务治理功能，包括服务注册与发现、负载均衡、断路器、路由、配置中心等。

服务调用倾向rest风格的http调用；dubbo可以以服务进行调用；

springcloud适用于中小型的项目，dubbo适合大规模的项目；

dubbo:因为它采用了高性能的Netty通信框架，并且使用了二进制传输协议。这使得 Dubbo 在网络通信效率上比 Spring Cloud 更高效;

dubbo不仅支持java语言，也支持php/python等；

16、mysql索引

主键、唯一、普通、全文

全文索引：主要应用于对文本字段进行搜索的场景，比如在文章内容、新闻标题、博客正文等文本数据上进行搜索。

全文索引原理是通过分词器将文本内容分词成单词（或者词组），然后将这些单词作为索引的关键词，建立索引数据结构。当进行全文搜索时，系统会根据关键词进行匹配，并返回符合条件的文本数据。

17、jsonUtils

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.Map;


public class JsonUtils {
    private static final TypeReference<Map<String, Object>> MAP_TYPE_REFERENCE = new TypeReference<Map<String, Object>>(){} ;
    private static final TypeReference<Map<String, String>> MAP_STRING_REFERENCE = new TypeReference<Map<String, String>>(){} ;

    /**
     * 转map
     * @param json
     * @return
     */
    public static Map<String, Object> toMap(String json) {
        return JSON.parseObject(json, MAP_TYPE_REFERENCE) ;
    }

    /**
     * 转map
     * @param json
     * @return
     */
    public static Map<String, String> toMapString(String json) {
        return JSON.parseObject(json, MAP_STRING_REFERENCE) ;
    }

    /**
     * 转List
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> List<T> parseList(String str, Class<T> clazz) {
        return JSON.parseArray(str, clazz) ;
    }

    /**
     * 转String
     * @param obj
     * @return
     */
    public static String toString(Object obj) {
        if(obj == null) {
            return "" ;
        }
        try {
            return JSON.toJSONString(obj) ;
        } catch (Exception e) {
            return "";
        }

    }

    /**
     * json转Object
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T parse(String str, Class<T> clazz) {
        try {
            T result = null ;
            if(StringUtils.isNotBlank(str)) {
                result = JSON.parseObject(str, clazz) ;
            }
            return result ;
        } catch (Exception e) {
            LogUtils.error("Json解析异常", e);
            return null ;
        }
    }

    /**
     * 将字符串解析为Json
     * @param str
     * @return
     */
    public static Object parse(String str) {
        try {
            return JSON.parse(str) ;
        } catch (Exception e) {
            return null ;
        }
    }

}

18、numberUtils

public class NumberUtils {
    private NumberUtils() { }

    /**
     * 中文数字
     */
    private static final String[] CN_NUM = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

    /**
     * 中文数字单位
     */
    private static final String[] CN_UNIT = {"", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};

    /**
     * 特殊字符：负
     */
    private static final String CN_NEGATIVE = "负";

    /**
     * 特殊字符：点
     */
    private static final String CN_POINT = "点";


    /**
     * int 转 中文数字
     * 支持到int最大值
     *
     * @param intNum 要转换的整型数
     * @return 中文数字
     */
    public static String int2chineseNum(int intNum) {
        StringBuffer sb = new StringBuffer();
        boolean isNegative = false;
        if (intNum < 0) {
            isNegative = true;
            intNum *= -1;
        }
        int count = 0;
        while(intNum > 0) {
            sb.insert(0, CN_NUM[intNum % 10] + CN_UNIT[count]);
            intNum = intNum / 10;
            count++;
        }

        if (isNegative)
            sb.insert(0, CN_NEGATIVE);


        return sb.toString().replaceAll("零[千百十]", "零").replaceAll("零+万", "万")
                .replaceAll("零+亿", "亿").replaceAll("亿万", "亿零")
                .replaceAll("零+", "零").replaceAll("零$", "");
    }
}

19、线程池

@EnableAsync
@Configuration //开启扫描@Async注解进行异步操作
public class ThreadPoolConfig {

    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程、最大线程、队列容积、空闲时间
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(100);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("taskExecutor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}



//异步执行任务并指定使用那个线程池
@Async("taskExecutor")
    public void SendEmailToManyAsync(){}

1. AbortPolicy（默认策略）： 如果线程池已满，并且任务队列也已满，而此时有新任务提交，则会立即抛出 RejectedExecutionException 异常，拒绝新任务的提交。

2. CallerRunsPolicy： 如果线程池已满，并且任务队列也已满，而此时有新任务提交，则会使用当前线程（提交任务的线程）来执行被拒绝的任务，这样可以避免任务丢失，但会影响当前线程的性能。

3. DiscardPolicy： 如果线程池已满，并且任务队列也已满，而此时有新任务提交，则会直接丢弃被拒绝的任务，不会抛出任何异常。

4. DiscardOldestPolicy： 如果线程池已满，并且任务队列也已满，而此时有新任务提交，则会丢弃队列中最早（最先进入队列）的任务，并将新任务加入到队列中，然后尝试重新执行被丢弃的任务。

20、输入一个文件名，判断是否存在，存在就拷贝一个文件放在同一个目录下，不存在就不创建

public class test01 {

    //输入一个文件名，判断是否存在，存在就拷贝一个文件放在同一个目录下，不存在就不创建
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入一个文件名");
        String fileName = "D:/boot-demo/"+scanner.next();
        boolean flog = false;

        try {
            flog = copyFile(fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (flog){
            System.out.println("创建失败文件不存在");
        }else {
            System.out.println("创建成功");
        }
    }

    private static File createFile(String fileName) throws IOException {
        File file = new File(fileName);
        if (file.exists()){
            File copyFile = new File(file.getParent() + "/copy_" + file.getName());
            System.out.println(copyFile);

            //创建新文件
            copyFile.createNewFile();
            //返回创建的文件
            return copyFile;
        }else {
            System.out.println("文件不存在");
        }
        return null;
    }

    private static boolean copyFile(String fileName) throws IOException{
        File copyFile = createFile(fileName);
        //判断拷贝是否为空
        if (copyFile == null){
            return false;
        }
        //读取原文件
        InputStream inputStream = new FileInputStream(fileName);
        OutputStream outputStream = new FileOutputStream(copyFile);
        int len=0;
        while ((len = inputStream.read()) !=-1){
            outputStream.write(len);
        }
        inputStream.close();
        outputStream.close();
        return true;
    }

}

21、随机生成10个一百内的数字并存入集合中，并排序输出

public class test02 {

//    随机生成10个一百内的数字并存入集合中，并排序输出

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            Random random = new Random();
            int element = random.nextInt(100);
            list.add(element);
        }
        System.out.println(list);
//        Collections.sort(list);
//        或者
        for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < list.size() - i - 1; j++) {
                if (list.get(j)>list.get(j+1)){
                    int temp = list.get(j);
                    list.set(j,list.get(j+1));
                    list.set(j+1,temp);
                }
            }
        }
        System.out.println(list);
    }
}

22、随机生成20个10位的字符串，有a-z,A-Z,0-9组成，存入容器中，从键盘输入一个字符串，判断是否存在于生成的字符串

public class test03 {
    //随机生成20个10位的字符串，有a-z,A-Z,0-9组成，存入容器中，从键盘输入一个字符串，判断是否存在于生成的字符串

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入字符串：");
        String content = scanner.nextLine();

        String chars="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        System.out.println(chars.length());

        Set<String> list = new HashSet<>();
        StringBuilder sb;
        while (list.size()<100){
             sb= new StringBuilder();
            for (int i = 0; i < 2; i++) {
                int rInt = random.nextInt(62);
                char c = chars.charAt(rInt);

                if (sb.toString().contains(String.valueOf(c))){
                    i--;
                    continue;
                }
                sb.append(c);
            }
            list.add(sb.toString());
        }
        System.out.println("生成的集合："+list);
        if (list.contains(content)){
            System.out.println("字符串存在集合中");
        }else {
            System.out.println("字符串不存在集合中");
        }
    }
}

23、stream流

数组排序1；
public class Main {
		public static void main(String[] args) {
          
      	int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
             System.out.print(a[i] + " ");
        }
    }
}
数组排序2；
public class test01 {
    public static void main(String[] args) {
        int []arr1= {45,34,59,55};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.asList(arr1));
    }
}

集合排序1；
public static void main(String[] args) {
        ArrayList<Integer> list0 = new ArrayList<>();
        list0.add(2);
        list0.add(4);
        list0.add(3);
方法1：
        Collections.sort(list0);
        System.out.println(list0);
方法2：
        List<Integer> sortedList = list0.stream().sorted().collect(Collectors.toList());
        System.out.println(sortedList);
根据对象某个字段排序：
//升序
        
        userList = list0.stream().sorted(Comparator.comparingInt(list0)).collect(Collectors.toList());
//降序
        userList = userList.stream().sorted(Comparator.comparingInt(User::getAge).reversed()).collect(Collectors.toList());
    }

treeMap集合可以自动排序：
Map<String, Integer> map = new HashMap<>();
map.put("c", 3);
map.put("a", 1);
map.put("b", 2);

Map<String, Integer> treeMap = new TreeMap<>(map);
System.out.println(treeMap);


Stream流循环遍历list：
public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("小红");
        list.add("小兰");
        list.stream().forEach(s -> System.out.println("value:"+s));
    }

Stream流循环遍对象：
public static void main(String[] args) {
        List<People> peopleList = new ArrayList<People>();
        peopleList.add(new People("小明",23,new BigDecimal("3000")));
        peopleList.add(new People("小红",24,new BigDecimal("2800")));
        peopleList.add(new People("小兰",22,new BigDecimal("3200")));
        //遍历对象
        peopleList.stream().forEach(s -> System.out.println("value:"+s));
        System.out.println("------------------------------------------------");
        //遍历属性
        peopleList.stream().forEach(s -> System.out.println("value:"+s.getName()));
    }

Stream循环设置值：
peopleList.stream().forEach(s ->{
            if("小明".equals(s.getName())){
                s.setSalary(s.getSalary().add(new BigDecimal("100")));
            }

Stream循环过滤放入新集合：
//查找年龄大于等于23岁的人
        List<People> newPeopleList = peopleList.stream().filter(s ->s.getAge()>=23).collect(Collectors.toList());
        System.out.println("value:"+newPeopleList);

Stream循环多个条件过滤放入新集合：
 //查找年龄大于等于23岁并且工资不低于3000的人
        List<People> newPeopleList = peopleList.stream().filter(s ->{
            if(s.getAge()>=23 && s.getSalary().compareTo(new BigDecimal("3000"))>=0){
                return true;
            }
            return false;
        }).collect(Collectors.toList());
        System.out.println("value:"+newPeopleList);

Stream循环对集合去重放入新集合：
list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("value:"+list);

Stream截取前两个放入新集合：
list = list.stream().limit(2).collect(Collectors.toList());
        System.out.println("value:"+list);

Stream根据对象某个字段排序放入新集合：
//根据年龄从小到大排序
        peopleList =peopleList.stream()
                .sorted(Comparator.comparing(People::getAge))
                .collect(Collectors.toList());
        System.out.println("value:"+peopleList);
        System.out.println("------------------------------------------------");
        //根据年龄从大到小排序
        peopleList =peopleList.stream()
                .sorted(Comparator.comparing(People::getAge).reversed())
                .collect(Collectors.toList());
        System.out.println("value:"+peopleList);


Stream-list转hashMap:
//根据姓名转map
        Map<String, People> map= peopleList.stream()
                .collect(Collectors.toMap(s-> s.getName(), object -> object,(oldValue, newValue) -> newValue));
        System.out.println("value:"+map);

Stream-list转hashMap，map键值都为对象的属性：
//根据姓名转map
        Map<String, Integer> map = peopleList.stream().collect(Collectors.toMap(People::getName
                , People::getAge));
        System.out.println("value:"+map);

//判断集合里面是否超过23岁的人
        boolean flag= peopleList.stream().anyMatch(s -> s.getAge() > 23);
        System.out.println("value:"+flag);
//判断集合里面的人是否全部超过23岁
        boolean flag= peopleList.stream().allMatch(s -> s.getAge() > 23);
        System.out.println("value:"+flag);

//获取对象某个属性存入集合
        List<String> nameList = peopleList.stream().map(s-> s.getName()).collect(Collectors.toList());
        System.out.println("value:"+nameList);

stream循环修改对象值并返回个新对象存入集合：
//对象转对象
        List<Student> studentList = peopleList.stream().map(s->{
            return new Student(s.getName(),s.getAge());
        }).collect(Collectors.toList());
        System.out.println("value:"+studentList);

//获取姓名字符串,逗号隔开
        String name = peopleList.stream().map(s-> s.getName()).collect(Collectors.joining(","));
        System.out.println("value:"+name);



hashMap遍历方法1:
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	map.put(1, 10);
	map.put(2, 20);
	map.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
hashMap遍历方法2：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(1, 10);
		map.put(2, 20);
 
		// 迭代键
		for (Integer key : map.keySet()) {
			System.out.println("Key = " + key);
		}
 
		// 迭代值
		for (Integer value : map.values()) {
			System.out.println("Value = " + value);
		}
hashMap遍历方法3：
//使用带泛型的迭代器进行遍
        Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<Integer, Integer> entry = entries.next();
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        }

24、线程池/线程抢票

public class TicketBookingSystem {
    private static final int TOTAL_TICKETS = 31;
    private static AtomicInteger ticketsBooked = new AtomicInteger(0);
    private static final int THREAD_COUNT = 3;
    private static int currentThread = 1;

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT); // 创建一个固定大小为 3 的线程池
        for (int i = 1; i <= THREAD_COUNT; i++) { // 启动三个线程进行抢票
            Runnable task = new TicketBookingTask(i);
            executor.execute(task);
        }
        executor.shutdown(); // 关闭线程池
    }

//    public static void main(String[] args) {
//        for (int i = 1; i <= 3; i++) {
//            TicketBookingTask ticketBookingTask1 = new TicketBookingTask(i);
//            TicketBookingTask ticketBookingTask2 = new TicketBookingTask(i);
//            TicketBookingTask ticketBookingTask3 = new TicketBookingTask(i);
//
//            Thread thread1 = new Thread(ticketBookingTask1);
//            Thread thread2 = new Thread(ticketBookingTask2);
//            Thread thread3 = new Thread(ticketBookingTask3);
//            thread1.start();
//            thread3.start();
//            thread2.start();
//        }
//    }

    static class TicketBookingTask implements Runnable {
        private int threadId;

        public TicketBookingTask(int threadId) {
            this.threadId = threadId;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (TicketBookingSystem.class) {
                    if (ticketsBooked.get() >= TOTAL_TICKETS) {
                        break; // 所有票已经被抢购完毕，结束任务
                    }

                    if (currentThread == threadId) {
                        int currentTicket = ticketsBooked.incrementAndGet();
                        System.out.println("当前线程 " + threadId + ": 第 " + currentTicket+"张票！");
                        currentThread = (currentThread % THREAD_COUNT) + 1; // 下一个抢票的线程编号
                    }
                }

                try {
                    Thread.sleep(100); // 模拟抢票过程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}