我在一个名为string1到string7的程序中有七个字符串。将java中的字符串拆分为固定长度的块
每个字符串的大小将为30个字符。
我会得到一个未知长度的输入字符串。
我必须将此输入字符串分成30个字符串，然后将第一个子字符串设置为string1，将第二个字符串设置为string2等等，直到可能。如果输入字符串大于210个字符，则结尾的剩余字符串将被忽略。
如何处理输入字符串的大小小于210 char的情况。
例如， 145在这种情况下，string1到string4将被填满，string5将由剩余的15个char组成。
如何处理这个很好？
我可以通过字符来读取字符，并将第一个30个字符和字符串1，接下来在字符串2中，直到所有字符被消耗。
但有没有更好的方法来做到这一点？
：请评论，如果我错了，任何地方。
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()) : "";
Iterable<String> chunks = Splitter.fixedLength(30).split(string);
这可以转换为具有例如List<String>Lists.newArrayList。
（披露：我对番石榴贡献）
这东西应该工作：
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]);
}
}
这就是我所做的。似乎工作。由于您的字符串是不是一个数组或列表，你需要显式地指定他们
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));
}
}
}
如何使用分割字符串字符数组，创建一个通用的方法接收的数据块大小和最大大小来考虑，并返回一个字符串数组？
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ç
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;
}
我遇到了一个问题，使用该技术的具体用法。一位用户将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字符。
优雅！非常感谢。 – Nik