Comment partager une chaîne de caractères en Java

j'ai une corde, "004-034556" , que je veux diviser en deux cordes:

string1="004";
string2="034556";

qui signifie que la première chaîne contiendra les caractères avant '-' , et la seconde chaîne contiendra les caractères après '-' . Je veux aussi vérifier si la chaîne de caractères contient '-' . Si pas, je vais jeter une exception. Comment puis-je faire cela?

1327
demandé sur Praveen 2010-08-14 07:01:53
la source

30 ответов

utilisez simplement la méthode appropriée: String#split() .

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

notez que cela prend une expression régulière , alors n'oubliez pas d'échapper caractères spéciaux si nécessaire.

il sont 12 caractères avec des significations spéciales: la barre oblique \ , la barre oblique ^ , le signe dollar $ , la barre oblique période ou point . , la barre verticale ou le symbole de pipe | , le point d'interrogation ? , l'astérisque ou l'étoile * , le signe plus + , la parenthèse d'ouverture ( , la parenthèse de fermeture ) , et la parenthèse carrée d'ouverture [ , la boucle d'ouverture { , ces caractères spéciaux sont souvent appelés"métacaractères".

ainsi, si vous voulez diviser sur par exemple période / point . qui signifie " n'importe quel caractère " dans la regex, soit utiliser anti-slash \ pour échapper à l'individu caractère spécial comme split("\.") , ou d'utiliser des caractère de classe [] pour représenter le caractère littéral(s) comme split("[.]") , ou d'utiliser des Pattern#quote() pour échapper à l'ensemble de la chaîne comme split(Pattern.quote(".")) .

String[] parts = string.split(Pattern.quote(".")); // Split on period.

pour tester à l'avance si la chaîne contient certains caractères, il suffit d'utiliser String#contains() .

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

Note, Ceci ne prend pas une expression régulière. Pour cela, utilisez String#matches() à la place.

si vous souhaitez conserver le caractère split dans les pièces résultantes, utilisez regard positif . Dans le cas où vous voulez avoir la scission de caractère à l'extrémité de gauche, utilisez lookbehind positif en préfixant ?<= groupe sur le modèle.

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

dans le cas où vous voulez avoir le caractère split pour finir dans le côté droit, utilisez lookahead positif en préfixant ?= groupe sur le modèle.

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

si vous souhaitez limiter le nombre de pièces résultantes, alors vous pouvez fournir le nombre désiré comme deuxième argument de la méthode split() .

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42
2401
répondu BalusC 2017-08-02 15:34:46
la source

une alternative au traitement direct de la chaîne serait d'utiliser une expression régulière avec des groupes de capture. Cela présente l'avantage qu'il est facile d'impliquer des contraintes plus sophistiquées sur l'entrée. Par exemple, le texte suivant divise la chaîne en deux parties, et garantit que les deux se composent uniquement de chiffres:

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");
    }
}

comme le modèle est fixe dans ce cas, il peut être compilé à l'avance et stocké comme un membre statique (initialisé au moment de la charge de classe dans l'exemple). L'expression régulière est:

(\d+)-(\d+)

les parenthèses indiquent les groupes de capture; la chaîne qui correspond à cette partie de regexp peut être accédée par la correspondance.méthode group (), comme illustré. Le \d correspond à un seul chiffre décimal, et le + signifie "correspondre à une ou plusieurs des expressions précédentes). Le - n'a pas de sens particulier, donc correspond juste à ce caractère dans l'entrée. Notez que vous avez besoin de double-échapper les barres obliques lors de l'écriture ceci comme une chaîne de caractères Java. Quelques autres exemples:

