java8 lambda匿名内部类使用小记

谁借莪１个温暖的怀抱￠ 2023-06-09 10:05 14阅读 0赞

java使用lambda表达时式，使用匿名内部类，可省略创建一个新类，并且在写时，省略类的方法。

Future<String> future4 = executor.submit(() -> {  
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < 10; i++) { 
                    sb.append("d");
                    try { 
                        Thread.sleep(100);
                    } catch (InterruptedException e) { 
    
                    }
                }
                return sb.toString();
    
            });

下面是整个省略的过程:

package io.netty.example.echo;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    import java.util.concurrent.FutureTask;
    
    /** * Created by arthur.dy.lee on 2019-10-19. */
    public class RealData implements Callable<String> { 
    
        private String para;
    
        public RealData(String para) { 
            this.para = para;
        }
    
        @Override
        public String call() throws Exception { 
            //真实的业务逻辑
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < 10; i++) { 
                sb.append(para);
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
    
                }
            }
    
            return sb.toString();
        }
    
        public static void main(String[] args) throws InterruptedException, ExecutionException { 
    
            FutureTask<String> future = new FutureTask<String>(new RealData("a"));
            FutureTask<String> future2 = new FutureTask(() -> { 
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < 10; i++) { 
                    sb.append("b");
                    try { 
                        Thread.sleep(100);
                    } catch (InterruptedException e) { 
    
                    }
                }
                return sb.toString();
            });
            ExecutorService executor = Executors.newFixedThreadPool(1);
    
            executor.submit(future);
            executor.submit(future2);
            Future<String> future3 = executor.submit(new Callable<String>() { 
    
                @Override public String call() throws Exception { 
                    StringBuffer sb = new StringBuffer();
                    for (int i = 0; i < 10; i++) { 
                        sb.append("c");
                        try { 
                            Thread.sleep(100);
                        } catch (InterruptedException e) { 
    
                        }
                    }
                    return sb.toString();
                }
            });
            Future<String> future4 = executor.submit(() -> { 
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < 10; i++) { 
                    sb.append("d");
                    try { 
                        Thread.sleep(100);
                    } catch (InterruptedException e) { 
    
                    }
                }
                return sb.toString();
    
            });
            System.out.println("请求完毕！");
            try { 
                System.out.println("我在睡觉别打扰我！2秒后回应");
                Thread.sleep(2000);
            } catch (InterruptedException e) { 
    
            }
            System.out.println("数据处理完成：" + future.get());
            System.out.println("数据处理完成：" + future2.get());
            System.out.println("数据处理完成：" + future3.get());
            System.out.println("数据处理完成：" + future4.get());
        }
    }