Stream的方式将 String字符串 转成 Integer[]数组

最新推荐文章于 2024-08-20 15:44:52 发布
最新推荐文章于 2024-08-20 15:44:52 发布
阅读量4.5k 收藏 1
点赞数 2
分类专栏： Stream 文章标签： jdk8-新特性 函数式 Stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40236395/article/details/78360277
版权

Stream的方式将 String字符串 转成 Integer[]数组

这是同事的博客里看到的一个问题，说标题上的做法暂时实现不了，我就晚上回来做了一下，不足之处，欢迎各位大神各位留言指教！代码里还有一些问题没有想清楚，我会尽力去更新的。

涉及的技术点：

  • jdk8的一些函数式接口

  • Stream.collect()方法

  • Collector（收集器）及具体实现（包含supplier，accumulator，combiner，finisher,characteristics）

  • Stream.reduce()方法

具体代码

代码块语法遵循标准markdown代码，例如：


package com.ytt.aaron.jdk8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collector;
import java.util.stream.Stream;


/**
 *  aaron
 */
public class StringToArray {


    //串行
    public final static Integer[] stringToArrayByCollect11(String string){

        //  *************
        // 注释掉的占时未找到原因，为什么？
        // *************

//        return Stream.of(string.split(""))
//                .map(Integer::valueOf)
//                .collect(
//                        () -> new Integer[1],
//                        (array, s) -> {
//                            if(array.length == 1){
//                                array[0] = s;
//                            }else {
//                                Integer[]  accumulatorArray= new Integer[array.length + 1];
//                                System.arraycopy(array, 0, accumulatorArray, 0, array.length);
//                                accumulatorArray[accumulatorArray.length - 1] = s;
//                                array = accumulatorArray;
//                            }
//                        },
//                        (left,right) -> {
//                            Integer[]  combinerArray= new Integer[left.length + right.length];
//                            System.arraycopy(left, 0, combinerArray, 0, left.length);
//                            System.arraycopy(right, 0, combinerArray, left.length, right.length);
//                            left = combinerArray;
//                        }
//                );

        final String[] strings = string.split("");

        return Stream.of(strings)
                .map(Integer::valueOf)
                .collect(
                        () -> new Integer[strings.length],
                        (array, s) -> {
                            for (int i = 0; i < array.length; i++) {
//                                System.out.println(array[i]);
                                if(array[i] == null){
                                    array[i] = s;
//                                    System.out.println("-----------------------------");
                                    break;
                                }

                            }
                        },
                        (left,right) -> {

                        }
                );


    }

    //并行
    public final static Integer[] stringToArrayByCollect12(String string){

        final String[] strings = string.split("");

        return Stream.of(strings)
                .map(Integer::valueOf)
                .parallel()
                .collect(
                        () -> new Integer[strings.length],
                        (array, s) -> {
                            for (int i = 0; i < array.length; i++) {
//                                System.out.println(array[i]);
                                if(array[i] == null){
                                    array[i] = s;
//                                    System.out.println("-----------------------------");
                                    break;
                                }

                            }
                        },
                        (left,right) -> {
                            Set<Integer> set = new HashSet<Integer>(Arrays.asList(left));
                            set.addAll(Arrays.asList(right));
                            left = set.toArray(new Integer[string.length()]);
                        }
                );


    }

    //串行
    public final static Integer[] stringToArrayByCollect21(String string){

        final String[] strings = string.split("");

        return Stream.of(string.split(""))
                .map(Integer::valueOf)
                .collect(
                    Collector.of(
                            () -> new Integer[string.length()],
                            (array, s) -> {
                                for (int i = 0; i < array.length; i++) {
//                                System.out.println(array[i]);
                                    if(array[i] == null){
                                        array[i] = s;
//                                    System.out.println("-----------------------------");
                                        break;
                                    }

                                }
                            },
                            (left,right) -> {
                                return null;
                            },
                            Collector.Characteristics.CONCURRENT
                    )
                );

    }

