Java经典类库-Guava中的函数式编程讲解

public class Person {     public String getName() {         return name;     }      public void setName(String name) {         this.name = name;     }      public int getAge() {         return age;     }      public void setAge(int age) {         this.age = age;     }      private String name;     private int age;      public Person(String name, int age) {         this.name = name;         this.age = age;     } }

List<Person> people = new ArrayList<Person>();         people.add(new Person("bowen",27));         people.add(new Person("bob", 20));         people.add(new Person("Katy", 18));         people.add(new Person("Logon", 24));

List<Person> people = newArrayList(new Person("bowen", 27),                 new Person("bob", 20),                 new Person("Katy", 18),                 new Person("Logon", 24));

List<Person> oldPeople = new ArrayList<Person>();         for (Person person : people) {             if (person.getAge() >= 20) {                 oldPeople.add(person);             }         }

List<Person> oldPeople = newArrayList(filter(people, new Predicate<Person>() {             public boolean apply(Person person) {                 return person.getAge() >= 20;             }         }));

@GwtCompatible public interface Predicate<T> {   /**    * Returns the result of applying this predicate to {@code input}. This method is <i>generally    * expected</i>, but not absolutely required, to have the following properties:    *    * <ul>    * <li>Its execution does not cause any observable side effects.    * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal    *     Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==    *     predicate.apply(b))}.    * </ul>    *    * @throws NullPointerException if {@code input} is null and this predicate does not accept null    *     arguments    */   boolean apply(@Nullable T input);    /**    * Indicates whether another object is equal to this predicate.    *    * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.    * However, an implementation may also choose to return {@code true} whenever {@code object} is a    * {@link Predicate} that it considers <i>interchangeable</i> with this one. "Interchangeable"    * <i>typically</i> means that {@code this.apply(t) == that.apply(t)} for all {@code t} of type    * {@code T}). Note that a {@code false} result from this method does not imply that the    * predicates are known <i>not</i> to be interchangeable.    */   @Override   boolean equals(@Nullable Object object); }

List<Person> namedPeople = newArrayList(filter(people, new Predicate<Person>() {             public boolean apply(Person person) {                 return person.getName().contains("b");             }         }));

List<Person> filteredPeople = newArrayList(filter(people, new Predicate<Person>() {             public boolean apply(Person person) {                 return person.getName().contains("b") && person.getAge() >= 20;             }         }));

private Predicate<Person> ageBiggerThan(final int age) {         return new Predicate<Person>() {             public boolean apply(Person person) {                 return person.getAge() >= age;             }         };     }  private Predicate<Person> nameContains(final String str) {         return new Predicate<Person>() {             public boolean apply(Person person) {                 return person.getName().contains(str);             }         };     }

List<Person> filteredPeople = newArrayList(filter(people, and(ageBiggerThan(20), nameContains("b"))));

List<String> names = new ArrayList<String>();         for (Person person : people) {             names.add(person.getName());         }

List<String> names = newArrayList(transform(people, new Function<Person, String>() {             public String apply( Person person) {                 return person.getName();             }         }));

@GwtCompatible public interface Function<F, T> {   /**    * Returns the result of applying this function to {@code input}. This method is <i>generally    * expected</i>, but not absolutely required, to have the following properties:    *    * <ul>    * <li>Its execution does not cause any observable side effects.    * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal    *     Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),    *     function.apply(b))}.    * </ul>    *    * @throws NullPointerException if {@code input} is null and this function does not accept null    *     arguments    */   @Nullable T apply(@Nullable F input);    /**    * Indicates whether another object is equal to this function.    *    * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.    * However, an implementation may also choose to return {@code true} whenever {@code object} is a    * {@link Function} that it considers <i>interchangeable</i> with this one. "Interchangeable"    * <i>typically</i> means that {@code Objects.equal(this.apply(f), that.apply(f))} is true for all    * {@code f} of type {@code F}. Note that a {@code false} result from this method does not imply    * that the functions are known <i>not</i> to be interchangeable.    */   @Override   boolean equals(@Nullable Object object); }

public interface Func<F,T> {           T apply(F currentElement, T origin);       }

public class Reduce {     private Reduce() {      }      public static <F,T> T reduce(final Iterable<F> iterable, final Func<F, T> func, T origin) {          for (Iterator iterator = iterable.iterator(); iterator.hasNext(); ) {             origin = func.apply((F)(iterator.next()), origin);         }          return origin;     } }

Integer ages = Reduce.reduce(people, new Func<Person, Integer>() {              public Integer apply(Person person, Integer origin) {                 return person.getAge() + origin;             }         }, 0);

Integer maxAge = Reduce.reduce(people, new Func<Person, Integer>() {              public Integer apply(Person person, Integer origin) {                 return person.getAge() > origin ? person.getAge() : origin;             }         }, 0);

List<String> names = from(people).filter(ageBiggerThan(20)).transform(getName()).toList();