黑猴子的家：Java 8 -> 阶段性练习一

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