([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
68
répondu Rob Hague 2017-07-17 19:09:43
la source
String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

cela divisera votre chaîne en 2 parties. Le premier élément du tableau sera la partie contenant la substance avant de l' - , et le 2ème élément du tableau contient la partie de votre chaîne de caractères après le - .

si la longueur du tableau n'est pas 2, alors la chaîne n'était pas au format string-string .

Vérifiez la méthode split() dans la classe String .

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int -

39
répondu jjnguy 2016-01-05 10:36:37
la source
// 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]);
}
26
répondu Mnyikka 2014-04-24 00:45:15
la source
String[] out = string.split("-");

devrait faire ce que vous voulez. String class a beaucoup de méthode pour fonctionner avec string.

23
répondu secmask 2010-08-14 07:06:21
la source

les prescriptions laissent une marge d'interprétation. Je recommande l'écriture d'une méthode,

public final static String[] mySplit(final String s)

qui encapsule cette fonction. Bien sûr, vous pouvez utiliser des chaînes de caractères.Split.(.) comme mentionné dans les autres réponses pour la mise en œuvre.

vous devriez écrire quelques tests unitaires pour les chaînes d'entrée et les résultats et comportements souhaités.

Bon les candidats à l'examen devrait inclure:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

avec en définissant les résultats des tests, vous pouvez spécifier le comportement.

par exemple, si "-333" doit retourner dans [,333] ou s'il s'agit d'une erreur. Peut "333-333-33" être séparé [333,333-33] or [333-333,33] ou est-ce une erreur? Et ainsi de suite.

17
répondu Michael Konietzka 2015-03-21 11:49:49
la source

vous pouvez essayer comme ceci aussi

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\^");
15
répondu SHUNMUGA RAJ PRABAKARAN 2013-01-15 13:58:38
la source

en supposant que

  • vous n'avez pas vraiment besoin d'expressions régulières pour votre split
  • il se trouve que vous utilisez déjà apache commons lang dans votre application

la manière la plus simple est d'utiliser StringUtils#split(java.lang.String, char) . C'est plus pratique que celui fourni par Java hors de la boîte si vous n'avez pas besoin d'expressions régulières. Comme son manuel dit, il fonctionne comme ceci:

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"]

je recommande l'utilisation de commong-lang, car il contient généralement beaucoup de choses qui sont utilisables. Cependant, si vous n'en avez pas besoin pour autre chose que faire un split, alors mettre en œuvre vous-même ou échapper à la regex est une meilleure option.

15
répondu eis 2014-03-25 10:43:17
la source

Utiliser org.Apache.commun.lang.La méthode de division de StringUtils qui peut séparer les chaînes en fonction du caractère ou de la chaîne que vous voulez séparer.

signature de la Méthode:

public static String[] split(String str, char separatorChar);

dans votre cas, vous voulez couper une corde quand il ya un" -".

, Vous pouvez simplement faire comme suit:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

sortie:

004
034556

Supposons que si - n'existe pas dans votre chaîne, il renvoie la chaîne donnée, et vous n'obtiendrez aucune exception.

15
répondu sandeep vanama 2015-06-25 12:44:35
la source

Avec Java 8:

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));
14
répondu Somaiah Kumbera 2017-05-21 14:07:32
la source

String Split avec plusieurs personnages en utilisant les 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]);
        }
     }
  }

sortie:

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

mais n'attendez pas la même sortie pour toutes les versions JDK. J'ai vu un bug qui existe dans certaines versions de JDK où la première chaîne nulle a été ignorée. Ce bug n'est pas présent dans la dernière version de JDK, mais il existe dans certaines versions entre JDK 1.7 late versions et 1.8 versions anciennes.

12
répondu Ravindra babu 2016-07-02 21:58:10
la source

pour les cas d'utilisation simple String.split() devrait faire le travail. Si vous utilisez la goyave, il existe aussi une classe Splitter qui permet le chaînage de différentes opérations de chaîne et supporte CharMatcher :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
11
répondu Vitalii Fedorenko 2018-02-15 18:28:39
la source
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);
    }
}
10
répondu Akhilesh Dhar Dubey 2017-08-29 12:29:39
la source

la voie la plus rapide, qui consomme également le moins de ressources pourrait être:

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 '-'
}
9
répondu David 2014-03-20 08:37:06
la source

vous pouvez diviser une chaîne par un saut de ligne en utilisant la déclaration suivante:

String textStr[] = yourString.split("\r?\n");

vous pouvez diviser une chaîne par un trait d'Union / caractère en utilisant la déclaration suivante:

String textStr[] = yourString.split("-");
9
répondu RajeshVijayakumar 2014-11-29 15:19:46
la source
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]);
    }
  }
}
9
répondu Ravi Pandey 2016-11-17 13:00:21
la source

une façon de faire cela est de passer par la chaîne dans une boucle pour chaque boucle et d'utiliser le caractère split requis.

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);
    }
}

sortie:

The split parts of the String are:
004
034556
7
répondu Keshav Pradeep Ramanath 2015-10-04 21:49:10
la source

s'il vous Plaît ne pas utiliser StringTokenizer classe comme c'est un héritage de la classe qui est retenu pour des raisons de compatibilité, et son utilisation est déconseillée dans le nouveau code. Et nous pouvons utiliser la méthode du partage, comme d'autres l'ont suggéré.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

et comme prévu il affichera:

[004, 034556]

dans cette réponse, je tiens également à souligner un changement qui a eu lieu pour split méthode en Java 8 . La méthode utilise Pattern.split , et maintenant elle va supprimer les chaînes vides au début du tableau de résultats. Notez ce change dans la documentation pour Java 8:

Lorsqu'il y a correspondance positive-width au début de l'entrée séquence puis une sous-couche vide est incluse au début de la matrice résultante. Une correspondance zéro-Largeur au début cependant ne produit jamais un substrat aussi vide.

