Lambda Expressions - Strings, Comparators, Filters

最新推荐文章于 2024-11-15 18:38:47 发布
最新推荐文章于 2024-11-15 18:38:47 发布
阅读量173 收藏
点赞数
分类专栏： FP 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agileforce/article/details/88300856
版权

原创转载请注明出处：http://agilestyle.iteye.com/blog/2375723

 

IterationStringTest

package chapter3;

import org.junit.Before;
import org.junit.Test;

public class IterationStringTest {

    private String str;

    @Before
    public void setUp() throws Exception {
        str = "Hello, 123, world";
    }

    @Test
    public void test1() {
        str.chars().forEach(ch -> System.out.println(ch));
    }

    @Test
    public void test2() {
        str.chars().forEach(System.out::println);
    }

    private static void printChar(int input) {
        System.out.println((char) input);
    }

    @Test
    public void test3() {
        str.chars().forEach(IterationStringTest::printChar);
    }

    @Test
    public void test4() {
        str.chars().mapToObj(ch -> Character.valueOf((char) ch)).forEach(System.out::println);
    }

    @Test
    public void test5() {
        str.chars().filter(ch -> Character.isDigit(ch)).forEach(ch -> printChar(ch));
    }

    @Test
    public void test6() {
        str.chars().filter(Character::isDigit).forEach(IterationStringTest::printChar);
    }
} 

Console Output


 

CompareTest

package chapter3;

import org.junit.Before;
import org.junit.Test;

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

public class CompareTest {

    private List<Person> personList;

    @Before
    public void setUp() throws Exception {
        personList = Arrays.asList(
                new Person("Alex", 20),
                new Person("Kevin", 27),
                new Person("Darren", 27),
                new Person("Max", 35));
    }

    @Test
    public void test1() {
        System.out.println("sorted in asc");
        personList.stream()
                .sorted((person1, person2) -> person1.ageDifference(person2))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test2() {
        System.out.println("sorted in asc");
        personList.stream()
                .sorted(Person::ageDifference)
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test3() {
        System.out.println("sorted in desc");
        personList.stream()
                .sorted((person1, person2) -> person2.ageDifference(person1))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test4() {
        Comparator<Person> compareAsc = (person1, person2) -> person1.ageDifference(person2);
        Comparator<Person> compareDesc = compareAsc.reversed();

        System.out.println("sorted in asc");
        personList.stream()
                .sorted(compareAsc)
                .collect(Collectors.toList())
                .forEach(System.out::println);

        System.out.println("sorted in desc");
        personList.stream()
                .sorted(compareDesc)
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test5() {
        System.out.println("sorted in asc order by name");
        personList.stream()
                .sorted((person1, person2) -> person1.getName().compareTo(person2.getName()))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test6() {
        System.out.println("sorted in desc order by name");
        personList.stream()
                .sorted((person1, person2) -> person2.getName().compareTo(person1.getName()))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test7() {
        personList.stream()
                .min(Person::ageDifference)
                .ifPresent(youngest -> System.out.println("Youngest: " + youngest));
    }

    @Test
    public void test8() {
        personList.stream()
                .max(Person::ageDifference)
                .ifPresent(oldest -> System.out.println("Oldest: " + oldest));
    }

    @Test
    public void test9() {
        personList.stream()
                .sorted(Comparator.comparing((Person person) -> person.getName()))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test10() {
        Function<Person, String> byName = person -> person.getName();
        personList.stream()
                .sorted(Comparator.comparing(byName))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    @Test
    public void test11() {
        Function<Person, Integer> byAge = person -> person.getAge();
        Function<Person, String> byName = person -> person.getName();

        System.out.println("sorted in asc order by age and name");
        personList.stream()
                .sorted(Comparator.comparing(byAge).thenComparing(byName))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }

    private static class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public int ageDifference(Person other) {
            return age - other.age;
        }

        @Override
        public String toString() {
            return String.format("%s - %d", name, age);
        }
    }
}

Console Output


 

CollectorsTest

package chapter3;

import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;

public class CollectorsTest {

    private List<Person> personList;

    @Before
    public void setUp() throws Exception {
        personList = Arrays.asList(
                new Person("Alex", 20),
                new Person("Kevin", 27),
                new Person("Darren", 27),
                new Person("Max", 35));
    }

    @Test
    public void test1() {
        List<Person> resultList = new ArrayList<>();
        personList.stream()
                .filter(person -> person.getAge() > 20)
                .forEach(person -> resultList.add(person));

        // older than 20: [Kevin - 27, Darren - 27, Max - 35]
        System.out.println("older than 20: " + resultList);
    }

    @Test
    public void test2() {
        List<Person> resultList =
                personList.stream()
                        .filter(person -> person.getAge() > 20)
                        .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

        // [Kevin - 27, Darren - 27, Max - 35]
        System.out.println(resultList);
    }

    @Test
    public void test3() {
        List<Person> resultList =
                personList.stream()
                        .filter(person -> person.getAge() > 20)
                        .collect(Collectors.toList());

        // [Kevin - 27, Darren - 27, Max - 35]
        System.out.println(resultList);
    }

    @Test
    public void test4() {
        Map<Integer, List<Person>> resultMap =
                personList.stream()
                        .collect(Collectors.groupingBy(Person::getAge));

        // group by age: {35=[Max - 35], 20=[Alex - 20], 27=[Kevin - 27, Darren - 27]}
        System.out.println("group by age: " + resultMap);
    }

    @Test
    public void test5() {
        Map<Integer, List<String>> resultMap =
                personList.stream()
                        .collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.toList())));

        // {35=[Max], 20=[Alex], 27=[Kevin, Darren]}
        System.out.println(resultMap);
    }

    @Test
    public void test6() {
        Comparator<Person> byAge = Comparator.comparing(Person::getAge);

        Map<Character, Optional<Person>> resultMap = personList.stream().
                collect(Collectors.groupingBy(person -> person.getName().charAt(0),
                        Collectors.reducing(BinaryOperator.maxBy(byAge))));

        System.out.println("Oldest person of each letter: " + resultMap);
    }

    private static class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public int ageDifference(Person other) {
            return age - other.age;
        }

        @Override
        public String toString() {
            return String.format("%s - %d", name, age);
        }
    }
}

Console Output


 
FileDirTest

package chapter3;

import org.junit.Test;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class FileDirTest {

    @Test
    public void test1() throws IOException {
        Files.list(Paths.get(".")).forEach(System.out::println);
    }

    @Test
    public void test2() throws IOException {
        Files.list(Paths.get(".")).filter(Files::isDirectory).forEach(System.out::println);
    }

    @Test
    public void test3() throws IOException {
        String[] files = new File(".").list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.endsWith(".java");
            }
        });

        System.out.println(files);
    }

