1、练习题一
调用Collections.sort()方法，通过定制排序，比较两个Employee(先按年龄比，年龄相同按姓名比),使用Lambda表达式作为参数传递。
package com.yinggu.demo4;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
import com.yinggu.data.EmployeeData;
import com.yinggu.domain.Employee;
* @author 黑猴子的家
* https://www.jianshu.com/u/37fd8e2dff4c
public class TestLambda1 {
调用Collections.sort()方法
通过定制排序比较两个Employee
(先按年龄比年龄相同按姓名比)
使用Lambda表达式作为参数传递
@Test
public void test1() {
List<Employee> list = EmployeeData.getData();
Collections.sort(list, new Comparator<Employee>() {
@Override
public int compare(Employee o1, Employee o2) {
int com = o1.getAge() - o2.getAge();
if (com > 0) {
return 1;
} else if (com < 0) {
return -1;
}
return o1.getName().compareTo(o2.getName());
}
});
System.out.println(list);
System.out.println("---------------------");
Collections.sort(list, (o1, o2) -> {
int com = o1.getAge() - o2.getAge();
if (com > 0) {
return 1;
} else if (com < 0) {
return -1;
}
return o1.getName().compareTo(o2.getName());
});
System.out.println(list);
}
}
2、练习题二
（1）声明函数式接口，接口中声明抽象方法：public String getValue(String str);
（2）声明类LambdaTest，类中编写方法使用接口作为参数，将一个字符串转换成大写，并作为方法的返回值。
（3）再将一个字符串的第2个到第4个索引位置进行截取子串。
package com.yinggu.demo4;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
import com.yinggu.data.EmployeeData;
import com.yinggu.domain.Employee;
@FunctionalInterface
interface ValueInterface {
String getValue(String str);
}
* @author 黑猴子的家
* http://www.121ugrow.com/
public class TestLambda1 {
@Test
public void test2() {
// 将一个字符串转换成大写，并作为方法的返回值。
method("hello", str -> str.toUpperCase());
// 一个字符串的第2个到第4个索引位置进行截取子串。
method("我爱你北京", str -> str.substring(1, 4));
}
public void method(String str, ValueInterface vi) {
System.out.println(vi.getValue(str));
}
}
3、练习题三
（1）声明一个带两个泛型的函数式接口，泛型类型为<T,R> : T 为参数，R 为返回值。
（2）接口中声明对应抽象方法
（3）在LambdaTest类中声明方法，使用接口作为参数，计算两个long型参数的和。
（4）再计算两个long型参数的乘积
package com.yinggu.demo4;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
import com.yinggu.data.EmployeeData;
import com.yinggu.domain.Employee;
@FunctionalInterface
interface CaleInterface<T, R> {
R cale(T t1, T t2);
}
* @author 黑猴子的家
* http://www.121ugrow.com/
public class TestLambda1 {
public void method2(Long l1, Long l2, CaleInterface<Long, Double> ci) {
System.out.println(ci.cale(l1, l2));
}
@Test
public void test3() {
// 1.计算两个long型参数的和。
method2(10L, 20L, (l1, l2) -> (double) (l1 + l2));
// 2.计算两个long型参数的乘积
method2(10L, 20L, (l1, l2) -> (double) (l1 * l2));
}
}
4、练习题四
创建Book类，里面有书名、作者、价格属性，并对其进行合理封装 定义测试类，提供测试方法（要求用上Lambda表达式）
测试方法一：比较两本书大小，先判断价格，价格相等，判断书名
（1）book类
package com.yinggu.domain;
/**
* @author 黑猴子的家
* http://www.121ugrow.com/
*/
public class Book {
private String name;
private String author;
private double price;
public Book() {
super();
}
public Book(String name, String author, double price) {
super();
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book [name=" + name + ", author=" + author + ", price=" + price + "]";
}
}
（2）code
package com.yinggu.demo4;
import java.util.function.BiPredicate;
import java.util.function.Function;
import org.junit.Test;
import com.yinggu.domain.Book;
* @author 黑猴子的家
* https://www.jianshu.com/u/37fd8e2dff4c
interface MyCompare<T> {
int compare(T t1, T t2);
}
public class TestLambda2 {
@Test
public void test1() {
Book b1 = new Book("红楼梦", "曹雪芹", 100);
Book b2 = new Book("西游记", "吴承恩", 23);
compareBook(b1, b2, (o1, o2) -> {
if (o1.getPrice() > o2.getPrice())
return 1;
else if (o1.getPrice() < o2.getPrice())
return -1;
else
return o1.getName().compareTo(o2.getName());
});
}
public void compareBook(Book b1, Book b2, MyCompare<Book> com) {
System.out.println(com.compare(b1, b2));
}
}
5、练习题五
书名、作者、价格一样，则为两本书相等
package com.yinggu.demo4;
import java.util.function.BiPredicate;
import java.util.function.Function;
import org.junit.Test;
import com.yinggu.domain.Book;
* @author 黑猴子的家
* https://www.jianshu.com/u/37fd8e2dff4c
public class TestLambda2 {
@SuppressWarnings("unused")
@Test
public void test2() {
Book b1 = new Book("红楼梦", "曹雪芹", 100);
// Book b2 = new Book("西游记","吴承恩",23);
Book b2 = new Book("红楼梦", "曹雪芹", 100);
BiPredicate<Book, Book> pre = new BiPredicate<Book, Book>() {
@Override
public boolean test(Book t, Book u) {
return t.getAuthor().equals(u.getAuthor()) &&
t.getName().equals(u.getName())
&& t.getPrice() == u.getPrice();
}
};
System.out.println("-------------------------------");
BiPredicate<Book, Book> pre1 = (t, u) ->
t.getAuthor().equals(u.getAuthor()) &&
t.getName().equals(u.getName())
&& t.getPrice() == u.getPrice();
System.out.println(pre1.test(b1, b2));
}
}
6、练习题六
根据传入的Book对象，打印有效的格式 这本书叫x，作者是xx，价格为xx.
package com.yinggu.demo4;
import java.util.function.BiPredicate;
import java.util.function.Function;
import org.junit.Test;
import com.yinggu.domain.Book;
public class TestLambda2 {
@Test
public void test3() {
Function<Book, String> fun = b -> "这本书：" + b.getName()
+ ",作者是：" + b.getAuthor()
+ ",价格为：" + b.getPrice();
Book b1 = new Book("红楼梦", "曹雪芹", 100);
System.out.println(fun.apply(b1));
}
}
网友评论