Staram się zrozumieć, w jaki sposób działa metoda split i mam w tej kwestii niewielkie zamieszanie. W tym przykładzie podanym na stronach dokumentacji wyroczni,
String str = "boo:and:foo";
String[] str1 = str.split("o",2);
Output
b
o:and:foo
Łatwo to zrozumieć, że łańcuch został dosłownie podzielony w momencie pojawienia się pierwszego „o”
ale dla
String[] str1 = str.split("o",3);
Output:
b
:and:foo
Jak to wygląda jako takie?
Odpowiedzi:
3 dla odpowiedzi № 1Co rozumiem z dokumentacji:
Parametr limitu określa liczbę razy, gdy wzór jest zastosowane i dlatego wpływa na długość wynikowej tablicy. Jeśli granica n jest większa niż zero, a następniewzór zostanie zastosowany w większość n - 1 razy, długość tablicy nie będzie większa niż n i ostatni wpis tablicy będzie zawierał wszystkie dane wejściowe poza ostatnim dopasowanym ogranicznik. Jeśli n nie jest dodatnie, wzór będziestosowane jako wiele razy, jak to możliwe, a tablica może mieć dowolną długość. Jeśli n wynosi zero wzór zostanie zastosowany tyle razy, ile to możliwe, tablica może mieć dowolną długość, a końcowe puste ciągi zostaną odrzucone.
Oznacza to wymyślenie lub obcięcie go na czas na sznurku s, więc Pozwala przeanalizować jeden po drugim, aby lepiej zrozumieć:
Limit 1
String[] spl1 = str.split("o", 1);
Oznacza to podzielenie go lub wycięcie na jednym ciągu na łańcuchu o w tym przypadku otrzymasz wszystkie dane wejściowe:
[boo:and:foo]
1
Limit 2
String[] spl1 = str.split("o", 2);
Co oznacza odcięcie go raz o więc zrobię przerwę w pierwszym o
boo:and:foo
-----^
w tym przypadku otrzymasz dwa wyniki:
[b,o:and:foo]
1 2
Limit 3
String[] spl1 = str.split("o", 3);
Co oznacza przecięcie go dwa razy w pierwszym o i na drugi o
boo:and:foo
1----^^--------------2
w tym przypadku otrzymasz trzy wyniki:
[b, ,:and:foo]
1 2 3
Limit 4
String[] spl1 = str.split("o", 4);
Co oznacza przecięcie go trzy razy w pierwszym, drugim i trzecim o
boo:and:foo
1_____^^ ^
|___2 |___3
w tym przypadku otrzymasz cztery wyniki:
[b, ,:and:f,o]
1 2 3 4
Limit 5
String[] spl1 = str.split("o", 5);
Co oznacza przecięcie go cztery razy w pierwszym, drugim, trzecim i czwartym o
boo:and:foo
1_____^^ ^^
|___2 ||___4
|____3
w tym przypadku otrzymasz pięć wyników:
[b, ,:and:f, , ]
1 2 3 4 5
Prosta animacja, aby zrozumieć więcej:
1 dla odpowiedzi nr 2
Drugi parametr określa liczbę przypadków, w których wzorzec musi zostać zastosowany.
Z dokumentów Java:
Parametr limitu kontroluje liczbę razywzór jest zastosowane i dlatego wpływa na długość wynikowej tablicy. Jeśli limit n jest większy niż zero, a wzór zostanie zastosowany w większość n - 1 razy, długość tablicy nie będzie większa niż n i ostatni wpis tablicy będzie zawierał wszystkie dane wejściowe poza ostatnim dopasowanym ogranicznik. Jeśli n nie jest dodatnie, wzór zostanie zastosowany jako wiele razy, jak to możliwe, a tablica może mieć dowolną długość. Jeśli n wynosi zero wzór zostanie zastosowany tyle razy, ile to możliwe, tablica może mieć dowolną długość, a końcowe puste ciągi zostaną odrzucone.
Przykład:
1) jeśli limit jest ustawiony na zero (str.split ("o", 0)) następnie zgodnie z dokumentami java wzorzec zostanie zastosowany tyle razy, ile będzie to możliwe, więc wynikiem będzie:
[b,: i: f]
2) ale jeśli ustawisz limit na wartość niezerową (np.sol. 1 lub 2) wzór zostanie zastosowany n-1 razy (np. Dla limitu 1 wzór zostanie zastosowany 0 razy, a dla 2 będzie zastosowany 1 raz), więc wynik będzie poniżej:
[boo: and: foo] // dla str.split ("o", 1) zastosowano 0 raz.
[b, o: and: foo] // dla str.split ("o", 2) zastosowano 1 raz.
[b,: i: foo] // dla str.split („o”, 3) zastosowano 2 razy.
0 dla odpowiedzi № 3
Drugi argument to liczba przypadków zastosowania wyrażenia regularnego w ciągu. Więc jeśli limit wynosi 3, dostaniesz b,,:and:foo: Podział łańcucha na token w momencie wystąpienia wzorca. Uwaga limit może być większy niż liczba wystąpień wyrażenia regularnego w rzeczywistym ciągu.
0 dla odpowiedzi nr 4
String[] split(String regex, int limit)
Drugi parametr ogranicza liczbę łańcuchów zwracanych po podziale.
Dla np. split("anydelimiter", 3) zwróci tablicę tylko 3 łańcuchów, mimo że separator jest obecny w ciągu więcej niż 3 razy.
Jeśli limit jest ujemny, to zwracana tablicaposiadałby tak dużo podciągów, jak to tylko możliwe, ale gdy limit wynosi zero, zwrócona tablica będzie zawierała wszystkie podciągi z wyłączeniem pustych ciągów końcowych.
0 dla odpowiedzi № 5
Żądanie metody dla dwóch parametrów split(String regex, int limit).
regex - ograniczające wyrażenie regularne;
limit - próg wyniku.
0 dla odpowiedzi № 6
**regex** − the delimiting regular expression
String Str = new String("boo:and:foo:com:boo");
System.out.println("Return value1: ");
for (String retval : Str.split(":", 2)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value2: ");
for (String retval : Str.split(":", 3)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value3: ");
for (String retval : Str.split(":", 0)) {
System.out.println(retval);
}
System.out.println();
System.out.println("Return value4: ");
for (String retval : Str.split(":")) {
System.out.println(retval);
}
}
Sam sprawdź każdą wartość1,2,3,4
0 dla odpowiedzi № 7
oto dokumentacja limitu
<p> The <tt>limit</tt> parameter controls the number of times the
* pattern is applied and therefore affects the length of the resulting
* array. If the limit <i>n</i> is greater than zero then the pattern
* will be applied at most <i>n</i> - 1 times, the array"s
* length will be no greater than <i>n</i>, and the array"s last entry
* will contain all input beyond the last matched delimiter. If <i>n</i>
* is non-positive then the pattern will be applied as many times as
* possible and the array can have any length. If <i>n</i> is zero then
* the pattern will be applied as many times as possible, the array can
* have any length, and trailing empty strings will be discarded.
i kod źródłowy dla metody split klasy String.
public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx"s meta characters ".$|()[{^?*+\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == "\" &&
(((ch = regex.charAt(1))-"0")|("9"-ch)) < 0 &&
((ch-"a")|("z"-ch)) < 0 &&
((ch-"A")|("Z"-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};
// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0)
while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
resultSize--;
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
zobacz tę część kodu
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
wynikowy rozmiar listy będzie limitem atmost.