Functional interface, method reference, list collection sorting gadget implemented by lambda

1. stay Java8 A functional interface is introduced in Consumer The object of , This object can pass methods as parameters .
About lambda A tutorial for

/** *  Collection sorting  */
@AllArgsConstructor
public class CollSort {
    

    //  Sorting factor 
    private final Long order;

    public final static CollSort DESC = new CollSort(-1L);
    public final static CollSort ASC = new CollSort(1L);

    //  Sort by number 
    public <E> Collection<E> sort(Collection<E> collection, ProcessorNumber<E> getParam) {
    
        return collection.stream()
                .filter(Objects::nonNull)
                .sorted((o1, o2) -> {
    
                    //  The incoming abstract method is executed here , And pass in the parameters required by the function method ,
                    // getParam The return value of has been determined in the abstract function method 
                    long result = Long.parseLong(String.valueOf(getParam.accept(o1))) - Long.parseLong(String.valueOf(getParam.accept(o2)));
                    result = result * order; //  Ranking coefficient intervention 
                    return result == 0 ? 0 : result < 0 ? -1 : 1;
                })
                .collect(Collectors.toList());
    }

    //  Sort by time 
    public <E> Collection<E> sort(Collection<E> collection, ProcessorDate<E> getParam) {
    
        return collection.stream()
                .filter(Objects::nonNull) //  Invalid data filtering 
                .sorted((o1, o2) -> {
    
                    long t1 = getParam.accept(o1).getTime(); //  Here are abstract methods getParam The return value of has been determined in the abstract function method 
                    long t2 = getParam.accept(o2).getTime();
                    long result = t1 - t2;
                    result = result * order; //  Ranking coefficient intervention 
                    return result == 0 ? 0 : result < 0 ? -1 : 1;
                })
                .collect(Collectors.toList());
    }

}

@FunctionalInterface
interface ProcessorDate<E> {
    

    /** *  Abstract function method to obtain the time attribute of the object  * * @param t  object  * @return  The time property of the object  */
    Date accept(E t);
}

@FunctionalInterface
interface ProcessorNumber<E> {
    

    /** *  Abstract function method to obtain the numerical attributes of an object  * * @param t  object  * @return  Numerical properties of objects  */
    Number accept(E t);
}

Use

  public static void main(String[] args) {
    
     SortTest sortTest = new SortTest();
     ArrayList<User> users = new ArrayList<>();
     users.add(new User("zz", 14,new Date()));
     users.add(new User("zz", 17,new Date(System.currentTimeMillis()+1000000)));
     users.add(new User("zz", 11,new Date(System.currentTimeMillis()+4000000)));
     users.add(new User("zz", 15,new Date(System.currentTimeMillis()+9000000)));
     users.add(new User("zz", 21,new Date(System.currentTimeMillis()+8000000)));
     users.add(new User("zz", 7,new Date(System.currentTimeMillis()+3000000)));
     sortTest.test(users);
 }
 public void test(List<User> users) {
    
     //  Just call ordinary tool methods , The difference is that the parameter is a method , You can also directly reference methods 
     Collection<User> ageSort = CollSort.ASC.sort(users, User::getAge);
     System.out.println(" Age ranking =========================");
     ageSort.forEach(System.out::println);
     System.out.println(" Birthday sorting ======================");
     Collection<User> timeSort = CollSort.DESC.sort(users, User::getBirthDay);
     timeSort.forEach(System.out::println);
 }

effect

You can expand the function interface according to your needs , We need to pay attention to Parameter type and return type , Most of the time, it is enough to change the return value type ;

Parameter types and return value types affect the parameters that need to be passed in when calling this function method , And response value