Java8?Lamdba函數(shù)式推導(dǎo)的語法怎么表達(dá)

本篇內(nèi)容介紹了“Java8 Lamdba函數(shù)式推導(dǎo)的語法怎么表達(dá)”的有關(guān)知識，在實(shí)際案例的操作過程中，不少人都會(huì)遇到這樣的困境，接下來就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！

前言

有且只有一個(gè)抽象函數(shù)的接口就是函數(shù)式接口，利用函數(shù)式接口我們就可以創(chuàng)建lamdba，但是其中可以包括靜態(tài)方法和default

1，lamdba表達(dá)式的語法

首先我們來看一個(gè)簡單的lamdba表達(dá)式的應(yīng)用，就是在創(chuàng)建線程時(shí)候

        //創(chuàng)建一個(gè)線程，將線程的名字打印出來
        new Thread(()-
       System.out.println(Thread.currentThread().getName())).start();
        Thread.currentThread().join();
        //Thread-0

看下面的例子：

        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());

我們不難看到lamdba的語法構(gòu)成如下:

參數(shù)+函數(shù)體就像上面的o1 和o2就是參數(shù)，后面的就是函數(shù)體 （Apple a） -> a.getColor() （parameters）-> expression (parameters) ->{statements}

compareTo函數(shù)介紹：

 // 根據(jù)Unicode來判斷，返回一個(gè)boolean 根據(jù)boolean來說明，這兩個(gè)對象需不需要交換，其實(shí)我們可以不用這個(gè)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;
    }

2，常見的函數(shù)式接口

• Predicate boolean test(T t)

• Consumer accept(T t)

• Function<T, R> R apple(T,t)

• Supplier T get()

Predicate ：傳入一個(gè)變量返回一個(gè)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);
//我們發(fā)現(xiàn)在 filterApple 函數(shù)里面我們傳入了兩個(gè)參數(shù)，一個(gè)是list 一個(gè)是Predicate抽象函數(shù)式接口，我們調(diào)用這個(gè)抽象函數(shù)式接口，但是我們不實(shí)現(xiàn)它，我們在調(diào)用的時(shí)候?qū)崿F(xiàn)它是根據(jù)重量來比較，當(dāng)然我們在調(diào)用的時(shí)候也可以根據(jù)顏色來比較
/**
舉一反三：Predicate是傳入一個(gè)參數(shù)進(jìn)行判斷，BiPredicate是傳入兩個(gè)參數(shù)進(jìn)行判斷，例如下面的例子
*/

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傳入兩個(gè)參數(shù)，根據(jù)顏色和重量來進(jìn)行比較，我們在調(diào)用的時(shí)候可以實(shí)現(xiàn)者兩個(gè)參數(shù)的比較規(guī)則
}