    //并行
    public final static Integer[] stringToArrayByCollect22(String string){

        final String[] strings = string.split("");

        return Stream.of(string.split(""))
                .map(Integer::valueOf)
                .parallel()
                .collect(
                        Collector.of(
                                () -> new Integer[string.length()],
                                (array, s) -> {
                                    for (int i = 0; i < array.length; i++) {
//                                System.out.println(array[i]);
                                        if(array[i] == null){
                                            array[i] = s;
//                                    System.out.println("-----------------------------");
                                            break;
                                        }

                                    }
                                },
                                (left,right) -> {
                                    Set<Integer> set = new HashSet<Integer>(Arrays.asList(left));
                                    set.addAll(Arrays.asList(right));
                                    return set.toArray(new Integer[string.length()]);
                                },
                                Collector.Characteristics.CONCURRENT
                        )
                );

    }

    //并行
    // ****************（仅仅能并行，串行就挂，为什么？）
    public final static Integer[] stringToArrayByCollect23(String string){
        return Stream.of(string.split(""))
                .map(Integer::valueOf)
                .parallel()
                .collect(
                        Collector.of(
                                () -> new Integer[1],
                                (array, s) -> {
                                    if(array.length == 1){
                                        array[0] = s;
                                    }else {
                                        Integer[]  accumulatorArray= new Integer[array.length + 1];
                                        System.arraycopy(array, 0, accumulatorArray, 0, array.length);
                                        accumulatorArray[accumulatorArray.length - 1] = s;
                                        array = accumulatorArray;
                                    }
//                                System.out.println(array[0] + " > " + array.length);
                                },
                                (left,right) -> {
                                    Integer[]  combinerArray= new Integer[left.length + right.length];
                                    System.arraycopy(left, 0, combinerArray, 0, left.length);
                                    System.arraycopy(right, 0, combinerArray, left.length, right.length);
                                    return combinerArray;
                                },
                                Collector.Characteristics.CONCURRENT
                        )
                );

    }


    //******************************
    // set的方式和数组那个方式好？
    //**************************
    //或者用其他类型，有什么改进优化方式呢？
    //******************************


    //串并行都可以
    public final static Integer[] stringToArrayByReduce1(String string){

        return Stream.of(string.split(""))
//                .parallel()
                .map(s -> new Integer[]{Integer.valueOf(s)})
                .reduce(
                    new Integer[0],
                    (left,right) -> {
                        Integer[]  accumulatorArray= new Integer[left.length + right.length];
                        System.arraycopy(left, 0, accumulatorArray, 0, left.length);
                        System.arraycopy(right, 0, accumulatorArray, left.length, right.length);
                        return accumulatorArray;
                    }
                );

    }

    //串行并都可以
    public final static Integer[] stringToArrayByReduce2(String string){

        return Stream.of(string.split(""))
//                .parallel()
                .map(s -> new Integer[]{Integer.valueOf(s)})
                .reduce(
                    (left,right) -> {
                        Integer[]  accumulatorArray= new Integer[left.length + right.length];
                        System.arraycopy(left, 0, accumulatorArray, 0, left.length);
                        System.arraycopy(right, 0, accumulatorArray, left.length, right.length);
                        return accumulatorArray;
                    }
                ).orElse(null);

    }

    //并行
    // ****************（仅仅能并行，串行就挂，为什么？）
    public final static Integer[] stringToArrayByReduce3(String string){

        return Stream.of(string.split(""))
//                .parallel()
                .map(Integer::valueOf)
                .reduce(
                    new Integer[0],
                    (array, s) -> {
                        if(array.length == 1){
                            array[0] = s;
                        }else {
                            Integer[]  accumulatorArray= new Integer[array.length + 1];
                            System.arraycopy(array, 0, accumulatorArray, 0, array.length);
                            accumulatorArray[accumulatorArray.length - 1] = s;
                            array = accumulatorArray;
                        }
                        return array;
                    },
                    (left,right) -> {
                        Integer[]  combinerArray= new Integer[left.length + right.length];
                        System.arraycopy(left, 0, combinerArray, 0, left.length);
                        System.arraycopy(right, 0, combinerArray, left.length, right.length);
                        return combinerArray;
                    }
                );

    }



