1 ThreadPoolTaskExecutor

  1. @Configuration
  2. @EnableAsync
  3. public class TaskPoolConfig {
  4.     @Bean
  5.     public ThreadPoolTaskExecutor myTaskAsyncPool(){
  6.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
  7.         //核心线程池大小
  8.         executor.setCorePoolSize(20);
  9.         //最大线程数
  10.         executor.setMaxPoolSize(50);
  11.         //队列容量
  12.         executor.setQueueCapacity(30);
  13.         //活跃时间
  14.         executor.setKeepAliveSeconds(60);
  15.         //线程名字前缀
  16.         executor.setThreadNamePrefix("MyExecutor-");
  17.         //当pool已经到达max size的时候，如何处理新任务,CallerRunsPolicy,由调用者所在的线程执行
  18.         executor.setThreadNamePrefix("thread-task-service-");
  19.         executor.initialize();
  20.         return  executor;
  21.     }
  22. }
  23. // 使用
  24. myTaskAsyncPool.execute(() -> {
  25.     // todo...
  27.         });

2 时间转换

  1. /**
  2.  * ----------------------------------------- SimpleDateFormat 线程不安全 --------------------------
  3.  */
  4. SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH");
  5. // String 转 data
  6. Date date1 = simpleDateFormat.parse("2019-09-02 20");
  7. Date date2 = simpleDateFormat.parse("2019-09-02 21");
  8. System.out.println(simpleDateFormat.format(date1));
  9. // 相差几小时
  10. System.out.println((date2.getTime() - date1.getTime())/1000/3600);
  12. // UTC 转 String(data)
  13. Date date = new Date(date2.getTime());
  14. String dareString = simpleDateFormat.format(date);
  15. System.out.println(dareString);
  18. /**
  19.  * ---------------------------------- LocalDateTime 线程安全--------------------------------
  20.  * ---------------------String----TimeStamp----LocalDataTime----LocalData------------------
  21.  */
  22.     public static LocalDateTime stringToLocalDateTime(String dateString, String pattern){
  23.         return LocalDateTime.parse(dateString, DateTimeFormatter.ofPattern(pattern));
  24.     }
  25.     public static LocalDate stringToLocalDate(String dateString, String pattern){
  26.         return LocalDate.parse(dateString, DateTimeFormatter.ofPattern(pattern));
  27.     }
  28.     public static long stringToTimeStamp(String dateString,String pattern){
  29.         if(pattern.contains("HH")){
  30.             return localDateTimeToTimeStamp(stringToLocalDateTime(dateString,pattern));
  31.         }
  32.         return localDateToTimeStamp(stringToLocalDate(dateString,pattern));
  33.     }
  34.     public static String localDateTimeToString(LocalDateTime time,String pattern){
  35.         return DateTimeFormatter.ofPattern(pattern).format(time);
  36.     }
  37.     public static long localDateTimeToTimeStamp(LocalDateTime time){
  38.         return time.toEpochSecond(ZoneOffset.of("+8"));
  39.     }
  40.     public static long localDateToTimeStamp(LocalDate time){
  41.         return time.atStartOfDay().toEpochSecond(ZoneOffset.of("+8"));
  42.     }
  43.     public static String localDateToString(LocalDate time,String pattern){
  44.         return DateTimeFormatter.ofPattern(pattern).format(time);
  45.     }
  46.     public static LocalDateTime timeStampToLocalDateTime(long timeStamp){
  47.         return LocalDateTime.ofEpochSecond(timeStamp,0,ZoneOffset.ofHours(8));
  48.     }
  49.     public static LocalDate timeStampToLocalDate(long timeStamp){
  50.         return Instant.ofEpochSecond(timeStamp).atOffset(ZoneOffset.of("+8")).toLocalDate();
  51.     }
  52.     public static String timeStampToString(long timeStamp,String pattern){
  53.         return localDateTimeToString(timeStampToLocalDateTime(timeStamp),pattern);
  54.     }