Consumer 這個(gè)單詞中文意思是消費(fèi)者，既然消費(fèi)了就不會(huì)有返回值

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()));
/**
從上面我們可以看到 這個(gè)Consumer不會(huì)返回任何對象
舉一反三: 上面有BiPredicate，那么我們這個(gè)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);
		}
})
//學(xué)習(xí)玩上面的例子 我再提一個(gè) LongConsumer，從字面上看，我們知道，它接收的是一個(gè)Long類型的，其他的并沒什么區(qū)別，這里我們就不多啰嗦了

Function：函數(shù)，我們知道函數(shù)都是有輸出的，這里的意思也就是說傳入一個(gè)參數(shù)，返回一個(gè)參數(shù)，下面我們來看下怎么使用這個(gè)Function

 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);
//在這里我們可以看到，F(xiàn)unction函數(shù)的apply抽象方法接收一個(gè)值，返回一個(gè)Long類型的值

//根據(jù)上面的經(jīng)驗(yàn)，想必大家也已經(jīng)知道了還有 BiFunction 這個(gè)函數(shù)式接口，沒錯(cuò)它只是傳進(jìn)去的參數(shù)有兩個(gè)而已，還是返回一個(gè)結(jié)果。除此之外還有呢，大家別著急，還有  IntFunction DoubleFunction,這些有什么作用呢，其實(shí)可以看成是Function的具體情況  IntFuntion也就是  apply里面的參數(shù)是Int類型的 DoubleFunction也就是apply的參數(shù)是double類型的，大家再看一下，是不是非常非常的簡單呢

Supplier：這個(gè)單詞的意思是提供的意思，那也就是給你返回?cái)?shù)據(jù)，這個(gè)函數(shù)接口里面會(huì)給你返回?cái)?shù)據(jù)，不需要你傳入數(shù)據(jù)

    private static Apple  getApple(Supplier<Apple> supplier){
       return  supplier.get();
    }
    //使用
        Apple green1 = getApple(() -> new Apple("green", 150));
        System.out.println(green1);
   //有人肯定再想了，這樣創(chuàng)建對象那不是脫褲子放屁嗎 多此一舉，這里只是舉一個(gè)小例子，在實(shí)際開發(fā)中肯定不會(huì)這樣

3，Lamdba表達(dá)式之函數(shù)式推導(dǎo)

• 1，通過一個(gè)類的靜態(tài)方法去推斷

• 2，用對象的實(shí)例方法去推斷

    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");
   //思考我們?yōu)槭裁纯梢詫懗蛇@樣呢，我們看下println的源碼
       // public final static PrintStream out = null;，在源碼里面我們可以看到PrintStream是一個(gè)靜態(tài)的類，而println是這個(gè)靜態(tài)類下面的方法，因此可以做函數(shù)推導(dǎo)
       public void println(String x) {
       //剛好是接收一個(gè)參數(shù)，沒有返回
        synchronized (this) {
            print(x);
            newLine();
        }
    }

```再舉個(gè)例子

```java
//將字符串轉(zhuǎn)換成數(shù)字
int  value = Integer.parseInt("123")
 Function<String, Integer> stringFunction = Integer::parseInt;
 Integer result = stringFunction.apply("123");
 System.out.println(result)
 /**
 很多人看到這里就很納悶了，怎么冒出一個(gè) Function來了呢，這就是類方法推導(dǎo)，parseInt是Integer的類方法它需要傳入一個(gè)數(shù)，然后輸出一個(gè)數(shù)，這樣的模式就是前面我們介紹的Function函數(shù)式接口，接著再來看一個(gè)例子
 */
 String string = new String("hello");
 Function<Integer, Character> f = string::charAt;
 Character c = f3.apply(4);
 System.out.println(c);

構(gòu)造函數(shù)推導(dǎo)：

Supplier<String> supplier = String::new
String s = supplier.get();
System.out.print(s)
//但是Apple是兩個(gè)構(gòu)造參數(shù)的，怎么辦呢，還是有辦法的
BiFunction<String, Long,Apple> appleFunction = Apple::new;
Apple apple = appleFunction.apply("red",100L);
//如果有更多的參數(shù)呢，在這里我們就可以自定義函數(shù)式接口
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 這樣自定義的函數(shù)式接口就完成了

例子：sort分類與函數(shù)式推導(dǎo)

//定義一個(gè)集合
  static List<Apple> listApple = Arrays.asList(
            new Apple("green",122),
            new Apple("red",  34),
            new Apple("black",135),
            new Apple("green",114),
            new Apple("yellow",54),
            new Apple("yellow",94));
 //以前我們排序的時(shí)候只知道調(diào)用 sort方法例如
 listAplle.sort()
 //但是我們不知道它怎么操作的，下面我們可以自定義排序的規(guī)則
 list.sort() //寫道這里系統(tǒng)提示參數(shù)可以為Comparator，我們接著寫
 list.sort(new Comparator<Apple>{
	public int compare(Apple o1, Apple o2){
		return o1.getColor().compareTo(o2.getColor());
	}
})
 //從上面的里例子來看我們是根據(jù)apple的顏色來進(jìn)行比較的，當(dāng)然我們也可以根據(jù)apple的weight來進(jìn)行比較.接著我們進(jìn)行函數(shù)推導(dǎo)
 list.sort(Comparator.comparing(Apple::getColor))
 //就這么一句完全代替了我們上面的功能，很明顯簡化了代碼

“Java8 Lamdba函數(shù)式推導(dǎo)的語法怎么表達(dá)”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識可以關(guān)注億速云網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實(shí)用文章！