Javaの文字列を等しい長さの部分文字列に分割します
Javaで文字列"Thequickbrownfoxjumps"を等しいサイズの部分文字列に分割する方法。例えば。 4つの等しいサイズの"Thequickbrownfoxjumps"が出力を提供するはずです。
["Theq","uick","brow","nfox","jump","s"]
同様の質問：
正規表現のワンライナーバージョンは次のとおりです。
System.out.println(Arrays.toString(
"Thequickbrownfoxjumps".split("(?<=\\G.{4})")
));
\Gは、前の一致が終了した位置に一致する幅ゼロのアサーションです。 wasが以前に一致しなかった場合、\Aと同じように、入力の先頭に一致します。囲んでいる後読みは、最後の一致の終わりから4文字の位置に一致します。
後読みと\Gはどちらも高度な正規表現機能であり、すべてのフレーバーでサポートされているわけではありません。さらに、\Gは、それをサポートするフレーバー全体で一貫して実装されていません。このトリックは、（たとえば） Java 、Perl、.NET、およびJGSoftで機能しますが、 PHP （PCRE）、Ruby 1.9では機能しません+またはTextMate（どちらも鬼車）。 JavaScriptの/y（スティッキーフラグ）は\Gほど柔軟ではなく、JSが後読みをサポートしていたとしても、この方法で使用することはできませんでした。
他のオプションがある場合、このソリューションは必ずしも推奨するとは限らないことに言及する必要があります。他の回答の正規表現ではないソリューションの方が長い場合がありますが、自己文書化もしています。これは、そのほぼoppositeです。 ;）
また、これはAndroidでは機能しません。Androidは、lookbehindsで\Gの使用をサポートしていません。
まあ、総当たりでこれを行うのはかなり簡単です：
public static List<String> splitEqually(String text, int size) {
// Give the list the right capacity to start with. You could use an array
// instead if you wanted.
List<String> ret = new ArrayList<String>((text.length() + size - 1) / size);
for (int start = 0; start < text.length(); start += size) {
ret.add(text.substring(start, Math.min(text.length(), start + size)));
}
return ret;
}
これには正規表現を使用する価値はないと思います。
編集：正規表現を使用しない理由：
- これは、正規表現の実際のパターンマッチングを使用しません。数えているだけです。
- I 疑わしい上記の方が効率的ですが、ほとんどの場合それは重要ではありません
- さまざまな場所で可変サイズを使用する必要がある場合は、繰り返しまたはヘルパー関数を使用して、パラメーターに基づいて正規表現自体を構築します-ick。
- 別の回答で提供された正規表現は、最初にコンパイルされず（無効なエスケープ）、その後動作しませんでした。私のコードは初めて働きました。これは、正規表現と普通のコード、IMOの使いやすさの証です。
これは非常に簡単です Google Guava ：
for(final String token :
Splitter
.fixedLength(4)
.split("Thequickbrownfoxjumps")){
System.out.println(token);
}
出力：
Theq
uick
brow
nfox
jump
s
または、結果を配列として必要とする場合は、次のコードを使用できます。
String[] tokens =
Iterables.toArray(
Splitter
.fixedLength(4)
.split("Thequickbrownfoxjumps"),
String.class
);
参照：
注：スプリッターの構造は上記のインラインで示されていますが、スプリッターは不変で再利用可能であるため、定数に格納することをお勧めします。
private static final Splitter FOUR_LETTERS = Splitter.fixedLength(4);
// more code
for(final String token : FOUR_LETTERS.split("Thequickbrownfoxjumps")){
System.out.println(token);
}
public static String[] split(String src, int len) {
String[] result = new String[(int)Math.ceil((double)src.length()/(double)len)];
for (int i=0; i<result.length; i++)
result[i] = src.substring(i*len, Math.min(src.length(), (i+1)*len));
return result;
}
public String[] splitInParts(String s, int partLength)
{
int len = s.length();
// Number of parts
int nparts = (len + partLength - 1) / partLength;
String parts[] = new String[nparts];
// Break into parts
int offset= 0;
int i = 0;
while (i < nparts)
{
parts[i] = s.substring(offset, Math.min(offset + partLength, len));
offset += partLength;
i++;
}
return parts;
}
substringをString.class（例外の処理）または Apache lang commons （例外を処理します）から使用できます
static String substring(String str, int start, int end)
それをループの中に入れて、あなたは行ってもいいです。
Java8ストリームを使用した1ライナーの実装を次に示します。
String input = "Thequickbrownfoxjumps";
final AtomicInteger atomicInteger = new AtomicInteger(0);
Collection<String> result = input.chars()
.mapToObj(c -> String.valueOf((char)c) )
.collect(Collectors.groupingBy(c -> atomicInteger.getAndIncrement() / 4
,Collectors.joining()))
.values();
次の出力が得られます。
[Theq, uick, brow, nfox, jump, s]
これはone-linerバージョンで、Java 8IntStream を使用して決定しますスライスの始まりのインデックス：
String x = "Thequickbrownfoxjumps";
String[] result = IntStream
.iterate(0, i -> i + 4)
.limit((int) Math.ceil(x.length() / 4.0))
.mapToObj(i ->
x.substring(i, Math.min(i + 4, x.length())
)
.toArray(String[]::new);
私はむしろこの単純な解決策を望みます：
String content = "Thequickbrownfoxjumps";
while(content.length() > 4) {
System.out.println(content.substring(0, 4));
content = content.substring(4);
}
System.out.println(content);
次のJava 8ソリューションを使用します。
public static List<String> splitString(final String string, final int chunkSize) {
final int numberOfChunks = (string.length() + chunkSize - 1) / chunkSize;
return IntStream.range(0, numberOfChunks)
.mapToObj(index -> string.substring(index * chunkSize, Math.min((index + 1) * chunkSize, string.length())))
.collect(toList());
}
文字列を逆方向に均等に分割する場合、つまり1010001111を[10, 1000, 1111]に分割するなど、右から左に分割する場合は、次のコードを使用します。
/**
* @param s the string to be split
* @param subLen length of the equal-length substrings.
* @param backwards true if the splitting is from right to left, false otherwise
* @return an array of equal-length substrings
* @throws ArithmeticException: / by zero when subLen == 0
*/
public static String[] split(String s, int subLen, boolean backwards) {
assert s != null;
int groups = s.length() % subLen == 0 ? s.length() / subLen : s.length() / subLen + 1;
String[] strs = new String[groups];
if (backwards) {
for (int i = 0; i < groups; i++) {
int beginIndex = s.length() - subLen * (i + 1);
int endIndex = beginIndex + subLen;
if (beginIndex < 0)
beginIndex = 0;
strs[groups - i - 1] = s.substring(beginIndex, endIndex);
}
} else {
for (int i = 0; i < groups; i++) {
int beginIndex = subLen * i;
int endIndex = beginIndex + subLen;
if (endIndex > s.length())
endIndex = s.length();
strs[i] = s.substring(beginIndex, endIndex);
}
}
return strs;
}
public static String[] split(String input, int length) throws IllegalArgumentException {
if(length == 0 || input == null)
return new String[0];
int lengthD = length * 2;
int size = input.length();
if(size == 0)
return new String[0];
int rep = (int) Math.ceil(size * 1d / length);
ByteArrayInputStream stream = new ByteArrayInputStream(input.getBytes(StandardCharsets.UTF_16LE));
String[] out = new String[rep];
byte[] buf = new byte[lengthD];
int d = 0;
for (int i = 0; i < rep; i++) {
try {
d = stream.read(buf);
} catch (IOException e) {
e.printStackTrace();
}
if(d != lengthD)
{
out[i] = new String(buf,0,d, StandardCharsets.UTF_16LE);
continue;
}
out[i] = new String(buf, StandardCharsets.UTF_16LE);
}
return out;
}
RegExおよびJava 8ストリームに基づいたバージョンです。 Java 9.以降はMatcher.results()メソッドが利用可能であることに言及する価値があります。
テストが含まれています。
public static List<String> splitString(String input, int splitSize) {
Matcher matcher = Pattern.compile("(?:(.{" + splitSize + "}))+?").matcher(input);
return matcher.results().map(MatchResult::group).collect(Collectors.toList());
}
@Test
public void shouldSplitStringToEqualLengthParts() {
String anyValidString = "Split me equally!";
String[] expectedTokens2 = {"Sp", "li", "t ", "me", " e", "qu", "al", "ly"};
String[] expectedTokens3 = {"Spl", "it ", "me ", "equ", "all"};
Assert.assertArrayEquals(expectedTokens2, splitString(anyValidString, 2).toArray());
Assert.assertArrayEquals(expectedTokens3, splitString(anyValidString, 3).toArray());
}
別のブルートフォースソリューションは、
String input = "thequickbrownfoxjumps";
int n = input.length()/4;
String[] num = new String[n];
for(int i = 0, x=0, y=4; i<n; i++){
num[i] = input.substring(x,y);
x += 4;
y += 4;
System.out.println(num[i]);
}
コードが部分文字列で文字列をステップスルーする場所
Java 8ソリューション（ this のようなものですが、少し単純です）：
public static List<String> partition(String string, int partSize) {
List<String> parts = IntStream.range(0, string.length() / partSize)
.mapToObj(i -> string.substring(i * partSize, (i + 1) * partSize))
.collect(toList());
if ((string.length() % partSize) != 0)
parts.add(string.substring(string.length() / partSize * partSize));
return parts;
}
@Test
public void regexSplit() {
String source = "Thequickbrownfoxjumps";
// define matcher, any char, min length 1, max length 4
Matcher matcher = Pattern.compile(".{1,4}").matcher(source);
List<String> result = new ArrayList<>();
while (matcher.find()) {
result.add(source.substring(matcher.start(), matcher.end()));
}
String[] expected = {"Theq", "uick", "brow", "nfox", "jump", "s"};
assertArrayEquals(result.toArray(), expected);
}
@ -Alan Mooreに 承認された解決策 へのコメントで尋ねました。改行を含む文字列の処理方法。彼はDOTALLの使用を提案しました。
彼の提案を使用して、私はそれがどのように機能するかの小さなサンプルを作成しました：
public void regexDotAllExample() throws UnsupportedEncodingException {
final String input = "The\nquick\nbrown\r\nfox\rjumps";
final String regex = "(?<=\\G.{4})";
Pattern splitByLengthPattern;
String[] split;
splitByLengthPattern = Pattern.compile(regex);
split = splitByLengthPattern.split(input);
System.out.println("---- Without DOTALL ----");
for (int i = 0; i < split.length; i++) {
byte[] s = split[i].getBytes("utf-8");
System.out.println("[Idx: "+i+", length: "+s.length+"] - " + s);
}
/* Output is a single entry longer than the desired split size:
---- Without DOTALL ----
[Idx: 0, length: 26] - [B@17cdc4a5
*/
//DOTALL suggested in Alan Moores comment on SO: https://stackoverflow.com/a/3761521/1237974
splitByLengthPattern = Pattern.compile(regex, Pattern.DOTALL);
split = splitByLengthPattern.split(input);
System.out.println("---- With DOTALL ----");
for (int i = 0; i < split.length; i++) {
byte[] s = split[i].getBytes("utf-8");
System.out.println("[Idx: "+i+", length: "+s.length+"] - " + s);
}
/* Output is as desired 7 entries with each entry having a max length of 4:
---- With DOTALL ----
[Idx: 0, length: 4] - [B@77b22abc
[Idx: 1, length: 4] - [B@5213da08
[Idx: 2, length: 4] - [B@154f6d51
[Idx: 3, length: 4] - [B@1191ebc5
[Idx: 4, length: 4] - [B@30ddb86
[Idx: 5, length: 4] - [B@2c73bfb
[Idx: 6, length: 2] - [B@6632dd29
*/
}
しかし、私は https://stackoverflow.com/a/3760193/1237974 の@Jon Skeetsソリューションが好きです。誰もが正規表現で平等に経験しているわけではない大規模プロジェクトの保守性のために、おそらくJonsソリューションを使用します。
import static Java.lang.System.exit;
import Java.util.Scanner;
import Java.util.Arrays.*;
public class string123 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("Enter String");
String r=sc.nextLine();
String[] s=new String[10];
int len=r.length();
System.out.println("Enter length Of Sub-string");
int l=sc.nextInt();
int last;
int f=0;
for(int i=0;;i++){
last=(f+l);
if((last)>=len) last=len;
s[i]=r.substring(f,last);
// System.out.println(s[i]);
if (last==len)break;
f=(f+l);
}
System.out.print(Arrays.tostring(s));
}}
結果
Enter String
Thequickbrownfoxjumps
Enter length Of Sub-string
4
["Theq","uick","brow","nfox","jump","s"]