Java：如何通过限制字符串中的字符数来拆分带分隔符的字符串？

我有一个场景，我必须拆分一个字符串（具有逗号分隔的值），限制字符串中的最大字符数，同时保持逗号分隔的格式

例如，

String str=“test，et，ste，ts，tst，est，ste，tstete，sts，tet，estst，tet”

假设字符串中的最大字符数可以是10。那么我的输出应该是：

test,et (7 chars)
ste,ts,tst (10 chars)
est,ste (7 chars)
tstete,sts (10 chars)
tet,estst (9 chars)
tet (3 chars)

---

基本上，输出将被循环并附加到查询中的IN子句中，但IN子句只能处理（最大字符数），因此在字符串长度超过限制时拆分字符串（表示完整的逗号分隔值）。

您可以这样做（查看注释以获取解释）：

publicstaticvoidmain（字符串[]args）{
String str=“test，et，ste，ts，tst，est，ste，tstete，sts，tet，estst，tet”；
//先把它分开
字符串字[]=str.split（“，”）；
//使用缓冲区
StringBuffer sb=新的StringBuffer（“”）；
列表结果=新建ArrayList（）；
字符串delim=“”；
//反复读单词。
for（int i=0；i

我会这样做：

用逗号分割输入字符串。返回一个带有单个字符串的数组，例如

arr[]

初始化一个临时字符串变量以存储输出，例如

out=”“

在数组上循环，例如for（int i=0；i

循环内：如果out的长度与当前数组项的长度之和小于10，则将当前数组项添加到out，否则打印输出，重置输出并继续，例如

if（out.length+arr[i].length<10）{out+=”，“+arr[i]；}否则{print out；out=”“；}

也许我忘了什么。。。但是你应该明白这一点，对吧？

这个任务很棘手，下面的lambda表达式解决了这个问题

comma=false；//类布尔变量
last=0；//类int变量
流（str.split（“，”）。收集(
（（）->新StringBuilder（）的收集器，
(小标题)-->{
如果（buf.length（）-last+s.length（）<10）{
buf.append（逗号？，“：”）.append（s）；
逗号=真；
}
否则{
int len=buf.length（）；
buf.append（“（”）.append（len-last）.append（“chars）\n”）；
last=buf.length（）；
buf.追加；
}
},
（buf1，buf2）->null，//未使用
buf->{
int len=buf.length（）；
return（buf.append（“（”）.append（len-last.append（“.chars）\n”）.toString（））；
} ) );

没有（…字符）-解释：

public static void main(String[] args) {
    String str = "test,et,ste,ts,tst,est,ste,tstete,sts,tet,estst,tet";

    // Split it first
    String words[] = str.split(",");

    // Use a buffer
    StringBuffer sb = new StringBuffer("");

    List<String> result = new ArrayList<>();

    String delim = "";

    // Iterate through the words. 
    for(int i = 0; i< words.length; i++) {
        // You will add the comma so total length should be less 
        // than 10.
        if(sb.length() + words[i].length() < 10) {
            sb.append(delim);
            sb.append(words[i]);
            delim = ",";
        }
        else {
            delim = "";
            result.add(sb.toString());
            System.out.println(sb.toString());
            sb = new StringBuffer(words[i]);
            delim = ",";
        }
    }

    // Print to check the results
    for(String s: result) {
        System.out.println(s);
    }
}

Stream.of( str.split( "," ) ).collect(
  Collector.of( () -> new StringBuilder(),
    (buf, s) -> {
      if( buf.length() - last + s.length() < 10 ) {
        buf.append( comma ? "," : "" ).append( s );
        comma = true;
      }
      else {
        buf.append( '\n' );
        last = buf.length();
        buf.append( s );
      }
    },
    (buf1, buf2) -> null,  // unused
    buf -> {
      return( buf.append( '\n' ).toString() );
    } ) );

str.of（str.split（“，”）。收集(
（（）->新StringBuilder（）的收集器，
(小标题)-->{
如果（buf.length（）-last+s.length（）<10）{
buf.append（逗号？，“：”）.append（s）；
逗号=真；
}
否则{
buf.append（'\n'）；
last=buf.length（）；
buf.追加；
}
},
（buf1，buf2）->null，//未使用
buf->{
返回（buf.append（'\n'）.toString（））；
} ) );

---

所需的输出以字符串形式返回…

我只是用逗号分割，然后以不超过大小限制的方式重新连接字符串。另外一个好处是，如果你真的在寻找挑战，你可以将字符串重新排列为最佳（即，在原始输入中可能不是连续的字符串）。这是家庭作业吗？@luksch不，这不是homework@mprivat我理解你回答的第一部分，但不理解第二部分。它不必是连续的，但您是否有通过限制字符大小来重新连接字符串[]的示例代码？这并没有给出我期望的确切结果。打印的两个值具有相同的值。有没有什么方法可以不创建对象而使用indexof函数并使其简单化？有没有什么方法可以不创建新对象而使用indexof函数并使其简单化？我建议的解决方案创建一个助手对象，即字符串。它不使用indexOf，只使用字符串的length属性，这在计算上很便宜。当然，您可以使用count变量来代替构建字符串

out

（另一种解决方案正确地建议使用StringBuffer）。将每个数组项的长度添加到count变量中，并将其与10进行比较。如果更大，那就建绳子。但我认为这并没有那么优雅。

Stream.of( str.split( "," ) ).collect(
  Collector.of( () -> new StringBuilder(),
    (buf, s) -> {
      if( buf.length() - last + s.length() < 10 ) {
        buf.append( comma ? "," : "" ).append( s );
        comma = true;
      }
      else {
        buf.append( '\n' );
        last = buf.length();
        buf.append( s );
      }
    },
    (buf1, buf2) -> null,  // unused
    buf -> {
      return( buf.append( '\n' ).toString() );
    } ) );