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);      //int[]的sorted方法无入参
        //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简介

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

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

1. 普通语句

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

1. 静态方法

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