Java8.0 Stream、lambda表达式练习（持续更新中）

我有明珠一颗

已于 2023-11-09 16:07:29 修改

阅读量324

点赞数 5

分类专栏： Java精修 leetcode&牛客数据结构与算法文章标签： Java lambda Stream Java8.0 牛客

于 2023-11-09 00:37:05 首次发布

本文链接：https://blog.csdn.net/m0_37738114/article/details/134301017

版权

Java精修同时被 3 个专栏收录

75 篇文章 1 订阅

订阅专栏

数据结构与算法

61 篇文章 1 订阅

订阅专栏

leetcode&牛客

39 篇文章 0 订阅

订阅专栏

1、HJ34 图片整理

图片整理_牛客题霸_牛客网

描述

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。

Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。

数据范围：每组输入的字符串长度满足 1≤n≤1000

输入描述：

一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。

输出描述：

Lily的所有图片按照从小到大的顺序输出

示例1

输入：Ihave1nose2hands10fingers

输出：0112Iaadeeefghhinnnorsssv

Java代码

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        String str = "Ihave1nose2hands10fingers";

        //基础方法：将字符串转换为数组，对数组进行排序，最后输出数组
        char[] chs = str.toCharArray();
        Arrays.sort(chs);
        System.out.println(chs);

        //优化：用 Java Stream 和 lambda表达式简化代码
        str.chars().mapToObj(ch -> (char)ch).sorted().forEach(System.out::print);
    }
}

2、HJ21 简单密码

简单密码_牛客题霸_牛客网

描述

现在有一种密码变换算法。

九键手机键盘上的数字与字母的对应： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0，把密码中出现的小写字母都变成九键键盘对应的数字，如：a 变成 2，x 变成 9.

而密码中出现的大写字母则变成小写之后往后移一位，如：X ，先变成小写，再往后移一位，变成了 y ，例外：Z 往后移是 a 。

数字和其它的符号都不做变换。

数据范围：输入的字符串长度满足 1≤n≤100

输入描述：

输入一组密码，长度不超过100个字符。

输出描述：

输出密码变换后的字符串

示例1

输入：YUANzhi1987

输出：zvbo9441987

Java代码（自测版）

public class Main {   

    public static void main(String[] args) {
        String str = "YUANzhi1987";
        str.chars().mapToObj(num -> {
            if('a' <= num && num <= 'a' + 25){//小写字母
                if(num <= 'a' + 2) return 2;
                else if(num <= 'a' + 5) return 3;
                else if(num <= 'a' + 8) return 4;
                else if(num <= 'a' + 11) return 5;
                else if(num <= 'a' + 14) return 6;
                else if(num <= 'a' + 18) return 7;
                else if(num <= 'a' + 21) return 8;
                else return 9;
            }
            if('A' <= num && num <= 'A' + 24) return (char)(num - ('A' - 'a') + 1);
            if(num == 'A' + 25) return 'a';
            return (char) num;
        }).forEach(System.out::print);
    }
}

Java代码（提交版）

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        str.chars().mapToObj(num -> {
            if ('a' <= num && num <= 'a' + 25) { //小写字母
                if (num <= 'a' + 2) return 2;
                else if (num <= 'a' + 5) return 3;
                else if (num <= 'a' + 8) return 4;
                else if (num <= 'a' + 11) return 5;
                else if (num <= 'a' + 14) return 6;
                else if (num <= 'a' + 18) return 7;
                else if (num <= 'a' + 21) return 8;
                else return 9;
            }
            if ('A' <= num && num <= 'A' + 24) return (char)(num - ('A' - 'a') + 1);
            if (num == 'A' + 25) return 'a';
            return (char) num;
        }).forEach(System.out::print);
    }
}

3、HJ36 字符串加密

字符串加密_牛客题霸_牛客网

描述

有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

T R A I L B Z E S C D F G H J K M N O P Q U V W X Y (实际需建立小写字母的字母表，此字母表仅为方便演示）

上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙， Attack AT DAWN (黎明时攻击)就会被加密为Tpptad TP ITVH。

请实现下述接口，通过指定的密匙和明文得到密文。

数据范围：1≤n≤100 ，保证输入的字符串中仅包含小写字母

输入描述：

先输入key和要加密的字符串

输出描述：

返回加密后的字符串

示例1

输入：

nihao
ni

输出：

le

Java代码（自测版）

用 IntStream.range('a', 'z' + 1) 方法生成了26个字母的流。
用 filter 方法进行逐个过滤，简化了判断语句。

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.IntStream;

public class StringEncrypt {

    public static void main(String[] args) {

        String key = "ybkgenngvjrajenzeqhmamrptohmdmxfmxngjg";
        String str = "zu";

        List<Character> list = new LinkedList<>();
        //通过 Stream 和 lambda表达式，将 26 个字母填充到list集合中取
        IntStream.range('a', 'z' + 1).forEach(c -> list.add((char) c));
        List<Character> list2 = new LinkedList<>();
        //将key中的字符逐个无重复地加到list2中
        key.chars().filter(c -> !list2.contains((char) c)).forEach(c -> list2.add((char) c));
        //将list中的元素逐个无重复地加到list2中
        list.stream().filter(c -> !list2.contains(c)).forEach(c -> list2.add(c));
//        System.out.println(list);
//        System.out.println(list2);
        //加密并输出
        str.chars().forEach(c -> System.out.print(list2.get(list.indexOf((char) c))));
    }
}

Java代码（提交版）

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String key = in.next();
            String str = in.next();

            List<Character> list = new LinkedList<>();
            //通过 Stream 和 lambda表达式，将 26 个字母填充到list集合中取
            IntStream.range('a', 'z' + 1).forEach(c -> list.add((char) c));
            List<Character> list2 = new LinkedList<>();
            //将key中的字符逐个无重复地加到list2中
            key.chars().filter(c -> !list2.contains((char) c)).forEach(c -> list2.add((char) c));
            //将list中的元素逐个无重复地加到list2中
            list.stream().filter(c -> !list2.contains(c)).forEach(c -> list2.add(c));
            //加密并输出
            str.chars().forEach(c -> System.out.print(list2.get(list.indexOf((char) c))));
        }
    }
}