    public static void main(String[] args) {

        String str = "912345678";

//        Stream.of(str.split(""))
//                .collect(
//                        () -> new ArrayList(),
//                        (left,s) -> {
//                            left.add(s);
//                            System.out.println(left);
//                        },
//                        (left,right) -> {
//                            left.addAll(right);
//                            System.out.println("right> " + right);
//                            System.out.println("left> " + left);
//                        }
//                ).forEach(System.out::println);

        System.out.println("--------------stringToArrayByCollect11-------------");

        for (Integer i: stringToArrayByCollect11(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByCollect12-------------");

        for (Integer i: stringToArrayByCollect12(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByCollect21-------------");

        for (Integer i: stringToArrayByCollect21(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByCollect22-------------");

        for (Integer i: stringToArrayByCollect21(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByCollect23-------------");

        for (Integer i: stringToArrayByCollect21(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByReduce1-------------");

        for (Integer i: stringToArrayByReduce1(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByReduce2-------------");

        for (Integer i: stringToArrayByReduce2(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();
        System.out.println("--------------stringToArrayByReduce3-------------");

        for (Integer i: stringToArrayByReduce3(str)) {
            System.out.print(i + "> ");
        }

        System.out.println();

    }


}

我要努力尽快想通。。。。。。。。。。。。。

抓住夏天的尾巴
关注
专栏目录
Java8 将List＜Integer＞ 转换成以逗号分割的String字符串
09-15
在Java编程中，将一个`List<Integer>`转换成以逗号分隔的`String`字符串是一种常见的需求，尤其是在处理数据展示或格式化输出时。Java 8引入了新的特性和方法，使得这种转换变得更加简洁和高效。下面我们将深入探讨...
【Java】Java中将String转换为int的多种方法
科技改变人类，技术成就未来
06-25 3095
在Java编程中，将字符串（String）转换为整数（int）是一个常见需求。本文讲解了是最常用的方法，直接将字符串转换为基本类型 int；Integer.valueOf() 返回一个 Integer 对象并自动拆箱；Integer.decode() 可以处理各种进制表示的字符串。需要注意的是，这些方法在处理非数字字符串时会抛出 NumberFormatException 异常，因此应在转换时进行异常处理，以确保程序的健壮性和稳定性。
【将String集合转为Integer集合的高效方法】
guoleiding888的博客
04-18 3677
将String集合转为Integer集合的高效方法
java Stream collect()使用
最新发布
qq_35175478的博客
08-20 299
【代码】java Stream collect()使用。
Java Stream 常用数组类型转换用法
studyday1的博客
11-11 7512
业务目前经常会使用的stream流来处理数据，特别是对数组的类型进行转换，下面我分类总结常用的转换用法。
Stream流将String的数字集合转成Integer类型数字集合
weixin_56227932的博客
04-06 4628
int[] ints = recordDTO.getIdList().stream().mapToInt(Integer::parseInt).toArray(); List<Integer> ids = Arrays.stream(ints).boxed().collect(Collectors.toList()); 测试 注意,必须是数字的字符串,不然会报错
Jdk8中Stream对于字符串、数组、集合之间的转化
成为一位优秀的职场人，我在路上
03-20 4481
字符串转int数组 入参是以空格划分的整型数组，如"1 2 3 4"； 将该字符串转化成int类型的数组； //字符串转int类型数组 //方式一 int[] ints = Arrays.stream(s.split(" ")).mapToInt(n -> Integer.parseInt(n)).toArray(); //方式二 int[] s1 = Stream.of(s.split(" ")).mapToInt(n -> Integer.parseInt(n)).toArray();
使用Java的Stream将String[]转为List＜long＞或long[]
Alex Leon
02-11 4896
//customTimeRange是一个map, 它的key都是String格式的时间戳 //我现在要获取它的全部key生成一个log[]并进行排序 Set‹String> keySet - customTimeRange.keySet() String[] keyArrays = new String[keySet.size()] keySet. toArray(keyArrays) //然后将string[]转成long[] //List‹Long> keyList = Arrays. st
android byte字节数组转换十六进制字符串
01-09
在Android开发中，有时我们需要将字节数组（byte array）转换为十六进制字符串，以便于数据存储、传输或调试。这是因为字节数组是二进制数据，而十六进制字符串则是一种人类可读的表示方式。下面我们将详细讨论如何...
itoa：快速整数到ASCII整数到字符串的转换
02-05
在C++中，更推荐使用`std::stringstream`，`std::to_string`或`std::stringstream`配合`std::dec`、`std::oct`或`std::hex`来完成整数到字符串的转换，这些方法不仅标准，而且具有更好的错误处理和性能。 例如，...
java8 统计字符串字母个数的几种方法总结(推荐)
08-28
通过遍历字符串，使用 TreeMap 的 put 方法将字母作为键，出现次数作为值，并使用 get 方法获取键对应的值，进行累加计算。 ```java public static void letterCount1(String s) { s = s.replaceAll(" +", ""); ...
java list,set,map,数组间的相互转换详解
08-31
例如，对于字符串数组： ```java String[] arr = {"Larry", "Moe", "Curly"}; List<String> list = Arrays.asList(arr); ``` 注意，这种方法创建的List是固定大小的，不能直接调用`add()`或`remove()`方法。 4...
String[ ]数组转Integer[ ]数组+数组正序、倒序排序
SUMMERENT的博客
06-09 3708
使用Arrays.stream()方法将String数组转换为Stream对象。3. 使用toArray()方法将Stream对象转换为Integer[]数组。3. 使用toArray()方法将Stream对象转换为Integer[]数组。2. 使用boxed()方法将IntStream对象中的每个元素转换为对应的Integer对象。1、String [] 转 Integer []2、int[] 转 Integer[]
【Java 8 新特性】如何将Java流(Stream)转化成数组(Array)
热门推荐
猫巳的博客
12-13 4万+
【Java 8 新特性】如何将Java流转化成数组1.Using Stream.toArray(IntFunction)2.Using Stream.toArray()3.Using IntStream.toArray()4.Using Collectors.toList()5.参考文献 在本页中，我们将学习如何将Java流(Stream)转换为数组(Array)。 最好的转换方法是使用Stream.toArray(IntFunction)方法。 在我们的示例中，我们将通过以下方式将Java流(Stream
如何将 Java 8 中的流转换为数组
村雨遥
05-10 673
问题 Java 8 中，什么是将流转换为数组的最简单的方式？ 回答 回答 1 最简单地方式就是使用 toArray(IntFunction<A[]> generator) 方法，该方法也是 Java API 所建议使用的方法，详情请戳 String[] stringArray = stringStream.toArray(String[]::new); 该方法通过给定一个整数（即长度）作为参数，然后返回一个字符串数组（String[]），你也可以写你自己的 IntFunction： Strea
Java新特性：Java8 Stream 简单快速的处理集合（三
m0_69526738的博客
05-05 796
因为 getAge 方法返回的是 int 类型（返回的如果是 Integer，一样可以转换为 IntStream） 数值流转换为流 很简单，就一个 boxed Stream stream = intStream.boxed(); 2、数值流方法 下面这些方法作用不用多说，看名字就知道： sum() max() min() average() 等… 3、数值范围 IntStream 与 LongStream 拥有 range 和 rangeClosed 方法用于数值范围处理 IntSt
String数组转int数组的几种方法
Asdniaf的博客
10-27 1万+
String数组转int数组的几种方法
string与int的相互转换
amanda的博客
09-16 860
有4种方法： stringstream atoi/itoa sscanf/sprintf lexical_cast 1.stringstream头文件：#include <sstream>1.1 string to int下面的例子将输入到str中的字符通过string stream类型的变量ss转换为int类型的变量，输入到num中：stringstream ss; s
java String数组转int数组 方法记录
无间行者
01-19 1398
java String数组转int数组 方法记录 方法1 public static int[] StringToInt(String[] arrs){ int[] ints = new int[arrs.length]; for(int i=0;i<arrs.length;i++){ ints[i] = Integer.parseInt(arrs[i]); } return ints; } 方法2 public static int[] String
集合或数组转成String字符串
06-09
在Java中，可以使用Arrays类或者Stream API将集合或数组转换为字符串，示例如下： 1. Arrays类的方式： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4); String str1 = String.join(",", list); int[] array = {5, 6, 7, 8}; String str2 = Arrays.toString(array); ``` 上述代码中，使用Arrays.asList方法将List<Integer>类型的集合转换为以逗号分隔的字符串，使用Arrays.toString方法将int[]类型的数组转换为字符串。 2. Stream API的方式： ```java List<Integer> list = Arrays.asList(1, 2, 3, 4); String str1 = list.stream().map(Object::toString).collect(Collectors.joining(",")); int[] array = {5, 6, 7, 8}; String str2 = Arrays.stream(array).mapToObj(String::valueOf).collect(Collectors.joining(",")); ``` 上述代码中，使用Stream API的方式将List<Integer>类型的集合和int[]类型的数组转换为以逗号分隔的字符串。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值