signifie dans l'exemple suivant:

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

nous obtiendrons trois cordes: [0, 0, 4] et non quatre comme C'était le cas dans Java 7 et avant. Cochez également cette question similaire à la question .

7
répondu i_am_zero 2016-07-02 21:59:47
la source

vous pouvez utiliser Split ():

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];
    }
}

sinon, vous pouvez utiliser StringTokenizer:

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("-");
    }
}
7
répondu Sarat Chandra 2018-02-06 18:03:49
la source

voici deux façons d'y parvenir.

chemin 1: comme vous devez diviser deux numéros par un caractère spécial, vous pouvez utiliser regex

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());
        }
    }
}

CHEMIN 2: à l'Aide de la chaîne de méthode split

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);
        }
    }
}
7
répondu Akshay Gaikwad 2018-02-06 18:05:33
la source

vous pouvez simplement utiliser StringTokenizer pour diviser une chaîne en deux ou plusieurs parties, qu'il y ait un type quelconque de délimiteurs:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}
5
répondu Rohit-Pandey 2018-02-06 18:06:59
la source

pour résumer: il y a au moins cinq façons de diviser une chaîne en Java:

  1. de la Chaîne.split ():

    String[] parts ="10,20".split(",");
    
  2. Pattern.compiler(regexp).splitAsStream (input):

    List<String> strings = Pattern.compile("\|")
          .splitAsStream("010|020202")
          .collect(Collectors.toList());
    
  3. StringTokenizer (héritage de la classe):

    StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
    while(strings.hasMoreTokens()){
        String substring = strings.nextToken();
        System.out.println(substring);
    }
    
  4. Google Goyave Splitter:

    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
    
  5. Apache Commons StringUtils:

    String[] strings = StringUtils.split("1,2,3,4", ",");
    

ainsi vous pouvez choisir la meilleure option pour vous en fonction de ce que vous avez besoin, par exemple le type de retour (array, list, ou iterable).

Ici est un grand aperçu de ces méthodes et les exemples les plus courants (comment diviser par point, barre oblique, point d'interrogation, etc.)

5
répondu Dmytro Shvechikov 2018-02-06 18:10:13
la source

Vérifiez la méthode split() dans la classe String sur 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++;
}

ici beaucoup d'exemples pour la corde fendue mais j'ai peu de code optimisé.

4
répondu Divyesh Kanzariya 2016-07-22 13:04:34
la source
String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];
4
répondu Shivanandam Sirmarigari 2016-11-20 07:43:14
la source
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));
    }
}

comme mentionné par tout le monde, split() est la meilleure option qui peut être utilisée dans votre cas. Une méthode alternative peut être l'utilisation de substring().

0
répondu SAM Jr 2017-02-24 13:12:25
la source

pour séparer une chaîne, utilisez String.split(regex) :

String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

sortie:

004
034556
0
répondu KIBOU Hassan 2018-02-06 18:06:10
la source

je voulais juste écrire un algorithme au lieu D'utiliser les fonctions intégrées de Java:

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;
}
0
répondu None 2018-02-06 18:11:50
la source

pour séparer une chaîne, utilise la chaîne.split (regex). Examinez les exemples suivants:

String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

sortie

004
034556

Note Cette split (regex) prend un regex comme argument, n'oubliez pas d'échapper aux caractères spéciaux regex, comme period/dot.

0
répondu KIBOU Hassan 2018-03-08 17:28:00
la source

de la documentation:

public String[] split(String regex,int limit) divise cette chaîne autour des correspondances de l'expression régulière donnée . Le tableau retourné par cette méthode contient chaque la soustraction de cette chaîne qui est terminée par un autre la soustraction qui correspond à l'expression donnée ou est résilié à la fin de l' chaîne. Les substrats dans le tableau sont dans le ordonnance dans laquelle ils se produire dans cette chaîne. Si l'expression ne correspond pas à d'entrée puis le tableau qui en résulte vient de un élément , , à savoir ce chaîne.

en gros, vous pouvez faire quelque chose comme ça:

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array
   System.out.println(subString);
}

sortie:

123
456
789
123
-1
répondu Peter Mortensen 2018-02-06 18:07:46
la source
 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

si vous avez un caractère spécial, vous pouvez utiliser Patter.citation. Si vous avez simplement dash ( - ) alors vous pouvez raccourcir le code:

 String string = "004-34";
 String[] parts = string.split("-");

si vous essayez d'ajouter un autre caractère spécial à la place du tiret ( ^ ) alors l'erreur générera ArrayIndexOutOfBoundsException . Pour cela, vous devez utiliser Pattern.quote .

-2
répondu Aditya Singh 2018-02-06 18:08:55
la source

Autres questions sur java string