3 Double 取消科学计数法

  1. double d = 112451254012.12485;
  2. NumberFormat nf = NumberFormat.getInstance();
  3. //设置保留多少位小数
  4. nf.setMaximumFractionDigits(20);
  5. // 取消科学计数法
  6. nf.setGroupingUsed(false);
  7. //返回结果
  8. System.out.println(nf.format(d));

4 Maven 项目打包

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.apache.maven.plugins</groupId>
  5.             <artifactId>maven-compiler-plugin</artifactId>
  6.             <version>3.1</version>
  7.         </plugin>
  8.         <plugin>
  9.             <artifactId>maven-assembly-plugin</artifactId>
  10.             <configuration>
  11.                 <archive>
  12.                     <manifest>
  13.                         <mainClass>com.cug.Main</mainClass>
  14.                     </manifest>
  15.                 </archive>
  16.                 <descriptorRefs>
  17.                     <descriptorRef>jar-with-dependencies</descriptorRef>
  18.                 </descriptorRefs>
  19.             </configuration>
  20.             <!--下面是为了使用 mvn package命令，如果不加则使用mvn assembly-->
  21.             <executions>
  22.                 <execution>
  23.                     <id>make-assemble</id>
  24.                     <phase>package</phase>
  25.                     <goals>
  26.                         <goal>single</goal>
  27.                     </goals>
  28.                 </execution>
  29.             </executions>
  30.         </plugin>
  31.     </plugins>
  32. </build>

5 执行可执行程序

  1. String path = System.getProperty("user.dir")+"\\main.exe";    
  3. @Test
  4. public void test1() throws IOException {
  6.     BufferedReader bufferedReader;
  7.     Process proc = Runtime.getRuntime().exec(path);
  9.     // 获取子进程的错误流，并打印
  10.     bufferedReader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
  11.     OutputStreamWriter outputStreamWriter = new OutputStreamWriter(proc.getOutputStream());
  13.     String line;
  14.     while ((line = bufferedReader.readLine()) != null) {
  15.         System.out.println(line);
  16.     }
  17. }
  19. @Test
  20. public void test2() throws IOException {
  21.     Process p = new ProcessBuilder().command(path,"--url","http://localhost:8889").start();
  22.     InputStream i = p.getInputStream();
  23.     Scanner scanner = new Scanner(i);
  24.     while (scanner.hasNextLine()){
  25.         System.out.println(scanner.nextLine());
  26.     }
  27. }

6 扫描线填充算法

