Question Comment diviser une chaîne en Java


J'ai une chaîne, "004-034556", que je veux diviser en deux chaînes:

string1=004
string2=034556

Cela signifie que la première chaîne contiendra les caractères avant '-', et la deuxième chaîne contiendra les caractères après '-'. Je veux aussi vérifier si la chaîne a '-' dedans. Sinon, je vais lancer une exception. Comment puis-je faire ceci?


1278
2017-08-14 03:01


origine


Réponses:


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 un expression régulière, alors n'oubliez pas d'échapper caractères spéciaux si nécessaire.

 sont 12 caractères avec des significations spéciales: l'antislash \, le caret ^, le signe du dollar $, la période ou le point ., le symbole de la barre ou de la barre verticale |, le point d'interrogation ?, l'astérisque ou l'étoile *, le signe plus +, la parenthèse ouvrante (, la parenthèse fermante )et le crochet carré d'ouverture [, l'accolade d'ouverture {, Ces caractères spéciaux sont souvent appelés "métacaractères".

Donc, si vous voulez diviser par exemple période / point . ce qui signifie "n'importe quel personnage"dans regex, utilisez soit antislash \ pour échapper au caractère spécial individuel comme si split("\\."), Ou utiliser classe de caractères [] représenter le (s) caractère (s) littéral (s) comme ça split("[.]"), Ou utiliser Pattern#quote() pour échapper à la chaîne entière comme si split(Pattern.quote(".")).

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

Pour tester au préalable 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 -");
}

Notez que ceci ne prend pas une expression régulière. Pour cela, utilisez String#matches() au lieu.

Si vous souhaitez conserver le caractère de division dans les parties résultantes, utilisez Lookaround positif. Dans le cas où vous souhaitez que le caractère de séparation se retrouve dans le côté gauche, utilisez le 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 souhaitez que le caractère de séparation se retrouve dans le côté droit, utilisez une anticipation positive 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, vous pouvez fournir le numéro désiré comme 2ème argument de split() méthode.

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

2349
2017-08-14 03:05



Une alternative au traitement direct de la chaîne consisterait à utiliser une expression régulière avec des groupes de capture. Cela a l'avantage de simplifier les contraintes sur l'entrée. Par exemple, ce qui suit scinde la chaîne en deux parties et garantit que les deux ne contiennent que des 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 motif est fixé dans cette instance, il peut être compilé à l'avance et stocké en tant que membre statique (initialisé au moment du chargement de la classe dans l'exemple). L'expression régulière est:

(\d+)-(\d+)

Les parenthèses indiquent les groupes de capture; la chaîne correspondant à cette partie de l'expression rationnelle est accessible par la méthode Match.group (), comme indiqué. Le \ d correspond à un seul chiffre décimal, et le signe + signifie "correspondre à une ou plusieurs expressions précédentes." Le - n'a pas de signification particulière, donc correspond juste à ce caractère dans l'entrée Notez que vous devez double-échapper les barres obliques inverses lors de l'écriture en tant que chaîne 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
2017-08-14 11:28



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 le contenu avant le -, et le 2ème élément dans le tableau contiendra la partie de votre chaîne après le -.

Si la longueur du tableau n'est pas 2, la chaîne n'a pas le format suivant: string-string.

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

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


39
2017-08-14 03:06



// 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
2017-11-16 06:30



String[] out = string.split("-");

devrait faire ce que vous voulez. La classe String a de nombreuses méthodes pour fonctionner avec une chaîne.


23
2017-08-14 03:06



Les exigences laissaient place à l'interprétation. Je recommande d'écrire une méthode,

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

qui encapsule cette fonction. Bien sûr, vous pouvez utiliser String.split (..) comme mentionné dans les autres réponses pour l'implémentation.

Vous devez écrire des tests unitaires pour les chaînes d'entrée et les résultats et le comportement souhaités.

Les bons candidats doivent inclure:

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

En définissant les résultats de test correspondants, vous pouvez spécifier le comportement.

Par exemple, si "-333" devrait revenir dans [,333] ou si c'est une erreur. Pouvez "333-333-33" être séparé en [333,333-33] or [333-333,33] ou est-ce une erreur? Etc.


17
2017-08-14 06:57



En admettant 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

Le moyen le plus simple est d'utiliser StringUtils # split (java.lang.String, char). C'est plus pratique que celui fourni par Java dès la sortie de la boîte si vous n'avez pas besoin d'expressions régulières. Comme son manuel le dit, cela 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 recommanderais d'utiliser commong-lang, car il contient généralement beaucoup de choses utilisables. Cependant, si vous n'en avez pas besoin pour autre chose que de faire une division, alors vous implémenter ou échapper à la regex est une meilleure option.


15
2018-03-25 06:43



Utilisation org.apache.commons.lang.StringUtils ' méthode split qui peut diviser les chaînes en fonction du caractère ou de la chaîne que vous voulez diviser.

Signature de méthode:

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

Dans votre cas, vous voulez diviser une chaîne lorsqu'il y a 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
2017-07-01 04:35



Vous pouvez essayer comme ça aussi

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

14
2018-01-15 09:58



Avec Java 8:

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

    stringList.forEach(s -> System.out.println(s));

14
2017-12-01 09:32