jdk1.8的lambda表达式的简单例子

package model;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Person
implements Cloneable{

    private String
name;

    private int   
age;

    private double
salary;
    
    private Date 
birthday;

    public Person() {

    }

    
    /**
     * @param name
     * @param age
     * @param salary
     * @param birthday
     */
    public Person(String
name, int age,
double salary, Date birthday) {
        this.name =
name;
        this.age =
age;
        this.salary =
salary;
        this.birthday =
birthday;
    }

    /**
     * @param name
     * @param age
     * @param salary
     */
    public Person(String
name, int age,
double salary) {
        this.name =
name;
        this.age =
age;
        this.salary =
salary;
    }

    /**
     * @param name
     * @param age
     */
    public Person(String
name, int age) {
        this.name =
name;
        this.age =
age;
    }

    /**
     * Getter method for property <tt>name</tt>.
     * 
     * @return property value of name
     */
    public String getName() {
        return
name;
    }

    /**
     * Setter method for property <tt>name</tt>.
     * 
     * @param name value to be assigned to property name
     */
    public void setName(String
name) {
        this.name =
name;
    }

    /**
     * Getter method for property <tt>age</tt>.
     * 
     * @return property value of age
     */
    public int getAge() {
        return
age;
    }

    /**
     * Setter method for property <tt>age</tt>.
     * 
     * @param age value to be assigned to property age
     */
    public void setAge(int
age) {
        this.age =
age;
    }

    /**
     * Getter method for property <tt>salary</tt>.
     * 
     * @return property value of salary
     */
    public double getSalary() {
        return
salary;
    }

    /**
     * Setter method for property <tt>salary</tt>.
     * 
     * @param salary value to be assigned to property salary
     */
    public void setSalary(double
salary) {
        this.salary =
salary;
    }
    
    

    /**
     * Getter method for property <tt>birthday</tt>.
     * 
     * @return property value of birthday
     */
    public Date getBirthday() {
        return
birthday;
    }

    /**
     * Setter method for property <tt>birthday</tt>.
     * 
     * @param birthday value to be assigned to property birthday
     */
    public void setBirthday(Date
birthday) {
        this.birthday =
birthday;
    }

    /** 
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object
obj) {
        if(obj
instanceof Person){
            Person comparePerson=(Person)obj;
            return
this.age==comparePerson.getAge();
        }
        return false;
    }

    
    

    /** 
     * @see java.lang.Object#clone()
     */
    @Override
    public Object clone()
throws CloneNotSupportedException {
        return
super.clone();
    }

    /** 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        SimpleDateFormat format=new SimpleDateFormat("YYYY-MM-dd");
        String finalBirthday="";
        if(this.getBirthday()!=null){
            finalBirthday=format.format(birthday);
        }
        return
"Person [name=" + name +
", age=" + age +
", salary=" + salary +
", birthday="
               + finalBirthday +
"]";
    }
}

package stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.OptionalDouble;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

import model.Person;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

public class StreamTest {

    /**
     * 
     * @param args
     */

    public static
void init(List<Person> persons) {
        Person person =
new Person();
        person.setAge(15);
        person.setName("yy");
        Person person1 =
new Person();
        person1.setAge(12);
        person1.setName("lisi");
        Person person2 =
new Person();
        person2.setAge(12);
        person2.setName("zangwu");
        persons.add(person);
        persons.add(person1);
        persons.add(person2);
    }

    public static
void printPerson(List<Person> persons) {
        persons.stream().forEach((o) -> System.out.println(o.getAge() +
"--" + o.getName()));
    }

    public static
void printPersonInfo(List<PersonInfo> persons) {
        persons.stream().forEach((o) -> System.out.println(o.getAge() +
"--" + o.getName()));
    }

    public static
void main(String[] args) {

        List<Person> persons = Lists.newArrayList();
        init(persons);
        printPerson(persons);
        System.out.println("---------------");
        List<Person> ageFilter =
persons.stream().filter((o) ->
o.getAge() > 11)
            .collect(Collectors.toList());
        printPerson(ageFilter);
        System.out.println("---------------");
        List<Person> sortPerson =
persons.stream().sorted(sortByRule())
            .collect(Collectors.toList());
        printPerson(sortPerson);
        System.out.println("---------------");
        List<PersonInfo> personInfos =
persons.stream().map(o -> convertToPersonInfo(o))
            .collect(Collectors.toList());
        printPersonInfo(personInfos);
        System.out.println("---------------");
        List<Person> limitPersons =
persons.stream().filter((o) ->
o.getAge() > 11).limit(1)
            .collect(Collectors.toList());
        printPerson(limitPersons);
        System.out.println("---------------");
        int ageCount =
persons.stream().mapToInt(Person::getAge).sum();
        System.out.println("所有人的年龄的和" +
ageCount);
        System.out.println("---------------");
        //针对persons集合进行虚拟分页功能
        int pageSize = 2;
        int pageNum = 1;
        int size =
persons.size();
        int from = (pageNum - 1) *
pageSize;
        int
to = pageNum * pageSize;
        if (size >
from) {
            List<Person> subListPerson =
persons.subList(from, Math.min(to,
size)).stream()
                .collect(Collectors.toList());
            printPerson(subListPerson);
        }
        System.out.println("---------------");
        List<Person> skipPersons =
persons.stream().skip(1).collect(Collectors.toList());
        printPerson(skipPersons);
        System.out.println("---------------");
        OptionalDouble average =
persons.stream().mapToInt(Person::getAge).distinct().average();
        System.out.println(average.getAsDouble());
        System.out.println("---------------");
        List<Integer> aa = Lists.newArrayList();
        aa.add(1);
        aa.add(1);
        aa.add(2);
        aa.add(3);
        aa.add(0);
        int aaListSize = (int)
aa.stream().distinct().count();
        System.out.println(aaListSize);
        System.out.println("---------------");

        Map<String, Integer> personInfos1 =
persons.stream().map(o -> convertToPersonInfo(o))
            .collect(Collectors.toMap(PersonInfo::getName, PersonInfo::getAge));
        System.out.println(personInfos1);
        System.out.println("---------------");

        List<Map<String, Integer>> personMap =
persons.stream().map(o -> convertPersonTo(o))
            .collect(Collectors.toList());
        System.out.println(personMap);
        System.out.println("---------------");
        Person p =
persons.stream().findFirst().get();
        System.out.println(p);
        System.out.println("---------------");
        //集合最小
        int min = (int)
aa.stream().min((p1,
p2) -> p1 - p2).get();
        System.out.println(min);
        System.out.println("---------------");
        //集合最大
        int max = (int)
aa.stream().max((p1,
p2) -> p1 - p2).get();
        System.out.println(max);
        System.out.println("---------------");
        //集合最大
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        IntSummaryStatistics stats =
numbers.stream().mapToInt((x) ->
x).summaryStatistics();

        System.out.println("List中最大的数字 : " +
stats.getMax());
        System.out.println("List中最小的数字 : " +
stats.getMin());
        System.out.println("所有数字的总和
  : " + stats.getSum());
        System.out.println("所有数字的平均值 : " +
stats.getAverage());
        System.out.println("---------------");

        String nameList =
persons.stream().map(Person::getName).collect(Collectors.joining(";"));
        System.out.println(nameList);
        System.out.println("---------------");

        Set<Integer> ageSet =
persons.stream().map(Person::getAge).collect(Collectors.toSet());
        System.out.println(ageSet);
        System.out.println("---------------");

        TreeSet<Integer> ageTreeSet =
persons.stream().map(Person::getAge)
            .collect(Collectors.toCollection(TreeSet::new));
        System.out.println(ageTreeSet);
        System.out.println("---------------");

        //聚合操作
        Map<Integer, List<String>> res =
persons.stream().collect(
            Collectors.groupingBy(Person::getAge,
                Collectors.mapping(Person::getName, Collectors.toList())));
        System.out.println(res);
        System.out.println("---------------");
        Map<String, Double> res1 =
persons.stream().collect(
            Collectors.groupingBy(Person::getName, Collectors.averagingDouble(Person::getAge)));
        System.out.println(res1);
        System.out.println("---------------");

        int sum =
aa.stream().map((x) ->
x).reduce(0, (x, y) ->
x + y);
        int sum1 =
aa.stream().mapToInt((x) ->
x).sum();
        System.out.println(sum);
        System.out.println(sum1);
        System.out.println("---------------");

        String[] strs = {
"java8", "is", "easy",
"to", "use" };
        List<String[]> distinctStrs = Arrays.stream(strs).map(str ->
str.split("")) // 映射成为Stream<String[]>
 
            .distinct().collect(Collectors.toList());
        distinctStrs.forEach(strings -> Arrays.stream(strings).forEach(s -> System.out.println(s)));

        System.out.println("==================================map方式");

        List<String> distinctStrsByFlatMap = Arrays.stream(strs).map(str ->
str.split("")) // 映射成为Stream<String[]>
 
            .flatMap(Arrays::stream)
// 扁平化为Stream<String>  
            .distinct().collect(Collectors.toList());

        distinctStrsByFlatMap.forEach(s -> System.out.println(s));

        System.out.println("==================================flatMap的方式");

        List<List<String>> testFlatMap =
new ArrayList<List<String>>();
        List<String> aaa =
new ArrayList<String>();
        aaa.add("a");
        aaa.add("a");
        aaa.add("c");
        aaa.add("b");
        List<String> aaa1 =
new ArrayList<String>();
        aaa1.add("ab");
        aaa1.add("ab");
        aaa1.add("cc");
        aaa1.add("bd");
        testFlatMap.add(aaa);
        testFlatMap.add(aaa1);

        System.out.println(testFlatMap.stream().flatMap(List::stream)
            .collect(Collectors.joining(";")));
        System.out.println("---------------");
        Set<String>  flatMap=testFlatMap.stream().flatMap(List::stream).collect(Collectors.toSet());
        System.out.println(flatMap);
        System.out.println("---------------");
    }

    private static Map<String, Integer> convertPersonTo(Person
person) {
        Map<String, Integer> personMap = Maps.newHashMap();
        personMap.putIfAbsent(person.getName(),
person.getAge());
        return
personMap;

    }

    private static PersonInfo convertToPersonInfo(Person
person) {
        PersonInfo personInfo =
new PersonInfo();
        personInfo.setAge(person.getAge());
        personInfo.setName(person.getName());
        return
personInfo;
    }

    private static Comparator<Person> sortByRule() {
        Comparator<Person> age = ((o1,
o2) -> {
            return Integer.compare(o2.getAge(),
o1.getAge());
        });
        Comparator<Person> name = ((o1,
o2) -> {
            return
o1.getName().compareTo(o2.getName());
        });
        return
age.thenComparing(name.reversed());
    }

    private static
class PersonInfo {
        private String
name;
        private
int    age;

        /**
         * Getter method for property
<tt>name</tt>.
         * 
         * @return property value of name
         */
        public String getName() {
            return
name;
        }

        /**
         * Setter method for property
<tt>name</tt>.
         * 
         * @param name value to be assigned to property name
         */
        public
void setName(String name) {
            this.name =
name;
        }

        /**
         * Getter method for property
<tt>age</tt>.
         * 
         * @return property value of age
         */
        public
int getAge() {
            return
age;
        }

        /**
         * Setter method for property
<tt>age</tt>.
         * 
         * @param age value to be assigned to property age
         */
        public
void setAge(int age) {
            this.age =
age;
        }

    }

}