https://blog.csdn.net/wodownload2/article/details/52154207
  1. package com.cug.web;
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.util.ArrayList;
  6. import java.util.Collections;
  8. public class FillTest extends JFrame {
  10.     private ArrayList<Edge> edgeTable = new ArrayList<>();
  12.     private int getYmin() {
  13.         int yMin = edgeTable.get(0).y1;
  14.         for (Edge edge : edgeTable) {
  15.             if (edge.y1 < yMin)
  16.                 yMin = edge.y1;
  17.         }
  18.         return yMin;
  19.     }
  21.     private int getYmax() {
  22.         int yMax = edgeTable.get(0).y1;
  23.         for (Edge edge : edgeTable) {
  24.             if (edge.y1 > yMax)
  25.                 yMax = edge.y1;
  26.         }
  27.         return yMax;
  28.     }
  30.     private boolean isActive(Edge edge, int currentY) {
  31.         return edge.y1 < currentY && currentY <= edge.y2 || edge.y1 >= currentY && currentY > edge.y2;
  32.     }
  34.     private void updateActiveEdges(ArrayList<Edge> activeEdges, int y) {
  35.         for (Edge edge : edgeTable) {
  36.             if (isActive(edge, y)) {
  37.                 if (!activeEdges.contains(edge)) {
  38.                     activeEdges.add(edge);
  39.                 }
  40.             } else {
  41.                 activeEdges.remove(edge);
  42.             }
  43.         }
  44.     }
  46.     private void findIntersections(ArrayList<Integer> intersections, ArrayList<Edge> activeEdges, int currentY) {
  47.         intersections.clear();
  48.         for (Edge edge : activeEdges) {
  49.             int x = edge.x1 + ((currentY - edge.y1) * (edge.dx)) / (edge.dy);
  50.             intersections.add(x);
  51.         }
  52.     }
  54.     public void fill() {
  55.         ArrayList<Edge> activeEdges = new ArrayList(10);
  56.         ArrayList<Integer> intersections = new ArrayList(20);
  58.         Graphics g = getGraphics();
  59.         g.setColor(Color.red);
  60.         // x1,y1,x2,y2
  61.         edgeTable.add(new Edge(100, 100, 100, 600));
  62.         edgeTable.add(new Edge(100, 600,500,400));
  63.         edgeTable.add(new Edge(500,400, 100, 100));
  65.         int yMin = getYmin();
  66.         int yMax = getYmax();
  68.         for (int y = yMin; y < yMax; y++) {
  69.             updateActiveEdges(activeEdges, y);
  70.             findIntersections(intersections, activeEdges, y);
  71.             Collections.sort(intersections);
  72.             for (int i = 0; i < intersections.size(); i += 2) {
  73.                 int x1 = intersections.get(i);
  74.                 if (i + 1 >= intersections.size()){
  75.                     break;
  76.                 }
  77.                 int x2 = intersections.get(i + 1);
  78.                 g.drawLine(x1, y, x2, y);
  79.             }
  80.         }
  81.     }
  83.     public static void main(String[] args) {
  84.         FillTest s = new FillTest();
  85.         s.setSize(800, 800);
  86.         s.setVisible(true);
  87.         s.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  88.         s.fill();
  89.     }
  90. }
  92. class Edge {
  93.     int x1, y1, x2, y2, dx, dy;
  94.     Edge(int x1, int y1, int x2, int y2) {
  95.         this.x1 = x1;
  96.         this.y1 = y1;
  97.         this.x2 = x2;
  98.         this.y2 = y2;
  99.         this.dx = x2 - x1;
  100.         this.dy = y2 - y1;
  101.     }
  102. }

7 JDK动态代理(只能代理实现了接口的类)

  1. import org.junit.jupiter.api.Test;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class ProxyTest {
  8.     interface SmsService {
  9.         void send(String message,String msg);
  10.     }
  12.     static class SmsServiceImpl implements SmsService {
  13.         public void send(String message,String msg) {
  14.             System.out.println("send message:" + message + "---" + msg);
  15.         }
  16.     }
  18.     static class DebugInvocationHandler implements InvocationHandler {
  19.         /**
  20.          * 代理类中的真实对象
  21.          */
  22.         private final Object target;
  24.         public DebugInvocationHandler(Object target) {
  25.             this.target = target;
  26.         }
  28.         @Override
  29.         public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
  30.             // 调用方法之前，添加自己的操作
  31.             System.out.println("before method " + method.getName());
  32.             Object result = method.invoke(target, args);
  33.             // 调用方法之后，添加自己的操作
  34.             System.out.println("after method " + method.getName());
  35.             return result;
  36.         }
  37.     }
  39.     @Test
  40.     void test1(){
  41.         SmsServiceImpl smsService1 = new SmsServiceImpl();
  42.         SmsService smsService = (SmsService) Proxy.newProxyInstance(
  43.                 // 目标类的类加载
  44.                 smsService1.getClass().getClassLoader(),
  45.                 // 代理需要实现的接口，可指定多个
  46.                 smsService1.getClass().getInterfaces(),
  47.                 new DebugInvocationHandler(smsService1));
  49.         smsService.send("java","test");
  50.     }
  51. }

