java lambda 语法糖 使用

lambda

介绍

算了， 没啥可介绍的。 就-> 的一种写法.

start

主要是实现@FunctionalInterface 注解,java8 之后 已经有些接口有了@FunctionalInterface 就可以使用lambda 语法糖.例如:
java.util.function.Consumer、java.lang.Runnable、java.util.concurrent.Callable、java.util.Comparator 等

例如
1.java.lang.Runnable 原来的实现方式是

Thread thread = new Thread(new Runnable() {
	@Override
	public void run() {
		//TODO 实现线程方式
		System.out.println("hello world");
	}
});

thread.start();

lambda 的实现方式

Thread thread = new Thread(() -> {
	System.out.println("hello world");
});

thread.start();

2.list 排序

原来

List<String> list = Arrays.asList("a","c","d","b");
for (String str: list) {
   System.out.println(str);
}

lambda 实现方式

List<String> list = Arrays.asList("a","c","d","b");
list2.forEach(str-> System.out.println(str));
// 双引号 lambda
// list.forEach(System.out::println);

自己实现了一个 @FunctionalInterface 的排序。

1. IComparable.java

     @FunctionalInterface
     public interface IComparable<T> {
   
     public int toCompare(T a, T b);
   }
   

2. ArrayImpl.java

   import com.google.common.collect.Lists;
   
   import java.util.ArrayList;
   import java.util.List;
   /**
    * 仅仅是为了测试 lambda
    * @param <T>
    */
   public class ArrayImpl<T> {
       private IComparable<T> comparable;
       public ArrayImpl(IComparable<T> comparable) {
           this.comparable =  comparable;
       }
   
       public void setComparable(IComparable<T> comparable) {
           this.comparable = comparable;
       }
   
       public void sort(List<T> list) {
           Lists.newCopyOnWriteArrayList(list);
           List<T> sortedList = new ArrayList<>();
           for (int i = 0; i < list.size(); i++) {
               int index2 = i;
               for (int j = i+1; j <list.size() ; j++) {
                   if (comparable.toCompare(list.get(i), list.get(j)) >= 0) {
                       index2 = j;
                   }
               }
               if (index2 != i) {
                   swap(list, i, index2);
               }
           }
       }
   
       private void swap(List<T> list, int index, int index2) {
           T temp = list.get(index);
           list.set(index, list.get(index2));
           list.set(index2, temp);
       }
   
   }
   

3. LambdaTest.java

   import com.alibaba.fastjson.JSONObject;
   import org.junit.Test;
   
   import java.util.Arrays;
   import java.util.List;
   
   public class LambdaTest {
   
     @Test
     public void lambdaSlefImpl() {
         List<String> list = Arrays.asList("a","c","d","b");
   
         ArrayImpl<String> impl = new ArrayImpl<String>((a, b)-> a.compareTo(b));
         impl.sort(list);
         list.forEach(System.out::println);
   
         List<JSONObject> list2 = Arrays.asList(
                 new JSONObject(){{put("name","logan");put( "age", 10);}},
                 new JSONObject(){{put("name","logan");put( "age", 21);}},
                 new JSONObject(){{put("name","logan");put( "age", 19);}}
         );
   
         ArrayImpl<JSONObject> impl2 = new ArrayImpl<JSONObject>((a, b)-> a.getInteger("age")-b.getInteger("age"));
         impl2.sort(list2);
         list2.forEach(json -> System.out.println(json.toJSONString()));
         // list2.forEach(System.out::println);
     }
   }
   

lambda 双引号（::）

介绍

算了， 没啥可介绍的。 就:: 的一种写法.

start

直接上例子

 @Test
    public void lambdaColon() {
        Person[] persons = {
                new Person("Logan", 12),
                new Person("Frank", 12),
                new Person("Leo", 22),
                new Person("Linda", 10)
        };
        List<Person> list = Arrays.asList(persons);

        list.forEach(System.out::println);
        List<String> collect = Arrays.stream(persons).map(Person::getName).collect(Collectors.toList());
        Function<Person, Integer> getAge = Person::getAge;
        List<Integer> collect2 = Arrays.stream(persons).map(person -> getAge.apply(person)).collect(Collectors.toList());

        collect.forEach(System.out::println);
        collect2.forEach(System.out::println);
        // print
        //        Person{name='Logan', age=12}
		//        Person{name='Frank', age=12}
		//        Person{name='Leo', age=22}
		//        Person{name='Linda', age=10}
		//        Logan
		//                Frank
		//        Leo
		//                Linda
		//        12
		//        12
		//        22
		//        10
		    }

在lambda 语法糖 中 person -> getAge.apply(person) 和 Person::getAge 等同