好程式設計師大資料培訓分享 Lambda 表示式，一種簡單的匿名內部類 ( 但是隻能對應只有一個抽象方法的介面 --> 函式式介面 )

- 舉例

- 無參基礎運用

```java

interface InterfaceA{

public void show();

}

public class Demo1 {

public static void main(String[] args) {

// 匿名內部類

InterfaceA a = new InterfaceA() {

public void show() {

System.out.println(" 匿名內部類的 show");

}

};

a.show();

// 透過 lambda 表示式

InterfaceA b = ()->{

System.out.println("lambda 表示式的 show");

};

b.show();

// 簡化

InterfaceA bb = ()->System.out.println(" 簡化的 lambda 表示式的 show");

bb.show();

}

```

- 帶引數基礎運用

```java

interface A{

public int add(int i,int j);

}

class B{

public int bAdd(int i,int j){

return i+j;

}

public class Lambda {

public static void main(String[] args) {

//lambda 表示式需要返回值 , 而它的程式碼塊中僅有一條省略了 return 的語句

//lambda 表示式會自動返回這條語句的結果

//A a=(i,j)->{return i+j;};

A a=(i,j)->i+j; // 基礎用法，這就很類似匿名內部類了

System.out.println(a.add(4,5));

}

interface A{

public int add(int i,int j);

}

class B{

public int bAdd(int i,int j){

return i+j;

}

public class Lambda {

public static void main(String[] args) {

A a=new B().bAdd();// 思想參考 C# 委託

System.out.println(a.add(4,5));

}

interface A{

public int add(int i,int j);

}

class B{

// 靜態

public static int bAdd(int i,int j){

return i+j;

}

public class Lambda {

public static void main(String[] args) {

// 呼叫方式不一樣了

A a=B::bAdd;// 思想參考 C# 委託

System.out.println(a.add(4,5));

}

```

- 引用類方法

```java

interface Converter{

// 將字串轉換成整數

Integer convert(String value);

}

class Test1{

public static void fun1() {

// 原來的方法

Converter converter = value->Integer.valueOf(value);

Integer v1 = converter.convert("222");

System.out.println(v1);

// 簡化

// 引用類方法

// 透過 :: 實現 , 這裡會自動將 lambda 表示式方法的引數全部傳遞給當前的方法

Converter converter2 = Integer::valueOf;

Integer v2 = converter2.convert("333");

System.out.println(v2);

}

```

- 引用特定物件的例項方法

```java

interface IA{

public void show(String message);

}

class A{

public void play(String i) {

System.out.println(" 這裡是 A 的方法 play"+" i:"+i);

}

class Test2{

public static void fun2() {

// 原來

IA ia = message->new A().play(message);

ia.show("hello");

// 簡化

IA ia2 = new A()::play;

ia2.show("world");

}

```

- 引用構造方法

```java

interface IC{

Object show(String name,int age);

}

class Person{

String name;

int age;

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

class Test4{

public static void fun4() {

IC ic = (name,age)->new Person(name, age);

Object per = ic.show("bing", 19);

System.out.println(per);

// 簡化

// 構造方法引用代替 lambda 表示式 , 函式式介面中被實現方法的全部引數傳該構造方法作為引數

IC ic2 = Person::new;

Object per1 = ic2.show("chen", 10);

System.out.println(per1);

}

```

- 應用

```java

String[] strings={"123","456","789"," 趙志陽真帥 "};

List<String> lists= Arrays.asList(strings);

lists.forEach((s)-> out.println(" 字串是 :"+s));

lists.forEach(out::println);

```

## 集合

```java

package collection;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Objects;

class Person{

private String name;

private int age;

public Person(String name, int age) {

this.name = name;

this.age = age;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Person person = (Person) o;

return age == person.age &&

Objects.equals(name, person.name);

}

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

public class Main {

public static void main(String[] args) {

ArrayList<Person> arrayList=new ArrayList<>();

Person zs=new Person(" 張三 ",20);

Person zs2=new Person(" 張三 ",20);// 將放不進去

Person ls=new Person(" 李四 ",30);

Person ww=new Person(" 王五 ",40);

//contains 判斷比較的是物件的 equals 方法。

if(!arrayList.contains(zs)){

arrayList.add(zs);

}

if(!arrayList.contains(zs2)){

arrayList.add(zs2);

}

if(!arrayList.contains(ls)){

arrayList.add(ls);

}

if(!arrayList.contains(ww)){

arrayList.add(ww);

}

Iterator iterator=arrayList.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

```

用hash 相關的容器是，重寫 equals hashcode

treeSet 還要實現 Comparable 介面並重寫 compareTo 方法。或者自定義比較器 Comparator

```java

public class Demo9 {

public static void main(String[] args) {

// 建立比較器物件

ComStrWithLength comStrWithLength = new ComStrWithLength();

// 將比較器物件交給 TreeSet

Set set = new TreeSet<>(comStrWithLength);

/*

* TreeSet 的 add 方法實現的排序 , 去重 . 透過呼叫元素的 compareTo 方法

* String 類已經實現了 Comparable 介面

*/

set.add("java");

set.add("hadoop");

set.add("spark");

set.add("HDFS");

set.add("Mapreduce");

System.out.println(set);

}

// 建立一個比較器類

class ComStrWithLength implements Comparator{

@Override

public int compare(Object o1, Object o2) {

// 比較字串的長度

if (!(o1 instanceof String)) {

throw new ClassCastException(" 型別轉換錯誤 ");

}

if (!(o2 instanceof String)) {

throw new ClassCastException(" 型別轉換錯誤 ");

}

// 向下轉型

String s1 = (String)o1;

String s2 = (String)o2;

// 先按照長度比

int num = s1.length()-s2.length();

// 長度相同 , 再按照字典順序比

return num==0?s1.compareTo(s2):num;

}

泛型

作用：

1. 使用了泛型不再需要進行容錯處理 , 向下轉型 , 強制型別轉換 ---- 簡化程式碼

2. 將執行階段的問題提前到編譯階段檢查 , 提高了程式碼的安全性和程式設計效率

好程式設計師大資料學習路線分享Lambda表示式

相關文章