vlambda博客
学习文章列表

Runnable runnable = new Runnable() { @Override public void run() { System.out.println("do something..."); }};

// 一行即可Runnable runnable = () -> System.out.println("do something...");

// 有状态函数: 执行结果依赖b的值是多少，即便入参相同，// 多次执行函数，函数的返回值有可能不同，因为b值有可能不同。int b;int increase(int a) { return a + b;}
// 无状态函数：执行结果不依赖任何外部变量值// 只要入参相同，不管执行多少次，函数的返回值就相同int increase(int a, int b) { return a + b;}

public class Demo { public static void main(String[] args) { Optional<Integer> result = Stream.of("a", "be", "hello") .map(s -> s.length()) .filter(l -> l <= 3) .max((o1, o2) -> o1-o2); System.out.println(result.get()); // 输出2 }}

add(multiply(subtract(3,1),2),5);

subtract(3,1).multiply(2).add(5);

public class Demo { public static void main(String[] args) { Optional<Integer> result = Stream.of("f", "ba", "hello") // of返回Stream<String>对象 .map(s -> s.length()) // map返回Stream<Integer>对象 .filter(l -> l <= 3) // filter返回Stream<Integer>对象 .max((o1, o2) -> o1-o2); // max终止操作：返回Optional<Integer> System.out.println(result.get()); // 输出2 }}

// Stream类中map函数的定义：public interface Stream<T> extends BaseStream<T, Stream<T>> { <R> Stream<R> map(Function<? super T, ? extends R> mapper); //...省略其他函数...}
// Stream类中map的使用方法示例：Stream.of("fo", "bar", "hello").map(new Function<String, Integer>() { @Override public Integer apply(String s) { return s.length(); }});
// 用Lambda表达式简化后的写法：Stream.of("fo", "bar", "hello").map(s -> s.length());

(a, b) -> { 语句1；语句2；...; return 输出; } //a,b是输入参数

Optional<Integer> result = Stream.of("f", "ba", "hello") .map(s -> s.length()) .filter(l -> l <= 3) .max((o1, o2) -> o1-o2); // 还原为函数接口的实现方式Optional<Integer> result2 = Stream.of("fo", "bar", "hello") .map(new Function<String, Integer>() { @Override public Integer apply(String s) { return s.length(); } }) .filter(new Predicate<Integer>() { @Override public boolean test(Integer l) { return l <= 3; } }) .max(new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1 - o2; } });

@FunctionalInterfacepublic interface Comparator<T> { /** * single abstract method * @since 1.8 */ int compare(T o1, T o2);
 /** * Object类中的public abstract method  * @since 1.8 */ boolean equals(Object obj);
 /** * 默认方法 * @since 1.8 */ default Comparator<T> reversed() { return Collections.reverseOrder(this); }
  /** * 静态方法 * @since 1.8 */ public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() { return Collections.reverseOrder(); }
 //省略...}

public class Test {  public static void main(String args[]) {  List<Person> persons = new ArrayList<Person>(); Collections.sort(persons, new Comparator<Person>(){ @Override public int compare(Person o1, Person o2) { return Integer.compareTo(o1.getAge(), o2.getAge()); } }); } }

Comparator<Person> comparator = (p1, p2) -> Integer.compareTo(p1.getAge(), p2.getAge());

@FunctionalInterfacepublic interface Function<T, R> { R apply(T t); // 只有这一个未实现的方法
 default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { Objects.requireNonNull(before); return (V v) -> apply(before.apply(v)); }
 default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (T t) -> after.apply(apply(t)); }
 static <T> Function<T, T> identity() { return t -> t; }}
@FunctionalInterfacepublic interface Predicate<T> { boolean test(T t); // 只有这一个未实现的方法
 default Predicate<T> and(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) && other.test(t); }
 default Predicate<T> negate() { return (t) -> !test(t); }
 default Predicate<T> or(Predicate<? super T> other) { Objects.requireNonNull(other); return (t) -> test(t) || other.test(t); }
 static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object); }}