我在一个名为 string1 到 string7 的程序中有七个字符串。
每个字符串的大小为 30 个字符。
我将得到一个长度未知的输入字符串。
我必须将此输入字符串拆分为 30 个字符字符串，然后将第一个子字符串设置为 string1，将第二个子字符串设置为 string2，依此类推，直到可能。如果输入字符串大于 210 个字符，则末尾的剩余字符串将被忽略。
当输入字符串的大小小于 210 字符时如何处理这种情况。
例如 145 在这种情况下 string1 到 string4 将是完整的，而 string5 将由剩余的 15 个字符组成。
如何很好地处理这个？
我可以逐个字符地读取字符并将前 30 个字符和字符串 1 放入字符串 2 中，等等，直到所有字符都被消耗完。
但是有没有更好的方法来做到这一点？
Iterable<String> chunks = Splitter.fixedLength(30).split(string);
这可以转换为 a List<String>with eg Lists.newArrayList。
（披露：我为 Guava 做出了贡献。）
private static Collection<String> splitStringBySize(String str, int size) {
ArrayList<String> split = new ArrayList<>();
for (int i = 0; i <= str.length() / size; i++) {
split.add(str.substring(i * size, Math.min((i + 1) * size, str.length())));
}
return split;
}
由于您的字符串不在数组或列表中，因此您需要明确分配它们。
Matcher m = Pattern.compile(".{1,30}").matcher(s);
String s1 = m.find() ? s.substring(m.start(), m.end()) : "";
String s2 = m.find() ? s.substring(m.start(), m.end()) : "";
String s3 = m.find() ? s.substring(m.start(), m.end()) : "";
String s4 = m.find() ? s.substring(m.start(), m.end()) : "";
String s5 = m.find() ? s.substring(m.start(), m.end()) : "";
String s6 = m.find() ? s.substring(m.start(), m.end()) : "";
String s7 = m.find() ? s.substring(m.start(), m.end()) : "";
如何使用 char 数组来拆分字符串，创建一个接收块大小和要考虑的最大大小的通用方法，并返回一个 String 数组？
public class SplitStringIntoFixedSizeChunks {
public static String[] Split(String text, int chunkSize, int maxLength) {
char[] data = text.toCharArray();
int len = Math.min(data.length,maxLength);
String[] result = new String[(len+chunkSize-1)/chunkSize];
int linha = 0;
for (int i=0; i < len; i+=chunkSize) {
result[linha] = new String(data, i, Math.min(chunkSize,len-i));
linha++;
}
return result;
}
public static void main(String[] args) {
String x = "flskdafsld~fdsakçkçfsda sfdaldsak~çfdskkfadsçlkçfldskçlflçfdskçldksçlkfdslçakafdslçdsklçfdskçlafdskçkdfsçlkfds~çlkfasdçlçfdls~kçlf~dksçlsakdçlkfç";
System.out.println("x length: "+x.length());
String[] lines = Split(x, 30, 210);
for (int i=0; i < lines.length; i++) {
System.out.println("lines["+i+"]: (len: "+lines[i].length()+") : "+lines[i]);
}
}
}
此示例结果：
x length: 145
lines[0]: (len: 30) : flskdafsld~fdsakçkçfsda sfdald
lines[1]: (len: 30) : sak~çfdskkfadsçlkçfldskçlflçfd
lines[2]: (len: 30) : skçldksçlkfdslçakafdslçdsklçfd
lines[3]: (len: 30) : skçlafdskçkdfsçlkfds~çlkfasdçl
lines[4]: (len: 25) : çfdls~kçlf~dksçlsakdçlkfç
这是应该起作用的东西：
String str = "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
if (str.length() > 210)
{
str = str.substring(0, 209);
}
String newStr = str.replaceAll("(.{30})", "$1|");
System.out.println(newStr);
String[] newStrings = newStr.split("\\|");
它的作用是接受给定的字符串，并且每隔 30 个字符，它就会抛出一个分隔符。在这种情况下，我假设您知道用户将输入什么以及不输入什么，这样您就可以输入一个用户不会输入的分隔符（或一组分隔符）。完成后，我使用刚刚添加的分隔符拆分字符串。
这可能会帮助你。
public static void main(String args[]) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String st = br.readLine();
int len = st.length();
String[] str = new String[7];
len=len/30;
int i=0;
for(; i<7 && i<len; i++ ){
str[i] = st.substring(30*i, 30*(i+1));
System.out.println(str[i]);
}
if(i!=7){
str[i] = st.substring(30*i, st.length());
System.out.println(str[i]);
}
}
我遇到了这种技术的特定用法的问题。一个用户将 M$ Word 内容复制/粘贴到一个 HTML 字段中，该字段最终被该技术提取并拆分为多个数据库字段。
该技术打破了 M$ Word 对回车和其他 ASCII 字符的使用。REGEX 将拆分每个回车而不是指定数量的字符。为了纠正这个问题，我将 Michael Besteck 的代码修改为以下内容：
Matcher m = Pattern.compile(".{1,30}", Pattern.DOTALL).matcher(s);
String s1 = m.find() ? s.substring(m.start(), m.end()) : "";
String s2 = m.find() ? s.substring(m.start(), m.end()) : "";
String s3 = m.find() ? s.substring(m.start(), m.end()) : "";
String s4 = m.find() ? s.substring(m.start(), m.end()) : "";
String s5 = m.find() ? s.substring(m.start(), m.end()) : "";
String s6 = m.find() ? s.substring(m.start(), m.end()) : "";
String s7 = m.find() ? s.substring(m.start(), m.end()) : "";
这正确地解释了 ASCII 字符。
这就是我所做的。似乎工作。如果我在任何地方错了，请发表评论：
package com.mypackage;
import java.util.ArrayList;
import java.util.List;
public class TestClass {
public static List<String> splitEqually(final String text, final int size) {
List<String> ret = new ArrayList<String>((text.length() + size - 1) / size);
for (int start = 0; start < text.length(); start += size) {
if (start + size > 0) {
String temp = text.substring(start, Math.min(text.length(), start + size));
int length = temp.length();
for (int i = 0; i < (size - length); i++) {
temp = temp + " ";
}
ret.add(temp);
} else {
ret.add(text.substring(start, Math.min(text.length(), start + size)));
}
}
return ret;
}
public static void main(final String args[]) {
String input = "hello wo";
String str1, str2, str3, str4, str5;
List<String> result = TestClass.splitEqually(input, 3);
try {
str1 = result.get(0);
System.out.println("1: " + result.get(0));
str2 = result.get(1);
System.out.println("2: " + result.get(1));
str3 = result.get(2);
System.out.println("3: " + result.get(2));
str4 = result.get(3);
System.out.println("4: " + result.get(3));
str5 = result.get(4);
System.out.println("5: " + result.get(4));
} catch (IndexOutOfBoundsException e) {
}
}
}
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
// your input
String input = "";
// strings 1-7 as array list
ArrayList<String> results = new ArrayList<String>();
int length;
if(input.length() > 210) {
length = 210;
} else {
length = input.length();
}
for(int i = 0; i <= length; i += 30) {
if((length - (i + 30)) > 0) {
results.add(input.substring(i, i + 30));
} else {
results.add(input.substring(i, length));
}
}
for(int a = 0; a < results.size(); a++) {
System.out.println("size: " + results.get(a).length() + " content: " + results.get(a));
}
}
}
private Collection<String> splitStringBySize(String strPrm, int sizePrm) {
ArrayList<String> splitLcl = new ArrayList<>();
int lLcl=strPrm.length();
int quantityLcl = lLcl / sizePrm;
for (int i = 0; i < quantityLcl; i++) {
splitLcl.add(strPrm.substring(i * sizePrm,(i+1) * sizePrm ));
}
int tailLcl = lLcl % sizePrm;
if(tailLcl>0){
splitLcl.add(strPrm.substring(lLcl-tailLcl,lLcl));
}
return splitLcl;
}
使用 Streams，这应该以一种简单的方式完成：
private static Stream<String> splitToFixedSize(String input, int maxSize) {
var noOfChunks = (int) Math.ceil((float) input.length() / maxSize);
return IntStream.range(0, noOfChunks).mapToObj(i -> {
var start = i * maxSize;
var end = Math.min((i + 1) * maxSize, input.length());
return input.substring(start, end);
});
}