Ik heb een touw, "004-034556", dat ik opgesplitst in twee snaren:
string1="004";
string2="034556";
Dat betekent dat de eerste tekenreeks de tekens vóór '-'bevat, en de tweede tekenreeks bevat de tekens na '-'. Ik wil ook controleren of de tekenreeks '-'erin heeft. Zo niet, dan gooide ik een uitzondering. Hoe kan ik dit doen?
1, Autoriteit 100%
Gebruik gewoon de juiste methode: String#split().
String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556
Merk op dat dit een Regelmatig is Expressie , dus vergeet niet om te ontsnappen speciale tekens indien nodig.
erzijn 12 tekens met een speciale betekenis: de backslash
\, het caret^, het dollarteken$, de punt of punt., het verticale streep- of pijpsymbool|, het vraagteken?, de asterisk of ster*, het plusteken+, het haakje openen(, het haakje sluiten), en het vierkante haakje openen[, de accolade openen{, deze speciale tekens worden vaak “metatekens” genoemd “.
Dus als je wilt splitsen op b.v. period/dot .wat betekent “elk teken” in regex , gebruik dan backslash \om te ontsnappen aan het individuele speciale teken, zoals dus split("\\."), of gebruik tekenklasse []om letterlijke tekens weer te geven, zoals split("[.]"), of gebruik Pattern#quote()om aan de hele tekenreeks te ontsnappen, zoals split(Pattern.quote(".")).
String[] parts = string.split(Pattern.quote(".")); // Split on period.
Als u vooraf wilt testen of de tekenreeks bepaalde tekens bevat, gebruikt u gewoon String#contains().
if (string.contains("-")) {
// Split it.
} else {
throw new IllegalArgumentException("String " + string + " does not contain -");
}
Opmerking, dit neemt geen reguliere uitdrukking. Gebruik daarvoor String#matches()in plaats daarvan.
Als u het gespleten teken in de resulterende delen wilt behouden, maakt u gebruik van positief lookaround . Als u het gespleten karakter wilt hebben om in de linkerkant te eindigen, gebruikt u positieve lookhecht door het vooraf te voegen ?<=groep op het patroon.
String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556
Als u het gesplitste karakter wilt laten eindigen op de rechterkant, gebruikt u positieve lookahead door ?=groep op het patroon.
String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556
Als u het aantal resulterende delen wilt beperken, kunt u het gewenste nummer als 2e argument van split()-methode leveren.
String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
2, Autoriteit 3%
Een alternatief voor het rechtstreeks verwerken van de string is het gebruik van een reguliere expressie met het vastleggen van groepen. Dit heeft het voordeel dat het eenvoudig is om meer geavanceerde beperkingen op de invoer te impliceren. Het volgende splitst bijvoorbeeld de tekenreeks in twee delen en zorgt ervoor dat beide alleen uit cijfers bestaan:
import java.util.regex.Pattern;
import java.util.regex.Matcher;
class SplitExample
{
private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");
public static void checkString(String s)
{
Matcher m = twopart.matcher(s);
if (m.matches()) {
System.out.println(s + " matches; first part is " + m.group(1) +
", second part is " + m.group(2) + ".");
} else {
System.out.println(s + " does not match.");
}
}
public static void main(String[] args) {
checkString("123-4567");
checkString("foo-bar");
checkString("123-");
checkString("-4567");
checkString("123-4567-890");
}
}
Omdat het patroon in dit geval vast is, kan het van tevoren worden gecompileerd en opgeslagen als een statisch lid (in het voorbeeld geïnitialiseerd tijdens de laadtijd van de klasse). De reguliere expressie is:
(\d+)-(\d+)
De haakjes geven de vastleggende groepen aan; de string die overeenkwam met dat deel van de regexp kan worden benaderd door de Match.group() methode, zoals getoond. De \d komt overeen met een enkel decimaal cijfer, en de + betekent “komt overeen met een of meer van de vorige uitdrukkingen). De – heeft geen speciale betekenis, dus komt alleen overeen met dat teken in de invoer. Merk op dat u de backslashes dubbel moet escapen wanneer u dit als een Java-tekenreeks schrijft. Enkele andere voorbeelden:
([A-Z]+)-([A-Z]+) // Each part consists of only capital letters
([^-]+)-([^-]+) // Each part consists of characters other than -
([A-Z]{2})-(\d+) // The first part is exactly two capital letters,
// the second consists of digits
3
Gebruik:
String[] result = yourString.split("-");
if (result.length != 2)
throw new IllegalArgumentException("String not in correct format");
Hiermee wordt uw string in twee delen gesplitst. Het eerste element in de array is het deel dat het spul bevat vóór de -en het tweede element in de array bevat het deel van uw string na de -.
Als de reekslengte niet 2 is, was de tekenreeks niet in het formaat: string-string.
Bekijk de Split () methode in de Stringklasse.
4
String[] out = string.split("-");
zou het ding moeten doen. De -klasse heeft veel methode om met een string te werken.
5
// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter
public static String[] SplitUsingTokenizer(String subject, String delimiters) {
StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
ArrayList<String> arrLis = new ArrayList<String>(subject.length());
while(strTkn.hasMoreTokens())
arrLis.add(strTkn.nextToken());
return arrLis.toArray(new String[0]);
}
6
Met Java 8:
List<String> stringList = Pattern.compile("-")
.splitAsStream("004-034556")
.collect(Collectors.toList());
stringList.forEach(s -> System.out.println(s));
7
U kunt ook zo proberen
String concatenated_String="hi^Hello";
String split_string_array[]=concatenated_String.split("\\^");
8
Aangenomen, dat
- Je hebt niet echt regelmatig uitdrukkingen nodig voor je split
- U gebruikt toevallig Apache Commons Lang in uw app
De eenvoudigste manier is om stringutils # splitsen (java.lang.string, char) . Dat is handiger dan degene die door Java uit de doos wordt geleverd als je geen reguliere expressies nodig hebt. Net als de handleiding zegt, het werkt als volgt:
A null input String returns null.
StringUtils.split(null, *) = null
StringUtils.split("", *) = []
StringUtils.split("a.b.c", '.') = ["a", "b", "c"]
StringUtils.split("a..b.c", '.') = ["a", "b", "c"]
StringUtils.split("a:b:c", '.') = ["a:b:c"]
StringUtils.split("a b c", ' ') = ["a", "b", "c"]
Ik zou aanraden om Commong-Lang te gebruiken, omdat het meestal veel dingen bevat die bruikbaar zijn. Als u het echter niet nodig hebt voor iets anders dan een split te doen, dan is het implementeren van uzelf of het ontsnappen van de regex een betere optie.
9
Gebruik org.apache.commons.lang.stringutils ‘gesplitste methode die een splitsen kan splitsen op basis van het teken of de reeks die u wilt splitsen.
METHODE-handtekening:
public static String[] split(String str, char separatorChar);
In uw geval wilt u een tekenreeks splitsen wanneer er een “-” is.
U kunt eenvoudig als volgt doen:
String str = "004-034556";
String split[] = StringUtils.split(str,"-");
Uitvoer:
004
034556
Stel dat als -niet in je string voorkomt, het de gegeven string retourneert en je geen uitzondering krijgt.
Antwoord 10
Samenvattend: er zijn minstens vijf manieren om een string in Java te splitsen:
-
String.split():
String[] parts ="10,20".split(","); -
Pattern.compile(regexp).splitAsStream(input):
List<String> strings = Pattern.compile("\\|") .splitAsStream("010|020202") .collect(Collectors.toList()); -
StringTokenizer (oude klasse):
StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", "."); while(strings.hasMoreTokens()){ String substring = strings.nextToken(); System.out.println(substring); } -
Google Guava-splitter:
Iterable<String> result = Splitter.on(",").split("1,2,3,4"); -
Apache Commons StringUtils:
String[] strings = StringUtils.split("1,2,3,4", ",");
Zodat u de beste optie voor u kunt kiezen, afhankelijk van wat u nodig heeft, b.v. retourtype (array, lijst of itereerbaar).
Hieris een groot overzicht van deze methoden en de meest voorkomende voorbeelden (hoe te splitsen door punt, schuine streep, vraagteken, enz.)
Antwoord 11
De snelste manier, die ook de minste middelen verbruikt, zou kunnen zijn:
String s = "abc-def";
int p = s.indexOf('-');
if (p >= 0) {
String left = s.substring(0, p);
String right = s.substring(p + 1);
} else {
// s does not contain '-'
}
Antwoord 12
Voor eenvoudig gebruik String.split()zou het werk moeten doen. Als u guave gebruikt, is er ook een klasse Splitterwaarmee u verschillende tekenreeksbewerkingen en ondersteunt CharMatcher:
Splitter.on('-')
.trimResults()
.omitEmptyStrings()
.split(string);
Antwoord 13
String Split met meerdere tekens met Regex
public class StringSplitTest {
public static void main(String args[]) {
String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
//String[] strs = s.split("[,\\s\\;]");
String[] strs = s.split("[,\\;]");
System.out.println("Substrings length:"+strs.length);
for (int i=0; i < strs.length; i++) {
System.out.println("Str["+i+"]:"+strs[i]);
}
}
}
Uitvoer:
Substrings length:17
Str[0]:
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]:
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String
Maar verwacht niet dezelfde uitvoer voor alle JDK-versies. Ik heb één buggezien die voorkomt in sommige JDK-versies waar de eerste null-tekenreeks genegeerd. Deze bug is niet aanwezig in de nieuwste JDK-versie, maar bestaat in sommige versies tussen de late versies van JDK 1.7 en de vroege versies van 1.8.
Antwoord 14
public class SplitTest {
public static String[] split(String text, String delimiter) {
java.util.List<String> parts = new java.util.ArrayList<String>();
text += delimiter;
for (int i = text.indexOf(delimiter), j=0; i != -1;) {
String temp = text.substring(j,i);
if(temp.trim().length() != 0) {
parts.add(temp);
}
j = i + delimiter.length();
i = text.indexOf(delimiter,j);
}
return parts.toArray(new String[0]);
}
public static void main(String[] args) {
String str = "004-034556";
String delimiter = "-";
String result[] = split(str, delimiter);
for(String s:result)
System.out.println(s);
}
}
Antwoord 15
Je kunt een tekenreeks splitsen door een regeleinde door de volgende instructie te gebruiken:
String textStr[] = yourString.split("\\r?\\n");
U kunt een string door een koppelteken / karakter splitsen met behulp van de volgende verklaring:
String textStr[] = yourString.split("-");
16
import java.io.*;
public class BreakString {
public static void main(String args[]) {
String string = "004-034556-1234-2341";
String[] parts = string.split("-");
for(int i=0;i<parts.length;i++) ｛
System.out.println(parts[i]);
}
}
}
17
Er zijn slechts twee methoden die u echt moet overwegen.
Gebruik String.Split voor een scheidingsteken van één personages of u geeft niet om prestaties
Als de prestaties geen probleem is, of als de scheidingsteken een enkel teken is dat geen gewoon uitdrukkingsspecial karakter is (dwz niet een van .$|()[{^?*+\) Dan kunt u String.splitgebruiken.
String[] results = input.split(",");
De split-methode heeft een optimalisatie om te voorkomen dat een reguliere expressie wordt gebruikt als de scheidingsteken een enkel teken is en niet in de bovenstaande lijst. Anders moet het een reguliere uitdrukking compileren, en dit is niet ideaal.
Pattern.Split en proeft het patroon als het gebruik van een complexe scheidingsliter en u geeft om prestaties.
Als de prestaties een probleem is, en uw scheidingsteken niet een van de bovenstaande is, moet u een regelmatig expressiepatroon pre-compileren dat u vervolgens kunt hergebruiken.
// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");
/// ... later
String[] results = pattern.split(input);
Deze laatste optie maakt nog steeds een nieuwe Matcher-object. U kunt dit object ook cachen en deze opnieuw instellen voor elke invoer voor maximale prestaties, maar dat is enigszins gecompliceerder en niet draadveilig.
18
Een manier om dit te doen, is door de reeks in een voor elke lus door te voeren en het vereiste gesplitste teken te gebruiken.
public class StringSplitTest {
public static void main(String[] arg){
String str = "004-034556";
String split[] = str.split("-");
System.out.println("The split parts of the String are");
for(String s:split)
System.out.println(s);
}
}
Uitgang:
The split parts of the String are:
004
034556
19
Gebruik het niet stringtokenizer Klasse omdat het een oudere klasse is die wordt behouden voor compatibiliteitsredenen, en het gebruik ervan wordt ontmoedigd in de nieuwe code. En we kunnen gebruik maken van de split-methode zoals ook door anderen wordt gesuggereerd.
String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));
en zoals verwacht zal het afdrukken:
[004, 034556]
In dit antwoord wil ik ook wijzen één wijziging die heeft plaatsgevonden voor splitMethode in Java 8 . De string # Split () Methode maakt gebruik van Pattern.split, en nu zal het lege snaren worden verwijderd aan het begin van de resultaatarray. Let op dit Wijzigen in documentatie voor Java 8:
Als er aan het begin van de invoer een pospitch-wedstrijd is
Sequentie Dan is een lege toonaangevende substring opgenomen aan het begin
van de resulterende array. Een zero-breedte match in het begin echter
produceert nooit een dergelijke lege toonaangevende substring.
het betekent voor het volgende voorbeeld:
String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));
We krijgen drie snaren: [0, 0, 4]en niet vier zoals het geval was in Java 7 en eerder. Controleer ook deze soortgelijke vraag .
20
U kunt SPLIT gebruiken ():
import java.io.*;
public class Splitting
{
public static void main(String args[])
{
String Str = new String("004-034556");
String[] SplittoArray = Str.split("-");
String string1 = SplittoArray[0];
String string2 = SplittoArray[1];
}
}
anders kunt u stringtokenizer gebruiken:
import java.util.*;
public class Splitting
{
public static void main(String[] args)
{
StringTokenizer Str = new StringTokenizer("004-034556");
String string1 = Str.nextToken("-");
String string2 = Str.nextToken("-");
}
}
Antwoord 21
Hier zijn twee manieren om dit te bereiken.
MANIER 1: Omdat je twee getallen moet splitsen door een speciaal teken, kun je regex gebruiken
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TrialClass
{
public static void main(String[] args)
{
Pattern p = Pattern.compile("[0-9]+");
Matcher m = p.matcher("004-034556");
while(m.find())
{
System.out.println(m.group());
}
}
}
MANIER 2: De string split-methode gebruiken
public class TrialClass
{
public static void main(String[] args)
{
String temp = "004-034556";
String [] arrString = temp.split("-");
for(String splitString:arrString)
{
System.out.println(splitString);
}
}
}
Antwoord 22
Je kunt StringTokenizer eenvoudig gebruiken om een string in twee of meer delen te splitsen, ongeacht of er scheidingstekens zijn:
StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
Antwoord 23
Bekijk de split()methode in de Stringklasse op javadoc.
https : //docs.oracle.com/javase/7/docs/api/java/lang/string.html#split (java.lang.string)
String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
System.out.println("string "+cnt+" = "+item);
cnt++;
}
Hier vele voorbeelden voor gesplitste string, maar ik weinig code geoptimaliseerd.
24
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter
string1=004 // sTemp[0];
string2=034556//sTemp[1];
25
Ik wilde gewoon een algoritme schrijven in plaats van met behulp van Java-ingebouwde functies:
public static List<String> split(String str, char c){
List<String> list = new ArrayList<>();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < str.length(); i++){
if(str.charAt(i) != c){
sb.append(str.charAt(i));
}
else{
if(sb.length() > 0){
list.add(sb.toString());
sb = new StringBuilder();
}
}
}
if(sb.length() >0){
list.add(sb.toString());
}
return list;
}
26
U kunt de methode split:
gebruiken
public class Demo {
public static void main(String args[]) {
String str = "004-034556";
if ((str.contains("-"))) {
String[] temp = str.split("-");
for (String part:temp) {
System.out.println(part);
}
}
else {
System.out.println(str + " does not contain \"-\".");
}
}
}
Antwoord 27
Gebruik String.split(regex) om een string te splitsen. Bekijk de volgende voorbeelden:
String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
Uitvoer
004
034556
Opmerking:
Deze splitsing (regex) neemt een regex als argument. Vergeet niet om de speciale tekens van de regex te escapen, zoals punt/punt.
Antwoord 28
String s="004-034556";
for(int i=0;i<s.length();i++)
{
if(s.charAt(i)=='-')
{
System.out.println(s.substring(0,i));
System.out.println(s.substring(i+1));
}
}
Zoals door iedereen vermeld, is split() de beste optie die in uw geval kan worden gebruikt. Een alternatieve methode kan het gebruik van substring() zijn.
Antwoord 29
Om een string te splitsen, gebruik String.split(regex):
String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);
Uitvoer:
004
034556