    @Test
    public void test4() throws IOException {
        Files.newDirectoryStream(
                Paths.get("."), path -> path.toString().endsWith(".java"))
                .forEach(System.out::println);
    }

    @Test
    public void test5() throws IOException {
        File[] files = new File(".").listFiles(file -> file.isHidden());
        new File(".").listFiles(File::isHidden);
        Arrays.stream(files).forEach(System.out::println);
    }

    @Test
    public void test6() throws IOException {
        List<File> files = new ArrayList<>();
        File[] filesInCurrentDir = new File(".").listFiles();

        for (File file : filesInCurrentDir) {
            File[] filesInSubDir = file.listFiles();

            if (filesInSubDir != null) {
                files.addAll(Arrays.asList(filesInSubDir));
            } else {
                files.add(file);
            }
        }

        System.out.println("Count: " + files.size());
    }

    @Test
    public void test7() throws IOException {
        List<File> files =
                Stream.of(new File(".").listFiles())
                        .flatMap(file -> file.listFiles() == null ? Stream.of(file) : Stream.of(file.listFiles()))
                        .collect(Collectors.toList());

        System.out.println("Count: " + files.size());
    }
}

Console Output


 

 

 

 

Agile牧
关注
专栏目录
JAVA 8 Lambda表达式-Lambda Expressions.rar
09-16
`JAVA 8 Lambda Expressions.pdf` 这份文档可能涵盖了以下主题： 1. Lambda 表达式的基本概念和语法 2. 函数式接口及其应用 3. Lambda 表达式与方法引用来实现函数式编程 4. Stream API 和 Lambda 表达式的结合使用...
[Java 8] (3) 字符串遍历和Comparator接口
热门推荐
不忘初心，好好沉淀
10-23 1万+
遍历一个字符串 在Java 8中，CharSequence接口新添加了一个方法叫做chars()，方法的签名是这个样子的： public default IntStream chars() default关键字修饰的接口方法是Java 8中新添加的特性，目的是向接口中添加已经实现的方法。chars()方法返回了一个IntStream类型，所以chars()实际上是为所有实现
Java 中字符串操作的函数式方法
免费
08-04 34
在 Java 的最新更新中，String 类经历了一系列重要的方法添加。某些方法现在生成 Stream 类的实例，而其中一些是高阶函数。合并这些方法的目的是提供一种简化的方法，以面向流的方式处理字符串。以流为导向的方式处理字符串具有简化代码和增强表现力的优势。这样可以更轻松地应用过滤、映射、减少等操作。另一个优点是 Stream API 支持并行处理，允许通过这些返回流的方法利用并行流。这使得利用多核处理器高效处理大型字符串成为可能。
解决编写lambda表达式时出现lambda expressions are not supported at this language level问题
zhou_fan_xi的博客
11-05 8998
一、问题原因            IDEA编写lambda表达式时报错：lambda expressions are not supported at this language level，意思是在此语言级别不支持lambda表达式，即lambda表达式是java8才支持的一种语法，所以检查idea编译运行环境是否是java8及以上版本 二、问题解决            1. 打开 F...
java 8 流处理字符串之分割字符串str.chars()
RitaAndWakaka的博客
06-03 932
public static List<Character> splitToListOfChar(String str) { return str.chars() .mapToObj(item -> (char) item) .collect(Collectors.toList()); } chars()方法转换字符串至Integer流，每个Integer值代表字符序列的ASCII值。所以我们需要显示使用mapToObj()方法进行类型转换。 ...
python 抽取字符串中的数字filter(str.isdigit, item)
design321的专栏
07-10 9456
item = 123and456 if item.rfind('123') >= 0:    number = filter(str.isdigit, item)
C++ Lambda Story - From C++98 to C++20.pdf
06-05
**C++ Lambda表达式**是C++编程语言中一个强大的特性，从C++11标准开始引入，到C++20标准进一步增强。Lambda表达式允许程序员在代码中定义匿名函数，即没有名称的函数，这极大地提高了代码的灵活性和可读性。本书...
放任Lambda-Lisp 50年Let Over Lambda -- 50 Years of Lisp
11-15
本书旨在突破我们对编程知识的界限。 如果您想知道Lisp甚至编程本身的真正含义，这就是您一直在寻找的书。
Lambda表达式--凌尘.pptx
05-18
【Lambda 表达式】是 Java 8 中的一项重大新特性，它引入了一种更为简洁的函数式编程风格。Lambda 表达式本质上是一个没有名字的函数，允许我们将代码作为一个对象进行传递。这种功能使得 Java 的语言表达能力得到...
java 8 lambda- expressions 学习资料，例子。练习 java example
04-19
Java 8是Java语言的一个重大版本更新，它引入了lambda表达式，这是Java平台的核心特性之一。Lambda表达式为Java带来了函数式编程的元素，使得开发者可以以更简洁的方式编写代码，尤其是在集合和多线程方面。本资料...
深度解读Java8-lambda表达式之方法引用
wonking666的博客
01-30 3423
先看个例子 import java.util.ArrayList; import java.util.Arrays; import static java.util.Comparator.comparing; import java.util.Comparator; import java.util.List; import java.util.function.Function; impor
Java8-Lambda表达式
猿人启示录
04-12 343
Lambda 表达式简介 Lambda 表达式是一种匿名函数(对 Java 而言这并不完全正确，但现在姑且这么认为)，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和名字。 你可以将其想做一种速记，在你需要使用某个方法的地方写上它。当某个方法只使用一次，而且定义很简短，使用这种速记替代之尤其有效，这样，你就不必在类中费力写声明与方法了。 Java 中的 Lambda 表达式...
Lambda表达式详解（一）
tianmlin1的博客
08-11 3458
Lambda表达式是什么 Lambda表达式是Java SE 8中一个重要的新特性 lambda表达式允许你通过表达式来代替功能接口 Lambda表达式还增强了集合库Function/Stream 使用Lambda表达式的优点 简化了匿名委托的使用，让你让代码更加简洁，优雅 Lambda表达式应用场景 使用ForEach遍历 自定义一个bean package com.zyxr....
Java 8 Lambda Expressions by Examples
hicarl的专栏
05-11 443
Ever since I heard Java 8 is going to support lambda expressions (aka closures), I was very enthusiastic to spice my code with such a decent and concise functional element. Most developers extensively
java8 比较器
方小白
04-18 1118
Collections.sort(annotationList, (o1,o2)-&gt;{ return new Integer(((ExcelField)o1[0]).sort()).compareTo( new Integer(((ExcelField)o2[0]).sort()) ); });在JDK8 的编译环境下，形如上的代码会提...
【Android导航 千里之行 始于足下】问题总结
s003603u的专栏
11-30 1万+
Android问题总结
Mybatis
最新发布
庸不易的博客
11-15 442
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 438
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
刷题---顺序表算法题
weixin_63997543的博客
11-11 450
顺序算法题----力扣刷题
编码 pre-lambda post-lambda
09-20
编码pre-lambda和post-lambda是与函数式编程相关的概念。 pre-lambda是指在函数调用之前执行的代码，通常用于数据的准备和验证，可以用来检查输入的参数是否满足某些条件，或者对输入参数进行预处理。 post-lambda...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值