搜索到
51
篇与
的结果
-
Spring Boot中ThreadLocal踩坑 ThreadLocal作用ThreadLocal的作用:用来存当前线程的局部变量，不同线程间互不干扰。拿完数据记得需要移除数据，不然JVM不会将ThreadLocal回收(可能还会被引用)，多了就会出现内存泄漏的情况。解析ThreadLocal类ThreadLocal包含几个方法：public T get() { } public void set(T value) { } public void remove() { } protected T initialValue() { }T get()get()方法是用来获取ThreadLocal在当前线程中保存的变量副本set(T value)set()用来设置当前线程中变量的副本void remove()remove()用来移除当前线程中变量的副本T initialValue()initialValue()是一个protected方法，一般是用来在使用时进行重写的，它是一个延迟加载方法。ThreadLocal变量污染ThreadLocal会在每个线程存储一个副本，但是如果我们使用的是比如Tomcat，Tomcat自身会维护一个线程池，线程结束后，并不会马上销毁，而是会重新进入线程池，下次有请求时，有可能会复用当前线程，如果我们每次使用ThreadLocal之前，没有进行Set(T value),那么就有可能导致不同线程之间变量污染，比如下面的代码@RestController @RequestMapping(value = "book") @Slf4j public class BookController { private static final ThreadLocal<String> THREAD_LOCAL_TEST = new ThreadLocal<>(); @Resource private IBookService bookService; /** * 构造函数 */ public BookController() { log.info("构造函数，此时bookService ：" + bookService); } @PostConstruct public void init() { log.info("PostConstruct，此时bookService ：" + bookService); } @PreDestroy public void destroy() { log.info("PreDestroy"); } @GetMapping(value = "set") public void set() { if (StringUtils.isEmpty(THREAD_LOCAL_TEST.get())) { THREAD_LOCAL_TEST.set(UUID.randomUUID().toString()); } } @GetMapping(value = "search") public List<Book> search() { log.error(THREAD_LOCAL_TEST.get()); return bookService.search(); } }使用jmeter进行请求，可以看到同一线程，输出的内容永远不会发生改变。可以在内次使用之前进行set(T value),但是set(T value)可能会导致内存无法释放。ThreadLocal可能导致的内存泄露ThreadLocal为了避免内存泄露，不仅使用了弱引用维护key，还会在每个操作上检查key是否被回收，进而再回收value。但是从中也可以看到，ThreadLocal并不能100%保证不发生内存泄漏。比如，很不幸的，你的get()方法总是访问固定几个一直存在的ThreadLocal，那么清理动作就不会执行，如果你没有机会调用set()和remove()，那么这个内存泄漏依然会发生。一个良好的习惯依然是：当你不需要这个ThreadLocal变量时，主动调用remove()，这样对整个系统是有好处的。@RestController @RequestMapping(value = "book") @Slf4j public class BookController { private static final ThreadLocal<String> THREAD_LOCAL_TEST = new ThreadLocal<>(); @Resource private IBookService bookService; /** * 构造函数 */ public BookController() { log.info("构造函数，此时bookService ：" + bookService); } @PostConstruct public void init() { log.info("PostConstruct，此时bookService ：" + bookService); } @PreDestroy public void destroy() { log.info("PreDestroy"); } @GetMapping(value = "set") public void set() { THREAD_LOCAL_TEST.set(UUID.randomUUID().toString()); } @GetMapping(value = "search") public List<Book> search() { log.error(THREAD_LOCAL_TEST.get()); THREAD_LOCAL_TEST.remove(); return bookService.search(); } }ThreadLocal与局部变量局部变量和ThreadLocal起到的作用是一样的，保证了并发环境下数据的安全性。那就是说，完全可以用局部变量来代替ThreadLocal咯？This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its {@code get} or {@code set} method) has its own, independently initialized copy of the variable. {@code ThreadLocal} instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).翻译过来 ThreadLocal提供的是一种线程局部变量。这些变量不同于其它变量的点在于每个线程在获取变量的时候，都拥有它自己相对独立的变量初始化拷贝。ThreadLocal的实例一般是私有静态的，可以做到与一个线程绑定某一种状态。所以就这段话而言，我们知道ThreadLocal不是为了满足多线程安全而开发出来的，因为局部变量已经足够安全。ThreadLocal是为了方便线程处理自己的某种状态。 可以看到ThreadLocal实例化所处的位置，是一个线程共有区域。好比一个银行和个人，我们可以把钱存在银行，也可以把钱存在家。存在家里的钱是局部变量，仅供个人使用；存在银行里的钱也不是说可以让别人随便使用，只有我们以个人身份去获取才能得到。所以说ThreadLocal封装的变量我们是在外面某个区域保存了处于我们个人的一个状态，只允许我们自己去访问和修改的状态。 -
@SpringBootApplication标注非引导类 一般情况下，@SpringBootApplication一般都是标注在项目引导类上。像下面这样：@Slf4j @SpringBootApplication public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoConfiguration.class, args); } }但是@SpringBootApplication一定要标注到引导类上吗？答案是否定的。我们可以将@SpringBootApplication标注到任意的类上。比如我们增加以下类package cc.lisen.demo.config; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class DemoConfiguration { }然后改造引导类@Slf4j public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoConfiguration.class, args); } }再次运行项目，可以发现项目可以正常运行但是如果我们访问我们的接口，会发现提示404注意我们DemoConfiguration所在的包cc.lisen.demo.config,@SpringBootApplication只会扫描当前包及下级包，所以，我们的接口它扫描不到，就提示404。如果希望我们其他的类被扫描到，我们就需要添加scanBasePackages属性。package cc.lisen.demo.config; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication(scanBasePackages = {"cc.lisen.demo"}) public class DemoConfiguration { }重启项目，在访问接口，发现能正常访问
-
理解SpringBoot 中的@AliasFor注解 感觉Spring Boot中的@AliasFor注解是一个既熟悉又陌生的注解。说熟悉，是因为我们经常使用的比如@Service、@RestController、@Repository甚至@SpringBootApplication中都有他们的身影。说陌生，是因为其实从来没有真正用过这个注解。@AliasFor注解有两个作用：定义一个注解中的两个属性互为别名。桥接其他注解的属性。一、定义一个注解中的两个属性互为别名。我们以ComponentScan注解为例，先来看下ComponentScan的定义@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Documented @Repeatable(ComponentScans.class) public @interface ComponentScan { @AliasFor("basePackages") String[] value() default {}; @AliasFor("value") String[] basePackages() default {}; Class<?>[] basePackageClasses() default {}; Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class; Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class; ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT; String resourcePattern() default "**/*.class"; boolean useDefaultFilters() default true; ComponentScan.Filter[] includeFilters() default {}; ComponentScan.Filter[] excludeFilters() default {}; boolean lazyInit() default false; @Retention(RetentionPolicy.RUNTIME) @Target({}) public @interface Filter { FilterType type() default FilterType.ANNOTATION; @AliasFor("classes") Class<?>[] value() default {}; @AliasFor("value") Class<?>[] classes() default {}; String[] pattern() default {}; } }以上代码，我们关注点在于 @AliasFor("basePackages") String[] value() default {}; @AliasFor("value") String[] basePackages() default {};这段代码，代表着，在ComponentScan注解中，basePackages属性与value是一样的，可以相互调用。我们可以测试一下@ComponentScan(basePackages = {"cc.lisen.demo"}) @Component @EnableAutoConfiguration @Slf4j public class DemoApplication { public static void main(String[] args) { ComponentScan componentScan = AnnotatedElementUtils.getMergedAnnotation(DemoApplication.class, ComponentScan.class); assert componentScan != null; System.out.println(Arrays.toString(componentScan.basePackages())); System.out.println(Arrays.toString(componentScan.value())); SpringApplication.run(DemoApplication.class, args); } }二、桥接其他注解的属性这次，我们看下@Service的代码@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Service { @AliasFor( annotation = Component.class ) String value() default ""; }可以看到，@Service将value属性，桥接到了@Component注解的value属性。@ComponentScan(basePackages = {"cc.lisen.demo"}) @Component @EnableAutoConfiguration @Slf4j public class DemoApplication { public static void main(String[] args) { Component component = AnnotatedElementUtils.getMergedAnnotation(BookService.class, Component.class); assert component != null; System.out.println(component.value()); SpringApplication.run(DemoApplication.class, args); } }
-
java类型转换的一些问题及处理 最近在项目上被类型转换坑了不少。特以此文做一下记录。问题出在哪以前在项目开发的时候，在数据访问层，基本上是使用MyBatis，偶尔使用JPA，不管哪种方式，我们数据访问都是建立在实体之上的（极少数情况下也会使用Map，但是这种情况是比较特殊的。目前公司的开发平台，数据访问层，统一通过平台封装的BQL进行，问题就出现在这个封装的BQL上，它返回的数据类型是List<Map<String,Object>>类型，这个东西看似灵活（因为是Map，另外还是Object的泛型），既然返回的是Object类型，那就涉及到类型转换的问题。这种Object的弱类型，也给我们创建实体制作了障碍，比如我们一个实体可能有Integer类型、String类型等等。但是，我们总不能把实体全部创建层Object类型的。进一步的问题截止到目前，我们发现的第一个问题就是Object需要转换成具体的类型。紧接着，我们面临着第二个问题，就是我们通过BQL这个东西建表的时候，我们选择的比如是Integer类型（整型），我们会发现，在postgre数据库中，创建的类型确实是Integer，但是在Oracle中创建的是Number类型，然后我们在用BQL取数的时候，在postgre数据库中，取出的Object是Integer，但是在Oracle中取出的Object确实BigDecimal类型，这就让人比较懵逼了。我在创建实体的时候，到底是用Integer还是用BigDecimal呢。如何定义类型通过上面分析，我们可以确定的是，我们需要的是Integer而不是BigDecimal。所以，我们在创建实体时，创建的是一个Integer类型的。如何进行类型转换以上，便引出了我们如何进行类型转换的话题。在Java中如何进行类型转换呢，我们以Integer类型为例，常见的方式可能就以下三种。(Integer)obj:将obj转换成Integer类型，这种obj可以是Object类型。Integer.parseInt(obj):将字符串类型的obj转成对应的数值。Integer.valueOf(obj):将字符串类型的obj转成对应的数值。那么这三种方法有啥区别呢，我们以以下代码为例Object str123 = new BigDecimal("123"); int int123 = (int) str123; int parseInt = Integer.parseInt(str123.toString()); Integer valueOf = Integer.valueOf(str123.toString()); System.out.println(int123); System.out.println(parseInt); System.out.println(valueOf);以上代码，idea不会给出任何的错误提示但是我们运行时，会发现int int123 = (int) str123;这行代码会报错因为str123实际是BigDecimal类型所以(Integer)报错了。区别一：(Integer)只能转换相同的类型，否则会报错。我们跳转代码，可以查看Integer.parseInt()和Integer.valueOf()通过上面截图，我们可以看到Integer.parseInt()和Integer.valueOf()的区别。Integer.parseInt()返回的是基本类型int，Integer.valueOf()返回的是对象类型Integer。区别二：Integer.parseInt()返回的是基本类型int，Integer.valueOf()返回的是对象类型Integer。
-
java object转成Map /** * object转成Map * * @param obj 对象 * @return Map */ private Map<String, Object> obj2Map(Object obj) { Map<String, Object> map = new HashMap<>(); // System.out.println(obj.getClass()); // 获取f对象对应类中的所有属性域 Field[] fields = obj.getClass().getDeclaredFields(); for (Field field : fields) { String varName = field.getName(); varName = varName.toUpperCase();//将key置为小写，默认为对象的属性 try { // 获取原来的访问控制权限 boolean accessFlag = field.isAccessible(); // 修改访问控制权限 field.setAccessible(true); // 获取在对象f中属性fields[i]对应的对象中的变量 Object o = field.get(obj); if (o != null) map.put(varName, o.toString()); // System.out.println("传入的对象中包含一个如下的变量：" + varName + " = " + o); // 恢复访问控制权限 field.setAccessible(accessFlag); } catch (IllegalArgumentException | IllegalAccessException ex) { ex.printStackTrace(); } } return map; }
-
-
java泛型反序列化 其实不管前后端交互还有API接口，我个人更倾向于使用实体（DTO、VO）啥的，但是，有时候也不得不用Map等进行数据交互。一般而言，前后端或者接口之间交互都是通过JSON进行的，而我们在使用Map的时候，一般都是使用的泛型类，而不是使用原始类型，比如Map<String,string>，那么我们来看下下面一段代码。Map<String,String> bookMap = new HashMap<>(); bookMap.put("author","张三"); bookMap.put("name","山海经"); String bookMapString = JSONObject.toJSONString(bookMap); log.info(bookMapString);我们创建一个Map<String,String>，并将其序列化成字符串，如果我们放过来，想将字符串在反序列化成Map，我们首先想到的可能就像下面这样。Map bookMapNew = JSONObject.parseObject(bookMapString); log.info(String.valueOf(bookMapNew));程序有错吗？当然没错，但是优雅嘛，肯定是不优雅。其实这个时候，idea会给我们一个提示Raw use of parameterized class 'Map'，大概意思就是说这个类要使用泛型，如果不使用泛型，我们其实丢失了类型的安全性。这个时候，我们就想到了parseObject()的重载方法，通过第二个参数，传递进去类型，如果我们是普通的类，传递一个class进去是没问题的。比如我们改写一下上面反序列化的方法Map<String,String> bookMapNew = JSONObject.parseObject(bookMapString,Map.class);这个时候，idea又会给我们一个提示大意就是类型转换没有校验。那么有没有更加完美的方法呢，有的，那就是TypeReference类，我们继续改造代码如下Map<String,String> bookMapNew = JSONObject.parseObject(bookMapString,new TypeReference<Map<String,String>>(){});这回idea终于没有提示了运行一下，结果也是正确的
-
一文撸清楚Java中的枚举enum Java Enum类型的语法结构尽管和java类的语法不一样，应该说差别比较大。但是经过编译器编译之后产生的是一个class文件。该class文件经过反编译可以看到实际上是生成了一个类，该类继承了java.lang.Enum<E>。定义一个枚举定义一个枚举，最简单的方式可能向下面这样public enum Size{ SMALL, MEDIUM, LARGE, EXTRA_LARGE };枚举的构造函数枚举可以定义构造函数，但是必须是private类型。public enum DishType { Fish("FISH"), Chiken("CHIKEN"), Meat("MEAT"); private String type; private DishType(String type) { this.type = type; } public String getType() { return type; } public void setType(String type) { this.type = type; } }你可以向上面这样添加private修饰符或者啥都不添加，但是不能添加public或protect。重写方法与类一样，可以重写枚举的方法，比如toString()方法。public enum DishType { Fish("FISH"), Chiken("CHIKEN"), Meat("MEAT"); private String type; private DishType(String type) { this.type = type; } public String getType() { return type; } public void setType(String type) { this.type = type; } @Override public String toString() { return type; } }获取枚举值可以通过.语法获取枚举值。如果想获取所有的值，可以通过values()方法 for(DishType dishType:DishType.values()){ System.out.println(dishType); }获取原始值可以通过ordinal()方法获取枚举的原始值，也就是1、2、3System.out.println(fish.ordinal());控制台输出0,因为Fish是我们在枚举值第一个定义的，从0开始。反向获取枚举可以通过valueOf()反向获取枚举值DishType.valueOf("Fish");枚举中定义方法比如在枚举中定义一个sayHello方法public void sayHello() { System.out.println("hello,i am " + type); }然后调用 DishType fish = DishType.valueOf("Fish"); fish.sayHello();枚举中的匿名内部类枚举实例后有花括号时，该枚举实例是枚举类匿名内部之类定义性别枚举类package com.company.enumpackage; public enum Gender { //枚举值调用对应构造器创建 MALE("男") { public void info() { System.out.println("这个枚举代表男"); } }, FEMALE("女") { public void info() { System.out.println("这个枚举代表女"); } }, UNKNOWN("UNKNOWN"); private final String name; //枚举类的构造器只能使用private修饰 private Gender(String name) { this.name = name; } public String getName() { return this.name; } public void info() { System.out.println("这是第一个用于定义性别的枚举类"); } }调用Gender male = Gender.MALE; Gender female = Gender.FEMALE; Gender unKnown = Gender.UNKNOWN; male.info(); female.info(); unKnown.info();
-
java8 Optional<T>简介 Optional<T>是Java8增加的一个用于处理NullPointException异常的类。Optional<T>是一个容器类，代表一个值存在或不存在。如果用过Spring Boot Data Jpa，会发现里面好多返回值都是Optional<T>类型的。下面我们介绍一下Optional<T>类的常见使用方法。作为演示，我们创建了一个Dish类，代码如下：public class Dish { /** * 构造函数 * @param name 名称 * @param isVegetarian 是否蔬菜 */ public Dish(String name, boolean isVegetarian) { this.name = name; this.isVegetarian = isVegetarian; } /** * 名称 */ private String name; /** * 是否蔬菜 */ private boolean isVegetarian; @Override public String toString(){ return name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public boolean isVegetarian() { return isVegetarian; } public void setVegetarian(boolean isVegetarian) { this.isVegetarian = isVegetarian; } } 创建一个Optional<T>实例创建Optional<T>实例，有两个方法，分别是of、ofNullable，ofNullable与是of的区别在于，如果传递的参数是null，那么会创建一个空的(empty)Optional<T>实例。 Optional<Dish> dishOptionalofNullable = Optional.ofNullable(null); dishOptionalofNullable.ifPresent(System.out::println); System.out.println("准备输出of方法的值"); Optional<Dish> dishOptionalof = Optional.of(null); dishOptionalof.ifPresent(System.out::println);运行代码，我们可以看到如下输出我们可以看到ofNullable创建的实例，即使传递的参数是null调用实例方法时，系统也会抛出异常，而of传递null值时，创建的Optional<T>实例也是null。判断是否为空通过isPresent()方法可以判断Optional<T>包含的类是否是null。返回true代表不是null,返回false代表是null。 Optional<Dish> emptyOptional = Optional.empty(); if (emptyOptional.isPresent()) { System.out.println(emptyOptional.get()); } else { System.out.println("empty optional"); }还有一个方法是ifPresent(Consumer<? super T> action)可以传递一个Consumer接口，当类不是null。 Optional<Dish> emptyOptional = Optional.empty(); emptyOptional.ifPresent(System.out::println);还有一个方法 ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction),当类不是null时，调用action接口，否则调用emptyAction接口。 List<Dish> menu = new ArrayList<>(); Dish fish = new Dish("鱼", false); Dish tomato = new Dish("西红柿", true); menu.add(fish); menu.add(tomato); menu.stream().filter(Dish::isVegetarian).findAny().ifPresentOrElse(System.out::println, () -> { System.out.println("没找到呢"); });获取值获取值比较简单，通过get()方法即可。 Optional<Dish> fishOptional = Optional.ofNullable(new Dish("鱼", false)); if(fishOptional.isPresent()){ System.out.println(fishOptional.get()); }通过orElse(T other)可以设置默认值。 Optional<Dish> fishOptional = Optional.ofNullable(new Dish("鱼", false)); Dish defaultDish = new Dish("default", false); if (fishOptional.isPresent()) { System.out.println(fishOptional.orElse(defaultDish)); } Optional<Dish> emptyOptional = Optional.empty(); System.out.println(emptyOptional.orElse(defaultDish));上面emptyOptional是空的，那么我们可以返回一个默认的Dish实例，下面看下控制台输出。orElse(T other)还有一些变种方法，大家可以试一下。
-
java中对象和Map的相互转换 实体对象转map集合private static Map<String, String> obj2Map(Object obj) { Map<String, String> map = new HashMap<String, String>(); // System.out.println(obj.getClass()); // 获取f对象对应类中的所有属性域 Field[] fields = obj.getClass().getDeclaredFields(); for (Field field : fields) { String varName = field.getName(); varName = varName.toLowerCase();//将key置为小写，默认为对象的属性 try { // 获取原来的访问控制权限 boolean accessFlag = field.isAccessible(); // 修改访问控制权限 field.setAccessible(true); // 获取在对象f中属性fields[i]对应的对象中的变量 Object o = field.get(obj); if (o != null) map.put(varName, o.toString()); // System.out.println("传入的对象中包含一个如下的变量：" + varName + " = " + o); // 恢复访问控制权限 field.setAccessible(accessFlag); } catch (IllegalArgumentException | IllegalAccessException ex) { ex.printStackTrace(); } } return map; }将map集合转化成实体对象利用反射实现/** * Map转成实体对象 * @param map map实体对象包含属性 * @param clazz 实体对象类型 * @return */ public static <T> T map2Object(Map<String, Object> map, Class<T> clazz) { if (map == null) { return null; } T obj = null; try { obj = clazz.newInstance(); Field[] fields = obj.getClass().getDeclaredFields(); for (Field field : fields) { int mod = field.getModifiers(); if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) { continue; } field.setAccessible(true); field.set(obj, map.get(field.getName())); } } catch (Exception e) { e.printStackTrace(); } return obj; }
-
java8谓词复合和函数复合 谓词及功能复合，就是在通过组合已有的谓词或功能，形成更加复杂的谓词或功能。谓词复合谓词（Predicate)接口包含三个方法：negate、and和or，通过这三个方法，我们可以在已有谓词的基础上，组合形成更加复杂的谓词。negate代表非，and代表和，or代表或。举个例子，我们有一个苹果（Apple）类，包含颜色（color)和重量（weight）两个属性。class Apple { public Apple(String color, double weight) { this.color = color; this.weight = weight; } private String color; private double weight; @Override public String toString() { return "color:" + color + "---------" + "weight:" + weight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public double getWeight() { return weight; } public void setWeight(double weight) { this.weight = weight; } } 然后我们创建一个苹果的列表，存储几条测试数据。List<Apple> appleList = new ArrayList<>(); appleList.add(new Apple("red", 2)); appleList.add(new Apple("red", 6)); appleList.add(new Apple("green", 2)); appleList.add(new Apple("green", 6));negate测试我们创建一个查找红色苹果的谓词Predicate<Apple> redApple = apple -> "red".equals(apple.getColor());然后创建一个查找不是红色苹果的谓词List<Apple> notRedAppleList = appleList.stream().filter(notRedApple).collect(Collectors.toList()); for (Apple apple : notRedAppleList) { System.out.println(apple); }and测试我们首先创建一个查找重量大于5的谓词Predicate<Apple> weightThan5Apple = apple -> apple.getWeight() > 5;然后组合红苹果及重量大于5的两个谓词Predicate<Apple> redAndWeightThan5Apple = redApple.and(weightThan5Apple);测试 List<Apple> redAndWeightThan5AppleList = appleList.stream().filter(redAndWeightThan5Apple).collect(Collectors.toList()); for (Apple apple : redAndWeightThan5AppleList) { System.out.println(apple); }or测试还是利用刚才的谓词，这次我们测试重量大于5或者颜色是红色的苹果Predicate<Apple> redOrWeightThan5Apple = redApple.or(weightThan5Apple);测试 List<Apple> redOrWeightThan5AppleList = appleList.stream().filter(redOrWeightThan5Apple).collect(Collectors.toList()); for (Apple apple : redOrWeightThan5AppleList) { System.out.println(apple); }函数复合函数复合跟谓词复合类似，函数复合提供了两个接口方法：andThen和compose,通过字面含义我们可以知道andThen代表先执行第一个函数，然后在执行第二个函数，compose与之相反，先执行第二个函数，在执行第一个函数。 Function<Integer, Integer> funcPlus = x -> x + 1; Function<Integer, Integer> funcMul = y -> y * 2; Function<Integer, Integer> funcAndThen = funcPlus.andThen(funcMul); Function<Integer, Integer> funcCompose = funcPlus.compose(funcMul); System.out.println("andThen:" + funcAndThen.apply(1)); System.out.println("compose:" + funcCompose.apply(1));通过测试，我们发现andThen先执行了第一个函数，也就是1+1=2，然后执行2*2=4，所以最终结果就是4。compose限制性1*2=2，然后执行1+2=3，所以结果是3。
-
java8函数式接口Predicate、Consumer、Function java8在java.util.function包中给我们预留了几个泛型函数式接口。Predicate、Consumer、Function。Predicate接口里面有一个test方法，接口一个泛型T对象并返回一个boolean值。 static <T> List<T> filter(List<T> list, Predicate<T> predicate) { List<T> result = new ArrayList<>(); for (T t : list) { if (predicate.test(t)) { result.add(t); } } return result; }传递一个String类型的列表，过滤掉其中为空的元素。 List<String> list = new ArrayList<>(); list.add(""); list.add("one"); List<String> result = filter(list,s->s.length()>0); for(String s:result){ System.out.println(s); }Consumer接口里面定义了一个accept方法，接受一个泛型T对象，没有返回值。 static <T> void consumer(List<T> list, Consumer<T> consumer) { for (T t : list) { consumer.accept(t); } }输出列表元素。 consumer(list, System.out::println);Function接口里面定义了一个apply方法，接受一个泛型T，并返回泛型R。static <T,R> List<R> func(List<T> list, Function<T,R> fun){ List<R> result = new ArrayList<>(); for(T t:list){ result.add(fun.apply(t)); } return result; }获取列表每个元素的长度。List<Integer> lengthList=func(list, String::length); for(Integer integer:lengthList){ System.out.println(integer); }
