Bagaimana untuk menyatakan sintaks terbitan berfungsi dalam Java8 Lamdba

Kata Pengantar

Antara muka dengan satu dan hanya satu fungsi abstrak ialah antara muka berfungsi Dengan menggunakan antara muka berfungsi, kita boleh mencipta lamdba, tetapi ia boleh termasuk kaedah statik dan lalai

1, Ungkapan lamdba. sintaks

Pertama, mari kita lihat aplikasi ungkapan lambba yang mudah, iaitu semasa mencipta benang

        //创建一个线程，将线程的名字打印出来
        new Thread(()-
       System.out.println(Thread.currentThread().getName())).start();
        Thread.currentThread().join();
        //Thread-0

Lihat contoh berikut :

        Comparator<Apple> byColor = new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return o1.getColor().compareTo(o2.getColor());
            }
        };
        listApple.sort(byColor);
        Comparator<Apple> byCOlor2 = (o1,o2) -> o1.getColor().compareTo(o2.getColor());

Kita boleh melihat dengan mudah bahawa sintaks lamdba terdiri seperti berikut:

参数+函数体Sama seperti o1 dan o2 di atas adalah parameter, dan yang berikut Ia ialah badan fungsi (Apple a) -> a.getColor() (parameter) -> 🎜>

2, antara muka berfungsi biasa

 // 根据Unicode来判断，返回一个boolean 根据boolean来说明，这两个对象需不需要交换，其实我们可以不用这个CompareTo，我们可以自己写判断条件，只要是返回boolean就行
  public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

Ujian boolean predikat(T t)

• Pengguna terima( T t)

• Fungsi469df1b70b2914a3841e0404ec3e3d5d R apple(T,t)

• Pembekal T get()

• Predikat:
Lepaskan pembolehubah dan kembalikan nilai Boolean

private static List<Apple> filterApple(List<Apple> list, Predicate<Apple> predicate){
        List<Apple> lists = new ArrayList<>();
        for (Apple apple:list){
            if (predicate.test(apple)){
                lists.add(apple);
            }
        }
        return lists;
    }
//使用
        List<Apple> list = filterApple(listApple, apple -> apple.getWeight() > 100);
        System.out.println(list);
//我们发现在 filterApple 函数里面我们传入了两个参数，一个是list 一个是Predicate抽象函数式接口，我们调用这个抽象函数式接口，但是我们不实现它，我们在调用的时候实现它是根据重量来比较，当然我们在调用的时候也可以根据颜色来比较
/**
举一反三：Predicate是传入一个参数进行判断，BiPredicate是传入两个参数进行判断，例如下面的例子
*/

private static List<Apple> filterAppleByBiPredicaTe(List<Apple> apples, BiPredicate<String, Long> predicate){
List<Apple> lists = new ArrayList()
for(Apple apple:apples){
	if (predicate.test(apple.getColor(),apple.getWeight())){
			lists.add(apple)
	}
}
//从上面的例子上来看我们知道BiPredicate传入两个参数，根据颜色和重量来进行比较，我们在调用的时候可以实现者两个参数的比较规则
}

Consumer 这个单词中文意思是消费者，既然消费了就不会有返回值Fungsi:

Fungsi , kita tahu bahawa semua fungsi mempunyai output, yang bermaksud menghantar parameter dan mengembalikan parameter Mari kita lihat cara menggunakan Fungsi ini

private static void printlnApple(List<Apple> list, Consumer<Apple> consumer){
        if (list.size()>0){
            for (Apple apple:list){
                consumer.accept(apple);
            }
        }
    }
//使用
printlnApple(listApple,apple -> System.out.println(apple.getColor()));
/**
从上面我们可以看到 这个Consumer不会返回任何对象
举一反三: 上面有BiPredicate，那么我们这个Consumer有没有BiConsumer，答案肯定是有的，下面我们来看下BiConsumer的用法
*/
private static void printGreenAppleByBiConsumer(List<Apple> apples, Consumer<Apple, String> consumer){
	if(apples.size()>0){
		for(Apple apple:apples){
			consumer.accept(apple, apple.getColor())
		}
	}
}
//使用
printGreenAppleByBiConsumer(list,(apple, color)->{
	if(apple.getWeight()>100&&color.equal("green")){
		System.out.println(apple);
		}
})
//学习玩上面的例子 我再提一个 LongConsumer，从字面上看，我们知道，它接收的是一个Long类型的，其他的并没什么区别，这里我们就不多啰嗦了

