Java8新特性Lambda表达式的基本使用(常用功能)

Java8新特性Lambda表达式的基本使用

下面的都是基本的使用。

• 列表的遍历
• 列表的排序
• 列表的筛选
• 列表的分页查询
• 列表内容提取
• 匿名类

主测试类

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @Author: Joker·Yang
 * @Date: 2018/2/23
 * @Desc:
 */
public class LambdaMain {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
                new User(1, "Joker"), new User(2, "Miller"), new User(3, "David"),
                new User(4, "Tony"), new User(5, "Tiger"), new User(6, "Dinggo"),
                new User(7, "Lily"), new User(8, "James")
        );
        print(users);
        sort(users, 1);//排序
        print(users);
        List<String> names = getAllName(users);//获取所有用户名
        print(names);
        List<User> userList = getUsers(users, (s) -> s.contains("er"));//根据条件筛选
        print(userList);
        List<User> pageList = pagesUser(users, 1, 3, 4);//排序分页
        print(pageList);
        doSomething((u) -> System.out.println("用户编号：" + u.getId() + ",用户名：" + u.getName()));//匿名类
    }

    /**
     * 遍历
     */
    private static void print(List<? extends Object> objects) {
        if (objects != null) objects.forEach(System.out::println);//方式一
        //users.forEach((u) -> System.out.println(u));//方式二(当使用此方式编译器会自动提示修改为方式一)
        System.out.println("---华丽分割线---");
    }

    /**
     * 升序排序
     */
    private static void upSort(List<User> users) {
        users.sort(Comparator.comparing(User::getName));
    }

    /**
     * 降序排序
     */
    private static void downSort(List<User> users) {
        users.sort((User u1, User u2) -> u2.getName().compareTo(u1.getName()));
    }

    /**
     * 排序
     */
    private static void sort(List<User> users, int sortType) {
        if (sortType == 1) upSort(users);
        if (sortType == 2) downSort(users);
    }

    /**
     * 获取姓名集合
     */
    private static List<String> getAllName(List<User> users) {
        return users.stream().map(User::getName).collect(Collectors.toList());
    }

    /**
     * 按照条件过滤用户
     */
    private static List<User> getUsers(List<User> users, Predicate<String> condition) {
        return users.stream().filter((u) -> condition.test(u.getName())).collect(Collectors.toList());
    }

    /**
     * 分页
     */
    private static List<User> pagesUser(List<User> users, int sortType, int pageSize, int pageIndex) {
        sort(users, sortType);
        return users.stream().skip((long) (pageIndex - 1) * pageSize).limit((long) pageSize).collect(Collectors.toList());
    }
    /**
     * 匿名类
     */
    private static void doSomething(LambdaRun run) {
        run.doSomething(new User(99, "Java"));
    }
}

用户信息封装类

/**
 * @Author: Joker·Yang
 * @Date: 2018/2/23
 * @Desc:
 */
@Data
public class User {

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    private Integer id;
    private String name;
}

匿名类测试接口类

/**
 * @Author: Joker·Yang
 * @Date: 2018/2/24
 * @Desc:
 */
public interface LambdaRun {
    void doSomething(User user);
}