在 Java 中一句话初始化一个 List

最新推荐文章于 2025-02-15 15:54:19 发布
最新推荐文章于 2025-02-15 15:54:19 发布
阅读量403 收藏
点赞数
分类专栏： 技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013039395/article/details/104774972
版权

在 Java 中初始化 List

方法一：使用Arrays

List<String> list = Arrays.asList("a", "b");

方法二：使用Stream(JDK8)

List<String> collect = Stream.of("a", "b").collect(Collectors.toList());

方法三：使用 Lists (JDK9)

List<String> strings = List.of("foo", "bar", "baz");

方法四：使用 Lists (JDK10)

var strings = List.of("foo", "bar", "baz");

ps:方法三和四未验证

【软件开发规范一】《Java开发规范》
商务合作|问题讨论|交流学习 请联系作者微信，加微信请务必注明来意，博客主页有联系方式
07-18 2864
此文档说明书供开发部全体成员阅读。1.【强制】不允许任何魔法值（即未经预先定义的常量）直接出现在代码中。反例2.【强制】long或者Long初始赋值时，使用大写的L，不能是小写的l，小写容易跟数字1混淆，造成误解。说明写的是数字的21，还是Long型的2?3.【推荐】不要使用一个常量类维护所有常量，按常量功能进行归类，分开维护。说明大而全的常量类，非得使用查找功能才能定位到修改的常量，不利于理解和维护。正例缓存相关常量放在类CacheConsts下；...
Java中高级面试题总览(一)
数据与算法架构提升之路专栏
03-29 2万+
高频面试题深入剖析
在 Java 中初始化 List 的五种方法
weixin_34220963的博客
11-03 5171
在 Java 中初始化 List 的五种方法 1.构造 List 后使用 List.add 初始化 2.使用 {{}} 双括号语法 3.使用 Arrays.asList 4. 使用 Stream (JDK8) 5. 使用 Lists （JDK9） 参考 在 Java 中初始化 List 的五种方法 Java 中经常需要使用到 List，下面简单介绍几种常见的初始化方式。 1.构造 Lis...
Java 中初始化 List 集合的 6 种方式!
热门推荐
Java技术栈，分享最主流的Java技术
12-06 8万+
List 是 Java 开发中经常会使用的集合，你们知道有哪些方式可以初始化一个 List 吗？这其中不缺乏一些坑，今天栈长我给大家一一普及一下。 1、常规方式 List&lt;String&gt; languages = new ArrayList&lt;&gt;(); languages.add("Java"); languages.add("PHP"); languages.add("Pyt...
Java基础：List初始化的几种方法
weixin_52891601的博客
02-15 580
Java中List初始化的几种方法
Java中List初始化
如雨随行的博客
01-08 1万+
文章目录1.构造List后使用List.add初始化2.使用 {{}} 双括号语法3.使用 Arrays.asList4. 使用 Stream (JDK8)5. 使用 Lists （JDK9） 1.构造List后使用List.add初始化 List<String> stringList = new LinkedList<>(); stringList.add("a"); s...
一个list初始化的小提示
cfhamlet的专栏
11-14 541
刚看了一位网友提出的问题：我想建一个5×5的列表，用以下两种方法： （1） >>> a=[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] >>> a [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0,
Java常用List集合初始化方式
mfsh93的博客
11-18 1189
1.先创建List再赋值 标准方式，先创建集合对象，然后逐个调用add方法初始化。 用起来比较繁琐，不方便 List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); 2.使用 {{}} 初始化 使用匿名内部类完成初始化。外层的{}定义了一个ArrayList的匿名内部类，内...
java二维数组初始化的三种方式，内含福利
m0_57699613的博客
06-21 240
一面 自我介绍 项目中的监控：那个监控指标常见的有哪些？ 微服务涉及到的技术以及需要注意的问题有哪些？ 注册中心你了解了哪些？ consul 的可靠性你了解吗？ consul 的机制你有没有具体深入过？有没有和其他的注册中心对比过？ 项目用 Spring 比较多，有没有了解 Spring 的原理？AOP 和 IOC 的原理 Spring Boot除了自动配置，相比传统的 Spring 有什么其他的区别？ Spring Cloud 有了解多少？ Spring Bean 的生命周期 HashMap 和 has
这次我终于懂JAVA集合框架啦 - 详解List接口（一）
2301_79108772的博客
07-28 1048
List就是有序队列。List是一个接口，继承自Collection。其中主要进行实现基本的List接口功能的有AbstractList抽象类，AbstractSequentialList。其中AbstractList抽象类继承了AbstractionCollection并进行实现了List接口，AbstractList实现了List接口中除了size()，get(int location)之外的函数。
Java编写一个cfd画图软件_starccm+二次开发与java技术(1)
weixin_36328984的博客
02-27 3046
STARCCM+的二次开发可以采用向导式开发和宏命令开发等。 STARCCM+提供了整套的API及丰富的java库，即可以开发算法，也可以开发用户界面。使用STARCCM+向导开发包可以开发各种专用cfd应用系统，定制CFD分析流程，建立自己的CFD分析界面。在启动STARCCM+客户端界面后，可以加载定制的向导，按照指定的流程完成CFD仿真，其中包括：几何建模、网格划分、物理模型定义、初始条件与...
list 初始化 方式·
shuai的博客
08-30 1627
public static List getList() { List list = null; list = Lists.newArrayList(1, 2, 3, "4", '5'); // new ArrayList(Arrays.asList(1, 2, 3, "4", '5')); /...
List 初始化的方法
Shipley_Leo的博客
06-03 836
List 初始化的方法
list初始化的方式
大叶子不小的博客
08-29 678
1、常规方式 List<String> languages = new ArrayList<>(); languages.add("Java"); languages.add("PHP"); languages.add("Python"); System.out.println(languages); 2、Arrays 工具类 List<String> jdks...
Java中初始化一个List的多种方式
weixin_40261082的博客
07-05 1905
Java中初始化一个List的多种方式
java map一句话初始化_关于java初始化一个有值的Map
weixin_28933797的博客
02-16 1242
转载:http://www.evget.com/article/2009/8/21/12289.htmlhttp://www.iteye.com/topic/418542Map map = new HashMap() {{put("Name", "Unmi");put("QQ", "1125535");}};List stooges = new ArrayList() {{add("Larry")...
List的初始化和赋值操作
小老弟的博客
03-12 1万+
//初始化 //1.构造 List 后使用 List.add 初始化 List<String> stringList = new LinkedList<>(); stringList.add("a"); stringList.add("b"); stringList.add("c"); //2.使用 {{}} 双括号语法 List<String> strin...
LIST集合初始化及常见方法
qq_48496989的博客
10-26 5472
常用的List集合方法 添加元素： 1.add(E e):添加元素在列表的末尾 2.add(int index, E e):添加元素在列表的指定位置，指定位置的元素依次后退一位 3.addAll(Collection<? extends E>c): 4.addAll(int index, Collection<? extends E>c): 查看（遍历元素）： 1.for循环 2.增强for循环 3.迭代器iterator() 4.Collectons.enu..
Java 中初始化 List 的五种方法
weixin_42590334的博客
11-28 587
在 Java 中初始化 List 的五种方法 1.构造 List 后使用 List.add 初始化 2.使用 {{}} 双括号语法 3.使用 Arrays.asList 4.使用 Stream (JDK8) 5.使用 Lists （JDK9） 1.构造 List 后使用 List.add 初始化 List<String> stringList = new LinkedList&lt...
java将List<String> list 中每个String 用：：拼接后生成新的List<String> list，每个list字符除去分隔符不超过5000个字符
最新发布
03-11
<think>嗯，用户的问题是关于如何用Java将一个List<String>中的每个字符串用"::"拼接后生成新的List<String>，同时每个拼接后的字符串不能超过5000个字符。这看起来像是一个需要处理字符串分割和拼接的任务。首先，我得理解用户的具体需求。 用户可能有一个原始的字符串列表，比如["a", "b", "c", ...]，想要将相邻的字符串用"::"连接起来，形成更大的字符串块，但每个块的总长度不能超过5000个字符。这听起来像是需要分批处理，每次拼接直到达到长度限制，然后分割到下一个块中。 首先，我需要考虑如何遍历原始列表，逐个拼接元素，并检查当前拼接后的长度是否超过5000。如果超过，就将当前块添加到结果列表中，并重新开始新的块。但这里需要注意分隔符的长度，比如"::"是两个字符，每次添加元素时需要加上分隔符的长度，但只有在已有元素的情况下才需要加分隔符，否则不需要。例如，第一个元素不需要加分隔符，后面的每个元素都需要加上"::"的长度。 然后，需要考虑边界情况，比如原始列表中的某个元素本身长度就超过了5000。这种情况下，可能需要直接截断或者抛出异常？不过用户的问题中没有提到这种情况的处理，所以可能假设每个单独的元素都不超过5000，或者在处理时进行分割。不过根据用户的问题描述，可能每个原始元素都是合理的，拼接后的总长度需要控制。 接下来，需要设计一个算法：初始化一个当前块字符串，初始为空，然后遍历每个元素，尝试将当前元素拼接到当前块。如果当前块为空，直接添加元素，不需要分隔符。否则，添加分隔符和元素。然后检查总长度是否超过5000。如果超过，就将当前块（不包含当前元素）添加到结果列表，然后重新开始新的块，以当前元素作为起始。如果没超过，继续处理下一个元素。 需要注意的是，分隔符的长度是2，所以每次拼接时需要考虑分隔符的长度是否会导致超过限制。例如，假设当前块长度为4999，如果添加一个分隔符和元素，总长度变为4999 + 2 + 元素长度，这可能导致超过5000。所以在拼接前需要预判。 例如，当前块长度是4998，下一个元素长度是3。如果直接拼接，加上分隔符的话总长度是4998 + 2 +3 =5003，超过5000。所以需要将当前块添加到结果中，然后将下一个元素作为新块的开始。 因此，处理逻辑应该是： 1. 初始化结果列表和当前块（空字符串）。 2. 遍历原始列表中的每个元素： a. 计算如果添加该元素到当前块后的长度： - 如果当前块为空，则新长度是元素长度。 - 否则，新长度是当前块长度 + 分隔符长度 + 元素长度。 b. 如果新长度超过5000： - 将当前块添加到结果列表。 - 当前块重置为当前元素。 c. 否则： - 如果当前块为空，直接设置为当前元素。 - 否则，拼接分隔符和当前元素。 3. 遍历结束后，将剩余的当前块添加到结果列表。 这样处理可以确保每个块的字符数不超过5000，同时正确拼接分隔符。 另外，需要注意分隔符的处理是否正确，例如是否在块之间正确添加，而不会在开头或结尾出现多余的分隔符。例如，结果中的每个字符串应该是类似"a::b::c"，而不是以"::"开头或结尾。 现在，考虑可能的代码实现。使用Java的话，可以用循环遍历，维护currentChunk和currentLength变量，避免每次拼接时都计算字符串长度，提高效率。 例如： List<String> result = new ArrayList<>(); StringBuilder currentChunk = new StringBuilder(); int currentLength = 0; String delimiter = "::"; int delimiterLength = delimiter.length(); for (String element : list) { int elementLength = element.length(); int newLength; if (currentLength == 0) { newLength = elementLength; } else { newLength = currentLength + delimiterLength + elementLength; } if (newLength > 5000) { result.add(currentChunk.toString()); currentChunk.setLength(0); currentChunk.append(element); currentLength = elementLength; } else { if (currentLength != 0) { currentChunk.append(delimiter); currentLength += delimiterLength; } currentChunk.append(element); currentLength += elementLength; } } if (currentLength > 0) { result.add(currentChunk.toString()); } 这样应该可以实现需求。不过需要考虑元素为空字符串的情况，或者元素本身是否允许为空。另外，分隔符的长度是固定的，这里假设分隔符是"::"，即2个字符。如果有不同的分隔符，需要调整。 此外，可能还需要处理原始列表为空的情况，此时结果列表也为空。或者在处理后，如果所有元素的总长度都不超过5000，则结果列表只有一个元素。 现在，检查是否有可能的边界情况： 1. 原始列表为空：返回空列表。 2. 单个元素长度超过5000：直接添加到结果中，因为无法分割。 3. 元素刚好在5000字符时：允许添加。 4. 元素加上分隔符刚好超过5000：需要分割到下一个块。 例如，当前块长度为4999，分隔符长度2，元素长度1：总和5002，超过5000。因此，将当前块添加到结果，然后将元素作为新块。 用户的需求中提到“每个list字符除去分隔符不超过5000个字符”，但这句话可能表达的是拼接后的字符串总长度不超过5000，包括分隔符？需要确认。根据问题描述，“生成新的List<String> list，每个list字符除去分隔符不超过5000个字符”，可能是指每个新列表中的字符串，在除去分隔符后的总长度不超过5000？或者每个拼接后的字符串总长度（包括分隔符）不超过5000？ 这里可能存在歧义。例如，如果用户的意思是拼接后的字符串总长度（包括分隔符）不超过5000，那么上面的代码是正确的。如果是除去分隔符后的总长度不超过5000，则需要调整计算方法，即只计算元素本身的长度总和，分隔符不算在内。这种情况下，处理逻辑会不同。 根据用户的问题描述：“每个list字符除去分隔符不超过5000个字符”，可能是指每个新生成的字符串中，所有原始元素的总长度之和不超过5000，分隔符不计入。例如，拼接后的字符串是"a::b::c"，则元素总长度是1+1+1=3，分隔符是2*2=4，总长度为7。但如果要求元素总长度不超过5000，那么需要将元素长度累加，直到加上下一个元素超过5000，此时分割。 这种情况下，处理逻辑需要跟踪元素本身的长度之和，而不是包括分隔符的总长度。例如： 当前元素总长度：sum = sumElements 下一个元素长度：elementLength 如果 sum + elementLength > 5000，则分割，当前块结束，开始新块。 但此时拼接后的字符串总长度可能会超过5000，因为分隔符的长度没有被计入。例如，如果sum是4999，加上elementLength=2，总和5001，超过，所以需要分割。但实际拼接后的字符串是之前的元素加上分隔符，再加上当前元素，总长度可能超过5000。但用户的要求是“除去分隔符不超过5000”，所以分隔符的长度不算在内。 这种情况下，处理逻辑应该是确保每个块中的原始元素总长度之和不超过5000，而分隔符可以随意添加，但用户可能更关注元素本身的总长度，而不是整个字符串的长度。这可能更符合某些应用场景，比如限制数据大小，但分隔符是必须的格式。 但这种情况比较少见，通常限制的是整个字符串的长度。因此，用户的问题可能存在表述上的歧义，需要进一步澄清。不过根据问题描述，用户可能指的是整个拼接后的字符串（包括分隔符）不超过5000字符。例如，在生成日志或拼接字段时，系统限制总长度。 假设用户的意思是整个拼接后的字符串（包括分隔符）不超过5000字符，那么之前的代码是正确的。如果用户的意思是元素总长度（不含分隔符）不超过5000，则需要调整算法，只计算元素长度的总和，而不考虑分隔符的长度。但根据通常的情况，可能前者更合理。 现在回到用户的问题，可能需要确认这一点。但根据用户给出的例子，可能希望总长度包括分隔符不超过5000。例如，如果用户要求每个生成的字符串不超过5000字符，包括分隔符，那么需要按照总长度来处理。 因此，回到之前的代码逻辑，应该正确。 另外，可能还需要考虑分隔符是否应该出现在块的末尾。例如，如果最后一个元素刚好导致总长度超过，那么分割后的新块是否只包含该元素，而之前的块可能以分隔符结尾？但根据算法，分隔符只有在添加元素时才会追加，因此生成的字符串不会以分隔符结尾，而是正确的拼接。 例如，假设当前块是"a::b"，长度是4，下一个元素是"c"，长度是1，分隔符长度2。如果总和是4+2+1=7，不超过5000，则拼接成"a::b::c"。但如果当前块长度是4998，下一个元素长度是3，分隔符长度2，总和4998+2+3=5003，超过5000，则当前块"a::b"被添加到结果，然后新块是"c"。 这样处理是正确的。 现在，总结步骤： 1. 遍历每个元素，维护当前块和当前长度。 2. 计算添加该元素后的总长度（包括分隔符）。 3. 如果超过5000，将当前块保存，重置为当前元素。 4. 否则，添加分隔符（如果不是第一个元素）和元素。 5. 最后将剩余的块添加到结果。 这样就能生成符合要求的列表。 另外，用户要求生成新的List<String>，所以需要将处理后的块添加到结果列表中。 可能的测试案例： 案例1： 原始列表：["a", "b", "c"], 分隔符"::"，每个块最大长度10。 拼接后的每个块总长度： "a::b::c" 是 1+2+1+2+1=7，不超过10，所以结果列表是["a::b::c"]。 案例2： 元素长度为4999的字符串，分隔符长度2，下一个元素长度2。 添加第一个元素后，长度4999。 添加第二个元素时，总长度4999 +2 +2=5003，超过5000。 所以结果列表第一个元素是第一个元素，第二个元素是第二个元素。结果为[元素1, 元素2]。 案例3： 元素1长度3000，元素2长度2000，分隔符长度2。 拼接后的总长度3000 +2 +2000=5002，超过5000。所以元素1单独成块，元素2单独成块。结果列表是[元素1, 元素2]。 案例4： 元素1长度4998，元素2长度2，分隔符长度2。 拼接后的总长度4998 +2 +2=5002，超过5000。所以元素1单独成块，元素2单独成块。 案例5： 元素1长度4998，元素2长度1，拼接后的总长度4998 +2 +1=5001，超过5000。所以元素1成块，元素2单独成块。 案例6： 元素1长度5000，直接成为一块，无论后面是否有元素。 此外，如果用户希望每个块尽可能接近5000，可以继续添加元素直到超过，再分割。这符合上述算法。 现在，考虑代码中的StringBuilder的使用，以及效率问题。使用StringBuilder可以高效拼接字符串，避免频繁创建字符串对象。 综上，回答用户的问题需要详细说明处理逻辑，并提供代码示例，同时解释可能的边界情况和处理方式。此外，需要明确分隔符是否计入总长度，这里假设用户要求总长度包括分隔符不超过5000字符。</think>--- ### **问题分析** 需要将 `List<String>` 中的元素按 `::` 拼接，生成新的 `List<String>`，且每个拼接后的字符串总长度（**含分隔符**）不超过 5000 字符。需解决以下关键问题： 1. **动态拼接控制**：按顺序拼接元素，并实时判断是否超过长度限制。 2. **分隔符处理**：仅在元素间插入 `::`，避免首尾冗余。 3. **性能优化**：避免频繁字符串操作，使用 `StringBuilder` 提升效率。 --- ### **解决方案** #### **步骤分解** 1. **初始化变量**： - `result`：存储最终结果的新列表。 - `currentChunk`：记录当前正在拼接的字符串块（使用 `StringBuilder`）。 - `currentLength`：记录当前块的长度（避免频繁计算 `length()`）。 - `delimiter` 和 `delimiterLength`：定义分隔符及其长度。 2. **遍历原始列表**： - 对每个元素计算**拼接后的预测长度**： - 若当前块为空，直接添加元素，长度为元素长度。 - 若当前块非空，预测长度 = 当前长度 + 分隔符长度 + 元素长度。 - **判断是否超过限制**： - 若超过，将当前块加入 `result`，并重置为新元素。 - 若未超过，追加分隔符和元素。 3. **收尾处理**： - 遍历结束后，将未加入的 `currentChunk` 加入 `result`。 --- ### **代码实现** ```java import java.util.ArrayList; import java.util.List; public class ListJoiner { public static List<String> joinWithLimit(List<String> list) { List<String> result = new ArrayList<>(); if (list == null || list.isEmpty()) return result; StringBuilder currentChunk = new StringBuilder(); int currentLength = 0; String delimiter = "::"; int delimiterLength = delimiter.length(); for (String element : list) { int elementLength = element.length(); // 计算拼接后的预测长度 int newLength = (currentLength == 0) ? elementLength : currentLength + delimiterLength + elementLength; if (newLength > 5000) { // 超过限制：保存当前块，重置为新元素 result.add(currentChunk.toString()); currentChunk.setLength(0); currentChunk.append(element); currentLength = elementLength; } else { // 未超限：添加分隔符（非首元素）和元素 if (currentLength != 0) { currentChunk.append(delimiter); currentLength += delimiterLength; } currentChunk.append(element); currentLength += elementLength; } } // 添加最后一个块 if (currentLength > 0) { result.add(currentChunk.toString()); } return result; } public static void main(String[] args) { // 测试示例 List<String> list = new ArrayList<>(); list.add("a".repeat(4998)); // 长度 4998 list.add("b"); // 长度 1 list.add("c".repeat(3)); // 长度 3 List<String> result = joinWithLimit(list); for (String s : result) { System.out.println(s + " (长度: " + s.length() + ")"); } } } ``` --- ### **关键逻辑说明** | 场景 | 处理方式 | |--------------------------|--------------------------------------------------------------------------| | **当前块为空时** | 直接添加元素，不计入分隔符。 | | **预测长度超过 5000** | 保存当前块，将新元素作为下一个块的起点。 | | **元素本身超长** | 单独作为一块（假设业务允许单个元素超限）。 | | **空列表或空元素** | 直接返回空结果或处理空字符串（需根据业务需求调整）。 | --- ### **测试案例与输出** #### **输入** ```java list = ["aaaa...aaa(4998个a)", "b", "ccc"] ``` #### **输出** ``` aaaa...aaa (长度: 4998) b::ccc (长度: 1 + 2 + 3 = 6) ``` #### **解释** 1. 第一个元素长度 4998，直接作为独立块。 2. 第二个元素 `b` 与第三个元素 `ccc` 拼接后总长度为 `1 + 2 + 3 = 6`，远低于 5000。 --- ### **性能优化点** 1. **预判长度**：通过 `currentLength` 变量跟踪，避免频繁调用 `StringBuilder.length()`。 2. **复用 StringBuilder**：减少内存分配，提升拼接效率。 3. **批量处理**：适合结合 Stream API 并行处理大规模列表。 --- ### **扩展场景** - **动态分隔符**：可通过参数传递分隔符，增强灵活性。 - **自定义长度限制**：将 5000 改为可配置参数。 - **异常处理**：对超长单元素抛出异常或截断（需补充逻辑）。 通过此方案，可高效、安全地实现带长度限制的字符串拼接需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值