好程序员大数据培训分享 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. 将运行阶段的问题提前到编译阶段检查 , 提高了代码的安全性和编程效率

ITPub博客

好程序员大数据学习路线分享Lambda表达式

最新文章