【java】List中replaceAll的用法

最新推荐文章于 2024-04-18 16:59:08 发布
最新推荐文章于 2024-04-18 16:59:08 发布
阅读量630 收藏
点赞数
分类专栏： java 文章标签： java list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53391462/article/details/133988560
版权
本文详细介绍了Java中的`List.replaceAll()`方法，展示了如何使用`UnaryOperator`接口进行一元运算，包括对Integer、Double、Long、Character等数据类型的算术运算、位操作、日期比较、布尔判断以及字符处理，提供了丰富的代码实例。
摘要由CSDN通过智能技术生成

前言

今天在练习代码优化的时候遇到了replaceAll这个方法，觉得这个方法很有意义，就研究了一下它，复习了一下Math和常用数据类型的一些用法，挺有收获的。

代码

package test.CollectionAndMap.Collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 *
 *  源码：
 *  接口：interface UnaryOperator<T> extends Function<T, T>
 *  UnaryOperator 一元运算符,就是对每个符合条件值进行对应处理 格式为 list.replaceAll(x -> 对x的处理),
 *  因为List中元素类型要求一致,所以这里关于x的处理结果需要返回同类型
 * 包装类,分别为Byte、Short、Integer、Long、Float、Double、Character、Boolean
 *
 */
public class ListReplaceAll {
    public static void main(String[] args) {
        // 1.Integer
        List<Integer> listInteger1 = new ArrayList<>();
        listInteger1.add(6);
        listInteger1.add(-2);
        listInteger1.add(3);
        listInteger1.add(16);
        // listInteger1 -> [6, -2, 3, 16] System.out.println(Arrays.toString(listInteger1.toArray()));
        // 加法运算
        listInteger1.replaceAll(x -> x+2); // [8, 0, 5, 18]
        // 减法运算
        listInteger1.replaceAll(x -> x-2); // [6, -2, 3, 16]
        // 自增,测试后发现x++ 无效        listInteger1.replaceAll(x -> ++x); // [7, -1, 4, 17]
        // 自减,测试后发现x-- 无效
        listInteger1.replaceAll(x -> --x); // [6, -2, 3, 16]
        // 乘法运算
        listInteger1.replaceAll(x -> x*3); // [18, -6, 9, 48]
        // 除法运算
        listInteger1.replaceAll(x -> x/2); // [9, -3, 4, 24]
        // 取余
        listInteger1.replaceAll(x -> x%2); // [1, -1, 0, 0]
        // 位非运算符（~）：正数取反、-1;负数取反、+1
        listInteger1.replaceAll(x -> ~x); // [-2, 0, -1, -1]
        // 其他数学计算 max
        listInteger1.replaceAll(x -> Math.max(x,-1)); // [-1, 0, -1, -1]
        listInteger1.replaceAll(x -> Math.addExact(x,-1)); // [-2, -1, -2, -2]

        List<Integer> listInteger2 = new ArrayList<>();
        listInteger2.add(86520803);
        listInteger2.add(0);
        listInteger2.add(38);
        listInteger2.add(-11);
        // listInteger2 -> [86520803, 0, 38, -11]
        // min
        listInteger2.replaceAll(x -> Math.min(x,3)); // [3, 0, 3, -11]
        // multiplyExact 用于计算两个整数的积,如果积超出了int或long的范围抛出ArithmeticException异常
        listInteger2.replaceAll(x -> Math.multiplyExact(x,9)); // [27, 0, 27, -99]
        // 计算乘积,由于listInteger1 是Integer的,这里需要Math.toIntExact
        // since 9 , Math.toIntExact(Math.multiplyFull(x, 999999999) 会报错：java.lang.ArithmeticException: integer overflow at java.base/java.lang.Math.toIntExact(Math.java:1071)
        listInteger2.replaceAll(x -> Math.toIntExact(Math.multiplyFull(x, 2))); // [54, 0, 54, -198]
        List<Integer> listInteger3 = new ArrayList<>();
        listInteger3.add(10);
        listInteger3.add(799);
        listInteger3.add(-5);
        listInteger3.add(-1029385637);
        // listInteger3 -> [10, 799, -5, -1029385637]
        // 相反数
        listInteger3.replaceAll(x -> Math.negateExact(x)); // [-10, -799, 5, 1029385637]
        // subtractExact返回x-2的值,如果结果溢出了long则抛出异常
        listInteger3.replaceAll(x -> Math.subtractExact(x,2)); // [-12, -801, 3, 1029385635]
        // floorDiv 除法结果向下取整
        listInteger3.replaceAll(x -> Math.floorDiv(x,3)); // [-4, -267, 1, 343128545]
        // Double
        List<Double> listDouble1 = new ArrayList<>();
        listDouble1.add(91.2);
        listDouble1.add(22.3);
        listDouble1.add(34.7);
        listDouble1.add(2.2);
        listDouble1.add(55.9);
        // listDouble1 -> [91.2, 22.3, 34.7, 2.2, 55.9]
        // 向下舍入整数
        listDouble1.replaceAll(x -> Double.valueOf(Math.round(x))); // [91.0, 22.0, 35.0, 2.0, 56.0]
        // 向上舍入整数
        listDouble1.replaceAll(x -> Math.ceil(x)); // [91.0, 22.0, 35.0, 2.0, 56.0]
        // 绝对值
        listDouble1.replaceAll(x -> Math.abs(x)); // [91.0, 22.0, 35.0, 2.0, 56.0]
        // 舍去小数位
        listDouble1.replaceAll(x -> Math.floor(x)); // [91.0, 22.0, 35.0, 2.0, 56.0]
        // since 9,最接近乘积的double值
        listDouble1.replaceAll(x -> Math.fma(x,52,85)); // [4817.0, 1229.0, 1905.0, 189.0, 2997.0]
        // 下面关于 % 和 IEEEremainder 的区别参考自：https://blog.csdn.net/slobe/article/details/6397885
        /**
         * 以下会出现 NaN -Infinity 的结果
         */
        // 余数,IEEERemainder = dividend - (divisor * Math.Round(dividend / divisor))
        listDouble1.replaceAll(x -> Math.IEEEremainder(x,2)); // [1.0, 1.0, 1.0, 1.0, 1.0]; x=0 会出现 -Infinity
        // Modulus = (Math.Abs(dividend) - (Math.Abs(divisor) * (Math.Floor(Math.Abs(dividend) / Math.Abs(divisor))))) * Math.Sign(dividend)
        listDouble1.replaceAll(x -> x%3);// [1.0, 1.0, 1.0, 1.0, 1.0]
        List<Double> listDouble2 = new ArrayList<>();
        listDouble2.add(3.14);
        listDouble2.add(31.4);
        listDouble2.add(62.8);
        listDouble2.add(11.5);
        listDouble2.add(56.3);
        // listDouble2 -> [3.14, 31.4, 62.8, 11.5, 56.3]
        // log 以e为底的对数
        listDouble2.replaceAll(x -> Math.log(x+5)); // [2.096790180014449, 3.594568774642695, 4.216562194946349, 2.803360380906535, 4.115779842942166]
        // log1p 以1为底的对数
        listDouble2.replaceAll(x -> Math.log1p(x)); // [1.130366149265698, 1.5248749047536572, 1.6518386015896627, 1.3358849867248124, 1.6323298497457235]
        // log10 以10为底的对数
        listDouble2.replaceAll(x -> Math.log10(x)); // [0.053219143349313644, 0.1832342171886525, 0.21796761086372685, 0.12576906908195992, 0.21280792246304991]
        // max min multiplyExact abs addExact 等与整型用法一致,不再赘述
        // nextAfter 与第一个参数最接近的可够和第一个参数所拥有的位数一样的浮点数,方向根据第二个参数判断
        listDouble2.replaceAll(x -> Math.nextAfter(x,0));// [0.05321914334931364, 0.18323421718865246, 0.21796761086372682, 0.1257690690819599, 0.2128079224630499]
        // 向上接近
        listDouble2.replaceAll(x -> Math.nextUp(x));// [0.053219143349313644, 0.1832342171886525, 0.21796761086372685, 0.12576906908195992, 0.21280792246304991]
        // 向下最接近的值
        listDouble2.replaceAll(x -> Math.nextDown(x)); // [0.05321914334931364, 0.18323421718865246, 0.21796761086372682, 0.1257690690819599, 0.2128079224630499]
        // 幂
        listDouble2.replaceAll(x -> Math.pow(x,3)); // [1.5073136731416425E-4, 0.006152048228013573, 0.010355614902112002, 0.0019893973683158574, 0.009637477470717413]
        // 随机数
        listDouble2.replaceAll(x -> Math.random());// [0.7722110690293934, 0.8370858901472782, 0.33050440781899926, 0.2576742763597336, 0.6627502490909225]

        List<Double> listDouble3 = new ArrayList<>();
        listDouble3.add(3.14);
        listDouble3.add(31.4);
        listDouble3.add(62.8);
        listDouble3.add(11.5);
        listDouble3.add(56.3);
        // 四舍五入
        listDouble3.replaceAll(x -> Math.rint(x));// [3.0, 31.0, 63.0, 12.0, 56.0]
        // 精度
        listDouble3.replaceAll(x -> Math.scalb(x,2));// [12.0, 124.0, 252.0, 48.0, 224.0]
        // 判断一个数字是正数 1 、负数 -1 还是零 0
        listDouble3.replaceAll(x -> Math.signum(x)); // [1.0, 1.0, 1.0, 1.0, 1.0]
        // 正弦 sin
        listDouble3.replaceAll(x -> Math.sin(x)); // [0.8414709848078965, 0.8414709848078965, 0.8414709848078965, 0.8414709848078965, 0.8414709848078965]
        // 双曲正弦
        listDouble3.replaceAll(x -> Math.sinh(x)); // [0.9443504370351303, 0.9443504370351303, 0.9443504370351303, 0.9443504370351303, 0.9443504370351303]
        // 余弦 cos
        listDouble3.replaceAll(x -> Math.cos(x)); // [0.5862692242006904, 0.5862692242006904, 0.5862692242006904, 0.5862692242006904, 0.5862692242006904]
        // 双曲余弦
        listDouble3.replaceAll(x -> Math.cosh(x)); // [1.1768349480813867, 1.1768349480813867, 1.1768349480813867, 1.1768349480813867, 1.1768349480813867]
       	// 这里我写的例子不太合适，所以出现了NaN,如有兴趣,您可以自己写一些相对合适一些的值
        // 反余弦
        listDouble3.replaceAll(x -> Math.acos(x)); // [NaN, NaN, NaN, NaN, NaN]
        // 正切 tan
        listDouble3.replaceAll(x -> Math.tan(x));// [NaN, NaN, NaN, NaN, NaN]
        // 双曲正切
        listDouble3.replaceAll(x -> Math.tanh(x));// [NaN, NaN, NaN, NaN, NaN]
        // e的x次幂
        listDouble3.replaceAll(x -> Math.exp(x));// [NaN, NaN, NaN, NaN, NaN]
        // e的x次幂 减1
        listDouble3.replaceAll(x -> Math.expm1(x));// [NaN, NaN, NaN, NaN, NaN]
        // 弧度转度
        listDouble3.replaceAll(x -> Math.toDegrees(x));// [NaN, NaN, NaN, NaN, NaN]
        // 角度转弧度
        listDouble3.replaceAll(x -> Math.toRadians(x));// [NaN, NaN, NaN, NaN, NaN]
        // 最接近的浮点值
        List<Double> listDouble4 = new ArrayList<>();
        listDouble4.add(1.0);
        listDouble4.add(-3.0);
        listDouble4.add(2.0);
        // listDouble4 ->[1.0, -3.0, 2.0]
        listDouble4.replaceAll(x -> Math.ulp(x)); // [2.220446049250313E-16, 4.440892098500626E-16, 4.440892098500626E-16]
        // 开方
        listDouble4.replaceAll(x -> Math.sqrt(x)); // [1.4901161193847656E-8, 2.1073424255447017E-8, 2.1073424255447017E-8]

        List<Long> listLong1 = new ArrayList<>();
        listLong1.add(1L);
        listLong1.add(2L);
        listLong1.add(-3L);
        listLong1.add(7L);
        // listLong1 -> [1.4901161193847656E-8, 2.1073424255447017E-8, 2.1073424255447017E-8]
        // floorMod(long x, long y) =  x - floorDiv(x, y) * y;
        listLong1.replaceAll(x -> Math.floorMod(x,2L)); // [1, 0, 1, 1]

        List<String> listStr1 = new ArrayList<>();
        listStr1.add("0000x1112039x");
        listStr1.add("0000011120x94");
        listStr1.add("000001x120394");
        listStr1.add("00000111x0394");
        listStr1.add("0x00011120x94");
        // replaceAll 全部替换,replace 替换,replaceFirst 替换第一个,substring 截取
        listStr1.replaceAll(x -> x.replace("x","X00X")); // [0000X00X1112039X00X, 0000011120X00X94, 000001X00X120394, 00000111X00X0394, 0X00X00011120X00X94]
        listStr1.replaceAll(x -> x.replace("0","f")); // [ffffXffX1112f39XffX, fffff1112fXffX94, fffff1XffX12f394, fffff111XffXf394, fXffXfff1112fXffX94]
        listStr1.replaceAll(x -> x.replaceFirst("1","8")); // [ffffXffX1112f39XffX, fffff1112fXffX94, fffff1XffX12f394, fffff111XffXf394, fXffXfff1112fXffX94]
        listStr1.replaceAll(x -> x.substring(4,13)); // [XffX8112f, f8112fXff, f8XffX12f, f811XffXf, Xfff8112f]
        listStr1.replaceAll(x -> x.substring(5)); // [112f, fXff, X12f, ffXf, 112f]
        listStr1.replaceAll(x -> Arrays.toString(x.split("1"))); // [[, , 2f], [fXff], [X, 2f], [ffXf], [, , 2f]]
        listStr1.replaceAll(x -> Arrays.toString(x.split("f", 2)));// [[[, , 2, ]], [[, Xff]], [[X, 2, ]], [[, fXf]], [[, , 2, ]]]
        List<String> listStr2 = new ArrayList<>();
        listStr2.add("2023-01-02 YYYY-MM-DD");
        listStr2.add("2023-11-02 YYYY-MM-DD");
        listStr2.add("2023-03-04 YYYY-MM-DD");
        listStr2.add("2023-07-05 YYYY-MM-DD");
        listStr2.add("2023-09-30 YYYY-MM-DD");
        // 改为大写 toUpperCase 改为小写  toLowerCase
        listStr2.replaceAll(String::toUpperCase);// x->x.toUpperCase() 的优化写法 [2023-01-02 YYYY-MM-DD, 2023-11-02 YYYY-MM-DD, 2023-03-04 YYYY-MM-DD, 2023-07-05 YYYY-MM-DD, 2023-09-30 YYYY-MM-DD]
        listStr2.replaceAll(String::toLowerCase);// x->x.toLowerCase() 的优化写法 [2023-01-02 yyyy-mm-dd, 2023-11-02 yyyy-mm-dd, 2023-03-04 yyyy-mm-dd, 2023-07-05 yyyy-mm-dd, 2023-09-30 yyyy-mm-dd]
        // getClass() 方法
        listStr2.replaceAll(x-> String.valueOf(x.getClass()));// [class java.lang.String, class java.lang.String, class java.lang.String, class java.lang.String, class java.lang.String]

        // Date 用于时间比较替换
        List<Date> listDate1 = new ArrayList<>();
        listDate1.add(new Date());
        Date date = new Date(2230402854893L);
        listDate1.replaceAll(x-> x.after(date) ? new Date() :date); // [Wed Sep 05 04:20:54 CST 2040]
        listDate1.replaceAll(x-> x.before(date) ?date :  new Date()); // [Fri Oct 20 17:19:21 CST 2023]

        // Boolean
        List<Boolean> listBoolean1 = new ArrayList<>();
        listBoolean1.add(false);
        listBoolean1.add(true);
        // listBoolean1 -> [false, true]
        listBoolean1.replaceAll(x -> x.booleanValue()); // 等同于 x-> x ;[false, true]
        listBoolean1.replaceAll(x -> x.equals(false)); // 可以用来判断结果和预期结果是否一致 [true, false]
        listBoolean1.replaceAll(x -> x.compareTo(false) < 0); // 对比,int值为 1 和 -1 时使用   [false, false]

        // Character 和 Byte 没有 return 本身的方法或者属性,因此这里给出的是一些可能用到的处理方式
        List<Character> listCharacter1 = new ArrayList<>();
        listCharacter1.add('a');
        listCharacter1.add('A');
        listCharacter1.add('我');
        // listByte1 -> [a, A, 我]
        // 比较相对于某个char值得结果后进行处理
        listCharacter1.replaceAll(x -> x.compareTo('a') > 0 ? 'b' : 'a'); // [a, a, b]

        // Byte
        List<Byte> listByte1 = new ArrayList<>();
        listByte1.add((byte) 'a');
        listByte1.add((byte) 'A');
        listByte1.add((byte) '我');
        // listByte1 -> [97, 65, 17]
        listByte1.replaceAll(x -> x.doubleValue()>50?x : (byte) 'a'); // [97, 65, 97]
    }


}

