1. StringJoiner类

构造方法：（StringJoiner中没有无参构造）

成员方法：

举个例子，把数组转成字符串：

2. Lambda表达式

练习1：使用Lambda求出整型数组元素之和

interface Operator{
    public abstract int getSum(int[] arr);
}
public class OperatorDemo {
    public static void main(String[] args) {
        // 这是使用匿名内部类的方式
        method(new Operator() {
            @Override
            public int getSum(int[] arr) {
                int sum = 0;
                for(int num : arr) {
                    sum += num;
                }
                return sum;
            }
        });
        // 使用Lambda表达式的方式 (IDEA中可以直接把匿名内部类转化为Lambda)
        method(arr -> {
            int sum = 0;
            for(int num : arr) {
                sum += num;
            }
            return sum;
        });
    }
    public static void method(Operator op) {
        int[] nums = {1,2,3,4,5};
        int sum = op.getSum(nums);
        System.out.println(sum);
    }
}

练习2：使用函数式接口返回数组元素的最大值

// Supplier接口，无参有返回值，供给型
@FunctionalInterface
public interface Supplier<T> {
    public abstract T get();
}
public class SupplierDemo { 
    public static void main(String[] args) {
        // 这是使用匿名内部类的方式
        printMax(new Supplier() {
            @Override
            public Integer get() {
                int[] arr = {10, 20, 100, 30, 40, 50};
                Arrays.sort(arr);
                return arr[arr.length - 1];
            }
        });
        // 这是使用Lambda表达式的方式
        printMax(() -> {
            int[] arr = {10, 20, 100, 30, 40, 50};
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
    }
    private static void printMax(Supplier<Integer> supplier) {
        // 调用接口中的get方法
        int max = supplier.get();
        System.out.println("max = " + max);
    }
}

练习3：使用Lambda表达式将一个字符串先转成小写，再转成大写。

// Consumer消费型接口，可以拿到accept方法参数传递过来的数据进行处理, 有参无返回的接口
public interface Consumer<T> {
    public abstract void accept(T t);
}
public class ConsumerDemo {
    public static void main(String[] args) {
        // 匿名内部类实现
        convert(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.toLowerCase());
            }
        }, new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.toUpperCase());
            }
        });
        // 使用Lambda表达式实现
        convert(s -> System.out.println(s.toLowerCase()),
                s -> System.out.println(s.toUpperCase()));
    }
    // 先转成全小写，再转成全大写
    public static void convert(Consumer<String> c1, Consumer<String> c2) {
        String str = "Hello World";
        c1.accept(str);
        c2.accept(str);
    }
}
------------------------------------------------------------------------------
    // 以上convert方法可以简化，可以使用Consumer 接口中的default方法 andThen进行简化
    // 通过链式写法可以实现更多步骤的组合
    public static void convert(Consumer<String> c1, Consumer<String> c2) {
        String str = "Hello World";
        c1.andThen(c2).accept(str);
        c2.andThen(c1).accept(str);
    }

练习4：使用Lambda表达式将字符串转成整型

// Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据。前者T称为前置条件，后者R称为后置条件。有参数有返回值。
@FunctionalInterface
public interface Function<T, R> {
    public abstract R apply(T, t);
}
public class FunctionDemo {
    public static void main(String[] args) {
        // 匿名内部类实现
        str2num(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        });
        // Lambda表达式实现（以下两种都可以）
        str2num(s -> Integer.parseInt(s));
        str2num(Integer::parseInt);
    }
    private static void str2num(Function<String, Integer> function) {
        Integer num = function.apply("1511711");
        System.out.println("res: " + (num + 5));
    }
}

练习5：使用Lambda表达式先将一个字符串转为整型，再乘以10


public class FunctionDemo {
    public static void main(String[] args) {
        // 匿名内部类实现
        test(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        }, new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer i) {
                return i * 10;
            }
        });
        // Lambda表达式实现（以下两种都可以）
        test(s -> Integer.parseInt(s), i -> i * 10);
        test(Integer::parseInt, i -> i * 10);
    }
    private static void test(Function<String, Integer> f1, Function<Integer, Integer> f2) {        
        // 先把字符串转为整型，再乘以10，输出结果
        Integer num = f1.apply("10086");
        Integer res = f2.apply(num);
        System.out.println(res);
    }
---------------------------------------------------------------------------------
    // Function 接口中有一个默认的 andThen 方法，用来进行组合操作
    private static void test(Function<String, Integer> f1, Function<Integer, Integer> f2) {
        Integer res = f1.andThen(f2).apply("10086");
        System.out.println(res);
    }
}

练习6：使用Lambda判断一个人名如果超过3个字就认为是很长的名字

public class PredicateDemo {
    public static void main(String[] args) {
        String name = "迪丽热巴";
        // 匿名内部类实现
        judgeName(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 3;
            }
        }, name);
        // Lambda表达式实现
        judgeName(s -> s.length() > 3, name);
    }
    private static void judgeName(Predicate<String> pre, String name) {
        boolean isLong = pre.test(name);
        System.out.println("isLong: " + isLong);
    }
}

练习6：

使用Lambda表达式判断一个字符串中即包含H，也包含W；
使用Lambda表达式判断一个字符串中包含H或者包含W；

使用Lambda表达式判断一个字符串中不包含W；

public class PredicateDemo {
  public static void main(String[] args) {
      judgeAnd(new Predicate<String>() {
          @Override
          public boolean test(String s) {
              return s.contains("H");
          }
      }, new Predicate<String>() {
          @Override
          public boolean test(String s) {
              return s.contains("W");
          }
      });
      judgeAnd(s -> s.contains("H"), s -> s.contains("W"));
      judgeOr(s -> s.contains("H"), s -> s.contains("W"));
      judgeNegate(s -> s.contains("W"));
  }
  private static void judgeAnd(Predicate<String> p1, Predicate<String> p2){
      String str = "HelloWorld";
      // 判断包含大写“H”
      boolean b1 = p1.test(str);
      // 判断包含大写“W”
      boolean b2 = p2.test(str);
      System.out.println(b1 && b2 ? "满足条件" : "不满足");
      // 也可以这么写
      boolean b = p1.and(p2).test(str);
      System.out.println(b ? "and ✔" : "and ❌");      
  }
  private static void judgeOr(Predicate<String> p1, Predicate<String> p2){
      String str = "XiaoMi";
      boolean b = p1.or(p2).test(str);
      System.out.println(b ? "or ✔" : "or ❌");
  }
  private static void judgeNegate(Predicate<String> p1) {
      String str = "XiaoMi";
      boolean b = p1.negate().test(str);
      System.out.println(b ? "negate ✔" : "negate ❌");
  }    
}

Java 生态

Java 8 新特性

1. StringJoiner类

2. Lambda表达式

3. Stream流