Getting started with lambda8 new features

Lambda8 Getting started with new features

In our daily development process , I can't avoid writing some simple functions , for instance , Multiply each person's age by two to return , Judge whether the age is older than 18 wait , If every time you encounter this kind of problem , If we all write a function , It seems to be a little troublesome , But in java8 in , Encapsulate all these functions , It can be divided into the following four types

name	describe	Corresponding method	Enter the reference ( type )	The ginseng ( type )
Function<S,T>	Functional	apply	Y	Y(T)
Consumer	Consumer type	accept	Y	N
Supplier	Application type	get	N	Y
Predicate	Judgmental	test	Y	Y

Example

Function

• Use scenarios : By entering a value , You also need to return the corresponding result value after processing

• The type of acceptance is String

• The return type is Integer

Function<String, Integer> function = s ->{
    
    return 1;
};
System.out.println (function.apply ("200"));

Consumer

• Use scenarios ： By entering a certain value , Don't care about the returned results , Most commonly used for Flow computation

• The type of acceptance is String

• no return value

Consumer<String> consumer = s -> {
    
    System.out.println (s + "22");
};
consumer.accept ("dasdsa");

Supplier

• Use scenarios ： No participation , But I want to get some kind of return value , It is usually used to obtain a certain Pool resources , For example, get jedis The connection of , Database connection, etc

• You do not need to accept parameters

• The type of return is String

Supplier<String> supplier = () -> {
    
    return "wew";
};
System.out.println (supplier.get ());

Predicate

• Use scenarios ： Accept one String Parameters of type , This parameter is logically calculated , Finally, you need to return a 0/1 The logical value of , For example, it is to judge whether a student is older than 14 wait

• The accepted type is String

• The return type is always bool

Predicate<String> predicate = s -> {
    
    return s.length () > 0;
};
System.out.println (predicate.test ("ewe"));

The above seems a little too simple , Let's have some advanced ones

Give the following code snippet , Print out Age >=18, Gender is ’ Woman ’, The man's id Or name and return a

List<Student> studentList = new ArrayList<>();
		studentList.add(new Student(1, " Zhang San ", 10, " male "));
        studentList.add(new Student(2, " Li Si ", 7, " male "));
        studentList.add(new Student(3, " Xi Shi ", 20, " Woman "));
        studentList.add(new Student(4, " The sable cicada ", 18, " Woman "));

Their thinking

• loop list Filter out age >= 18 Get a collection list1

• loop list1, Filter out gender =‘ Woman ’ Get a collection list2

• Loop print out list2

  The approximate code is as follows

   List<Student> list1 = new ArrayList<>();
          for (Student student : studentList){
        
              if (student.getAge() >= 18){
        
                  list1.add(student);
              }
          }
          List<Student> list2 = new ArrayList<>();
          for (Student student : list1){
        
              if (" Woman ".equals(student.getSex())){
        
                  list2.add(student);
              }
          }
  
          System.out.println(list2.get(0));
  

  It seems that there are a lot , And there is a lot of repetitive code , But the overall logic is relatively clear , Nothing wrong , So is there an optimized way to write ？？？

Optimized version

Here, we consider the adoption of the above jdk Several methods are provided , The specific code is as follows

        String studentName = studentList.stream()
                .filter(x -> x.getAge() >= 18)
                .filter(x -> " Woman ".equals(x.getSex()))
                .map(Student::getName)
                .collect(Collectors.toList())
                .get(0);
        System.out.println(studentName);

The code has been modified , It is more regular than the previous version （ grace ） A lot , In the following code, we can often use this kind of streaming programming , It can greatly simplify the readability of our code .

In the above functions , Accept the following parameter types

• filter

public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate)

• map

public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper)

That's what we're sharing , Welcome to communicate and discuss with us ~~~