8 cglib 动态代理

  1. <dependency>
  2.   <groupId>cglib</groupId>
  3.   <artifactId>cglib</artifactId>
  4.   <version>3.3.0</version>
  5. </dependency>
  1. import net.sf.cglib.proxy.Enhancer;
  2. import net.sf.cglib.proxy.MethodInterceptor;
  3. import net.sf.cglib.proxy.MethodProxy;
  4. import org.junit.jupiter.api.Test;
  5. import java.lang.reflect.Method;
  7. public class ProxyCglibTest {
  8.     static class SmsService {
  9.         public void send(String message,String msg) {
  10.             System.out.println("send message:" + message + "---" + msg);
  11.         }
  12.     }
  13.     /**
  14.      * 自定义MethodInterceptor
  15.      */
  16.     static class DebugMethodInterceptor implements MethodInterceptor {
  17.         /**
  18.          * @param o           代理对象（增强的对象）
  19.          * @param method      被拦截的方法（需要增强的方法）
  20.          * @param args        方法入参
  21.          * @param methodProxy 用于调用原始方法
  22.          */
  23.         @Override
  24.         public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  25.             //调用方法之前，我们可以添加自己的操作
  26.             System.out.println("before method " + method.getName());
  27.             Object object = methodProxy.invokeSuper(o, args);
  28.             //调用方法之后，我们同样可以添加自己的操作
  29.             System.out.println("after method " + method.getName());
  30.             return object;
  31.         }
  32.     }
  34.     @Test
  35.     void test1(){
  36.         Class<SmsService> smsServiceClass = SmsService.class;
  37.         // 创建动态代理增强类
  38.         Enhancer enhancer = new Enhancer();
  39.         // 设置类加载器
  40.         enhancer.setClassLoader(smsServiceClass.getClassLoader());
  41.         // 设置被代理类
  42.         enhancer.setSuperclass(smsServiceClass);
  43.         // 设置方法拦截器
  44.         enhancer.setCallback(new DebugMethodInterceptor());
  45.         // 创建代理类
  46.         SmsService smsService = (SmsService) enhancer.create();
  48.         smsService.send("java","test");
  49.     }
  50. }

9 反射

  1. public class TargetObject {
  2.     private String value;
  3.     public TargetObject() {
  4.         value = "targetObject";
  5.     }
  6.     public void publicMethod(String s) {
  7.         System.out.println("publicMethod " + s);
  8.     }
  9.     private void privateMethod() {
  10.         System.out.println("privateMethod " + value);
  11.     }
  12. }
  14. public class Main {
  15.     public static void main(String[] args) throws Exception {
  16.         /**
  17.          * 获取 TargetObject 类的 Class 对象并且创建 TargetObject 类实例
  18.          */
  19.         Class<?> targetClass = Class.forName("com.cug.TargetObject");
  20.         TargetObject targetObject = (TargetObject) targetClass.newInstance();
  21.         /**
  22.          * 获取 TargetObject 类中定义的所有方法
  23.          */
  24.         Method[] methods = targetClass.getDeclaredMethods();
  25.         for (Method method : methods) {
  26.             System.out.println(method.getName());
  27.         }
  29.         /**
  30.          * 获取指定方法并调用
  31.          */
  32.         Method publicMethod = targetClass.getDeclaredMethod("publicMethod",String.class);
  33.         publicMethod.invoke(targetObject, "targetObject");
  35.         /**
  36.          * 获取指定参数并对参数进行修改
  37.          */
  38.         Field field = targetClass.getDeclaredField("value");
  39.         //为了对类中的参数进行修改我们取消安全检查
  40.         field.setAccessible(true);
  41.         field.set(targetObject, "modify");
  43.         /**
  44.          * 调用 private 方法
  45.          */
  46.         Method privateMethod = targetClass.getDeclaredMethod("privateMethod");
  47.         //调用 private 方法，取消安全检查
  48.         privateMethod.setAccessible(true);
  49.         privateMethod.invoke(targetObject);
  50.     }
  51. }

10 回调函数

public class CallBackTest {

    interface CallBack {
        void send(String msg);
    }

    static class Callback1 implements CallBack{
        @Override
        public void send(String msg) {
            System.out.println("Callback1 : " + msg);
        }
    }

    static class Callback2 implements CallBack{
        @Override
        public void send(String msg) {
            System.out.println("Callback2 : " + msg);
        }
    }

    public void execute(CallBack callBack) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            callBack.send("i = " + i);
            TimeUnit.SECONDS.sleep(1);
        }
    }

    @Test
    void  test1() throws InterruptedException {
        execute(new CallBack() {
            @Override
            public void send(String msg) {
                System.out.println("匿名 : " + msg);
            }
        });
        execute(new Callback1());
        execute(new Callback2());
    }
}