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

Question

J'ai une corde, "004-034556" que je veux diviser en deux chaînes de caractères :

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 '-' en elle. Si ce n'est pas le cas, je lèverai une exception. Comment puis-je faire cela ?

Answer 1

Il suffit d'utiliser 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 de vous échapper caractères spéciaux si nécessaire.

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

Ainsi, si vous voulez diviser sur, par exemple, période/point . ce qui signifie " tout caractère "dans une expression rationnelle, utilisez soit barre oblique inversée \ pour échapper au caractère spécial individuel, comme suit split("\\.") ou utiliser classe de caractères [] pour représenter un ou plusieurs caractères littéraux, comme suit split("[.]") ou utiliser Pattern#quote() pour échapper à la chaîne entière, comme suit split(Pattern.quote(".")) .

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

Pour tester au préalable si la chaîne de caractères contient un ou plusieurs caractères, il suffit d'utiliser String#contains() .

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

Notez que cela ne prend pas d'expression régulière. Pour cela, utilisez String#matches() à la place.

Si vous souhaitez conserver le caractère divisé dans les parties résultantes, utilisez la fonction regard positif . Si vous voulez que le caractère divisé se retrouve dans la partie gauche, utilisez un lookbehind positif en préfixant ?<= sur le motif.

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

Dans le cas où vous voulez que le caractère divisé se retrouve à droite, utilisez un lookahead positif en préfixant ?= sur le motif.

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 nombre souhaité en tant que deuxième argument de la commande split() méthode.

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

Answer 2

Une alternative au traitement direct de la chaîne de caractères serait d'utiliser une expression régulière avec des groupes de capture. L'avantage de cette méthode est qu'elle permet d'impliquer des contraintes plus sophistiquées sur l'entrée. Par exemple, l'expression suivante divise la chaîne de caractères en deux parties, et s'assure que les deux ne sont constituées que 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 motif est fixe dans cette instance, il peut être compilé à l'avance et stocké comme un 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 qui correspond à cette partie de la regexp est accessible par la méthode Match.group(), comme indiqué. Le site \d correspond à un seul chiffre décimal, et le + signifie "correspond à une ou plusieurs des expressions précédentes".) Le - n'a pas de signification particulière et correspond simplement à ce caractère dans l'entrée. Notez que vous devez doubler l'échappement des barres obliques inversées lorsque vous écrivez cette expression sous forme de 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

Answer 3

Utilisez :

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

Cela va diviser votre chaîne en deux parties. Le premier élément du tableau sera la partie qui contient le contenu avant l'élément - et le deuxième élément du tableau contiendra la partie de votre chaîne de caractères après l'élément - .

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

Consultez le split() dans la méthode String classe.

Answer 4

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

devrait faire la chose que vous voulez. Le site chaîne de caractères a de nombreuses méthodes pour opérer avec une chaîne de caractères.

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