总结

List.replaceAll()方法中，参数取的是一元运算符，支持java 包装数据类型到同种类型之间的一些处理。

m0_53391462
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java集合中的list详解
08-28
Java集合框架中的List接口是Java编程中非常重要的一部分，它代表了一种有序的、允许元素重复的集合。List接口扩展了Collection接口，并提供了对元素位置的精确访问和操作。本文将深入探讨List接口及其子类，特别是...
30分钟入门Java8之方法引用学习
08-30
// 使用方法引用 // 引用的是ComparisonProvider对象的实例方法 Arrays.sort(persons, provider::compareByName); 引用类型的所有对象的实例方法 如果我们希望引用一个类型的所有对象的公共方法，而不必指定特定的...
Java 关于List接口中的replaceAll() 方法
Atimynyc的博客
09-26 1万+
想直接用的同学可以直接跳到最后。 今天博主在查看List接口中有什么哪些方法时，发现了一个特殊的方法replaceAll()方法。 为什么说它特殊呢，因为它传入的参数我是第一次见过，如下 default void replaceAll(UnaryOperator&lt;E&gt; operator) 对于该方法，Java jdk1.8手册里是这么描述的 /** * 用函数接口的...
Java 数据结构之 List接口中的replaceAll() ---UnaryOperator
xiaoliuliu2050的专栏
01-03 3331
default void replaceAll(UnaryOperator&lt;E&gt; operator) 对于该方法，Java jdk1.8手册里是这么描述的 ：用函数接口的返回结果替代原list中的值. list 接口中的源码 default void replaceAll(UnaryOperator&lt;E&gt; operator) { Objects.require...
ArrayList 中 replaceAll方法的作用（jdk源码分析）
wenchang-的博客
08-21 1310
关于ArrayList类中的源码 @Override @SuppressWarnings("unchecked") public void replaceAll(UnaryOperator<E> operator) { Objects.requireNonNull(operator); final int expectedModCount = modCount; //modCount表示list结构上被修改的次数
java替换字符串_java string中的替换字符串
weixin_39729840的博客
02-12 2370
public String replace(char oldChar, char newChar) ，在字符串中用newChar字符替代oldChar字符，返回一个新的字符串public StringreplaceAll(String regex,String replacement)使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。区别：1)replac...
java 中的replaceall
最爱晴天和自己的博客
07-11 3713
  replaceAll() 方法使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。 语法 public String replaceAll(String regex, String replacement) String replaceAll(String regex, String replacement) 参数 regex -- 匹配此字符...
arraylist替换 java_Java ArrayList replaceAll()方法
weixin_35711352的博客
02-23 541
Java ArrayList replaceAll()方法java.util.ArrayList.replaceAll(UnaryOperator operator) 方法用于将ArrayList中的所有元素替换为指定的元素。1 语法public void replaceAll(UnaryOperator operator)2 参数operator ：表示对单个操作数的操作，该操作数生成与其操作数...
Java List集合返回值去掉中括号('[ ]')的操作
09-07
总的来说，处理Java List集合返回值去中括号的问题是常见的字符串处理需求，可以通过各种方式实现，包括使用自定义工具类如StringUtils，或者直接利用Java内置的方法。选择哪种方式取决于具体项目的需求和已有的工具...
java8 streamList转换使用详解
08-18
在本文中，我们将深入探讨如何使用 Stream API 将 `List, Object>>` 转换为 `Map, Object>`，以及如何统计字符串中字母的个数。 首先，让我们详细解析将 `List, Object>>` 转换为 `Map, Object>` 的两种方法： 1. ...
java将String字符串转换为List<Long>类型实例方法
08-24
在 Java 中，将 List 转换为 String 输出过程最简单的方法之一就是使用 List 里面的 `toString` 方法。下面是一个示例代码： ```java private void OutString() { List<Integer> integerList = Arrays.asList(1, 2...
关于String类中的replace()和replaceAll(),List类中add()和addAll()
weixin_34238642的博客
11-07 418
关于String类中的replace()和replaceAll()关于String类中的replace()和replaceAll()关于String类中的replace()和replaceAll() 1 package cn.itcast.stringrepalce; 2 3 public class StringReplaceDemo {...
Java的replaceAll（）方法
carter_yu的博客
06-26 4085
replaceAll( )方法实际是采用正则表达式的规则去匹配的。在regex中”\\”表示一个”\”，在java中一个”\”也要用”\\”表示。这样，前一个”\\”代表regex中的”\”，后一个”\\”代表java中的”\”，所以字符串转义一次，正则转义一次，那么一个斜扛要写4个。1、Java的字符串反斜杠(‘\’)转换为(‘/’)string = string.replaceAll("\\\\
JAVA replaceall的用法
WC949464367的博客
09-16 821
在刷力扣时，罗马转阿拉伯数字时，遇到replaceall的使用 class Solution { public int romanToInt(String s) { //先处理特殊情况，将特殊情况用占位符表示 //IV=A=4，IX=B=9,XL=E=40,XC=F=90,CD=J= 400 CM=K=900 s = s.replaceAll("IV", "A"); s = s.replaceAll("IX", "B");
替换List集合中的某个任意值(对象)
热门推荐
weixin_44488164的博客
02-16 4万+
替换List集合中的某个任意值（对象） 定义一个replaceAll方法,将传入的新值替换集合中的老值(list,old,new) public static void main(String[] args) { List&lt;String&gt; list = new ArrayList&lt;&gt;(); list.add("a"); list.add("a"); list.add...
Java字符串替换replaceAll,新手容易出现的转义错误
最新发布
tusbasa1的博客
04-18 827
最近的写java代码出现了下面的问题，这种替换明明在js中replaceAll根本不会有问题，java的replaceAll到底做了什么？如果未来开发动态替换的功能，对待替换的字符串有什么要求？不想看代码测试的可直接看我的结论。
java list 替换_Java 实例 – List 元素替换
weixin_30847063的博客
02-15 4432
Java 实例 - List 元素替换以下实例演示了如何使用 Collections 类的 replaceAll() 来替换List中所有的指定元素：/*author by w3cschool.ccMain.java*/import java.util.*;public class Main {public static void main(String[] args) {List list = ...
Collections的一些方法(replaceAll---替换指定元素--fill---替换所有元素--reverse---实现反转)
YL的专栏
11-24 4372
/* Collections的一些方法(replaceAll---替换指定元素--fill---替换所有元素--reverse---实现反转) */ import java.util.ArrayList; import java.util.Collections; public class CollectionsDemo2 { public static void main(String
Java replaceFirst 和replaceAll 方法
在路上
07-09 4728
replaceFirst 和replaceAll 方法用来替换匹配正则表达式的文本。不同的是，replaceFirst 替换首次匹配，replaceAll 替换所有匹配。下面的例子来解释这个功能：import java.util.regex.Matcher; import java.util.regex.Pattern;public class RegexMatches { private
java中使用Stream改变list集合中的值
06-06
使用Java 8中的Stream API可以很方便地对List集合中的元素进行修改。 例如，我们有一个List集合存储了一些整数，现在想要将每个元素加上1，可以使用如下代码： ``` List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> modifiedList = list.stream() .map(i -> i + 1) .collect(Collectors.toList()); ``` 上述代码中，我们使用了stream()方法将List集合转换为Stream流，然后使用map()方法对每个元素进行加1操作，最后使用collect()方法将修改后的流转换为List集合并保存到modifiedList中。 如果想要直接修改原始的List集合中的元素，可以使用如下代码： ``` List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); list.replaceAll(i -> i + 1); ``` 上述代码中，我们使用了List的replaceAll()方法，该方法接受一个UnaryOperator函数作为参数，该函数用于对每个元素进行修改。在本例中，我们使用lambda表达式 i -> i + 1 表示对每个元素加1操作。执行完replaceAll()方法后，原始的List集合中的元素值会被修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值