Java-Lambda相关使用介绍

频繁使用的语句

Lambda又涉及到comparator和comparable区别(Comparable是实现comparable接口,实现后可以使用Collections.sort或Arrays.sort，而Comparator是个比较接口，内部有compare和equals函数，而
Labmda中的sort就是实现的后者comparator接口，具体可以见代码),匿名内部类实现和Lambda实现互相转换(Lambda就是把匿名内部类简化了),数组和链表的转换(lambda有toArray函数，Arrays.aslist可以转化成list)

        //Arrays循环输出
        Arrays.stream(heros).forEach(System.out::println);
        //Arrays排序
        Arrays.stream(arr).sorted((arr1, arr2)-> arr2-arr1).forEach(System.out::println);
        //filter筛选
        heros.stream().filter(hero -> testMethod(hero)).forEach(hero -> System.out.println(hero));
        //map转换成list进行存储
        List<String> temp = heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).collect(Collectors.toList());
        //得到某个对象
        Hero firstHero = heros.stream().findFirst().get();

前言

组长让我用Lambda加个功能的时候，网上搜到了使用教程，不是很熟练，趁着端午节详细学习一下Lambda相关内容.

Lambda简介

普通类：循环遍历集合，进行输出或比较
匿名类：实现接口的方法，循环编辑进行输出
Lambda：简化代码，实际操作也是转换成匿名类进行处理。

Lambda引用类型（包含普通语句，静态方法，对象方法，容器对象方法，构造器，这里只写平时用得着的）

普通语句

List<Hero> list = new ArrayList<>();
list.stream().filter(h->h.getDamage() > 10 && h.getDamage() < 50).forEach(System.out::println);

静态方法

List<Hero> list = new ArrayList<>();
list.stream().filter(h->bewteen(h)).forEach(System.out::println);
private static boolean bewteen(Hero h){
    return h.getDamage() > 10 && h.getDamage() < 50;
}

Lambda聚合类型

对元素进行筛选：
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator ) 指定排序
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流
forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator ) 取最小的元素
max(Comparator ) 取最大的元素
count() 总数
findFirst() 第一个元素

上述功能介绍

package lambda;

import charactor.Hero;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author ：Empirefree
 * @description：TODO
 * @date ：2020/6/25 14:50
 */
public class testLambda4 {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for(int i = 0; i < 10; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
//        filter(heros, h->testMethod(h));
/*        //制造重复元素
        heros.add(heros.get(0));
        heros.stream().filter(hero -> testMethod(hero)).forEach(hero -> System.out.println(hero));
        System.out.println("============去重");
        heros.stream().distinct().forEach(hero -> System.out.println(hero));
        System.out.println("============自然排序");
        heros.stream().sorted().forEach(hero -> System.out.println(hero));
        System.out.println("============按规则排序");
        heros.stream().sorted((h1, h2)->h1.getHp() >= h2.getHp() ? 1: -1).forEach(hero -> System.out.println(hero));
        System.out.println("============只输出3个");
        heros.stream().limit(3).forEach(System.out::println);
        System.out.println("============忽略前3个");
        heros.stream().skip(3).forEach(System.out::println);
        System.out.println("============转化为double流");
        heros.stream().mapToDouble(Hero::getHp).forEach(System.out::println);
        System.out.println("============转化为任意类型的流");
        heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).forEach(System.out::println);
        List<String> temp = heros.stream().map(hero -> hero.getName() + "-" + hero.getHp() + "-" + hero.getDamage()).collect(Collectors.toList());
        System.out.println("============map转换成list存储");
        System.out.println(temp);*/
        Object[] objects = heros.stream().toArray();
//        List<Hero> temp = Arrays.asList(objects);

        System.out.println("============转化为数组");
        System.out.println(Arrays.toString(objects));
        Hero minDamageHero = heros.stream().min((h1, h2)->h1.getDamage() - h2.getDamage()).get();
        System.out.println(minDamageHero);
        Hero maxDamagehero = heros.stream().max((h1, h2)->h1.getDamage() - h2.getDamage()).get();
        System.out.println(maxDamagehero);
        long cout = heros.stream().count();
        System.out.println(cout);
        Hero firstHero = heros.stream().findFirst().get();
        System.out.println(firstHero);
    }
    private static boolean testMethod(Hero hero){
        return hero.getDamage() > 10 && hero.getDamage() < 60;
    }
    private static void filter(List<Hero> heros, heroChecker checker) {
        for (Hero hero : heros) {
            if (checker.test(hero)) {
                System.out.print(hero);
            }
        }
    }
}

匿名内部类与Lambda+链表和数组转换+排序

package lambda;

import charactor.Hero;

import java.lang.reflect.Array;
import java.util.*;

/**
 * @author ：Empirefree
 * @description：TODO
 * @date ：2020/6/25 12:07
 */
public class test {
    public static void main(String[] args) {
        Long l1 = new Long(100);
        Long l2 = new Long(200);
        System.out.println(l1.equals(l2));
        System.out.println(l1.longValue() < l2.longValue());
/*
        Integer[] arr = {4, 1, 3, 5, 6, 7, 9, 1};
*/
/*        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*//*

        Arrays.stream(arr).sorted((arr1, arr2)-> arr2-arr1).forEach(System.out::println);
*/

       /* List<String> heroes = new LinkedList<>();
        heroes.add("asdf");
        String[] temp = new String[]{"1243", "asdf"};
        for (String string : temp){
            System.out.println(string);
        }
        heroes.toArray(temp);
        System.out.println(heroes);
        System.out.println(temp);
        for (String string : temp){
            System.out.println(string);
        }
        List<String> hero2 = Arrays.asList(temp);
        System.out.println(hero2);*/
    }
}