Pembekal: Maksud perkataan ini adalah untuk menyediakan, iaitu, untuk mengembalikan data kepada anda Antara muka fungsi ini akan mengembalikan data kepada anda dan tidak memerlukan anda untuk menghantar data

 private static Long getWeightList(Apple apple, Function<Apple,Long> function)
    {
        return function.apply(apple);
    }
//使用
  Long green = getWeightList(new Apple("green", 120), Apple::getWeight);
        System.out.println(green);
//在这里我们可以看到，Function函数的apply抽象方法接收一个值，返回一个Long类型的值

//根据上面的经验，想必大家也已经知道了还有 BiFunction 这个函数式接口，没错它只是传进去的参数有两个而已，还是返回一个结果。除此之外还有呢，大家别着急，还有  IntFunction DoubleFunction,这些有什么作用呢，其实可以看成是Function的具体情况  IntFuntion也就是  apply里面的参数是Int类型的 DoubleFunction也就是apply的参数是double类型的，大家再看一下，是不是非常非常的简单呢

3 ungkapan Terbitan formula

    private static Apple  getApple(Supplier<Apple> supplier){
       return  supplier.get();
    }
    //使用
        Apple green1 = getApple(() -> new Apple("green", 150));
        System.out.println(green1);
   //有人肯定再想了，这样创建对象那不是脱裤子放屁吗 多此一举，这里只是举一个小例子，在实际开发中肯定不会这样

1 Gunakan kaedah statik kelas untuk membuat kesimpulan

• 2 simpulkan

• Terbitan pembina:

    private static void printstr(Consumer<String> consumer, String str){
        consumer.accept(str);
    }
    //使用
        Consumer<String> consumer = a -> System.out.println(a);
        printstr(consumer,"hello world");
   //写成
   		Consumer<String> consumer = System.out::println
   		printstr(consumer,"hello world");
   //思考我们为什么可以写成这样呢，我们看下println的源码
       // public final static PrintStream out = null;，在源码里面我们可以看到PrintStream是一个静态的类，而println是这个静态类下面的方法，因此可以做函数推导
       public void println(String x) {
       //刚好是接收一个参数，没有返回
        synchronized (this) {
            print(x);
            newLine();
        }
    }

```再举个例子

```java
//将字符串转换成数字
int  value = Integer.parseInt("123")
 Function<String, Integer> stringFunction = Integer::parseInt;
 Integer result = stringFunction.apply("123");
 System.out.println(result)
 /**
 很多人看到这里就很纳闷了，怎么冒出一个 Function来了呢，这就是类方法推导，parseInt是Integer的类方法它需要传入一个数，然后输出一个数，这样的模式就是前面我们介绍的Function函数式接口，接着再来看一个例子
 */
 String string = new String("hello");
 Function<Integer, Character> f = string::charAt;
 Character c = f3.apply(4);
 System.out.println(c);

Contoh: pengkelasan isihan dan terbitan berfungsi

Supplier<String> supplier = String::new
String s = supplier.get();
System.out.print(s)
//但是Apple是两个构造参数的，怎么办呢，还是有办法的
BiFunction<String, Long,Apple> appleFunction = Apple::new;
Apple apple = appleFunction.apply("red",100L);
//如果有更多的参数呢，在这里我们就可以自定义函数式接口
public interface CMyFuction<T,U,W,R>{
	R get(T t,U u, W w,R,r);
}
CMyFuction<String,String, Long> cmyfunction = Apple::new;
Apple apple =  cmyfunction.get("green","large",120);
//ok 这样自定义的函数式接口就完成了

Atas ialah kandungan terperinci Bagaimana untuk menyatakan sintaks terbitan berfungsi dalam Java8 Lamdba. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!