Comment diviser une chaîne en Java

Une alternative au traitement direct de la chaîne serait d'utiliser une expression régulière avec la capture de groupes. Cela a l'avantage qu'il est facile d'impliquer des contraintes plus sophistiquées sur l'entrée. Par exemple, ce qui suit divise la chaîne en deux parties et garantit que les deux ne sont constitués 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 modèle est fixe dans ce cas, il peut être compilé à l'avance et stocké en tant que membre statique (initialisé au moment du chargement de la classe dans le exemple). L'expression régulière est:

(\d+)-(\d+)

Les parenthèses indiquent les groupes de capture; la chaîne qui correspondait à cette partie de l'expression régulière est accessible par la correspondance.méthode group (), comme indiqué. Le \d correspond et un seul chiffre décimal, et le + signifie " correspondre à une ou plusieurs des expressions précédentes). Le - n'a pas de signification particulière, donc correspond simplement à ce caractère dans l'entrée. Notez que vous devez double-échapper les barres obliques inverses lorsque vous écrivez ceci en tant que chaîne Java. Certains 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

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 après le -.

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

Découvrez 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-

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

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

Devrait faire ce que vous voulez. La classe String a de nombreuses méthodes pour fonctionner avec string.

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

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

Qui encapsulent 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 devez écrire des tests unitaires pour les chaînes d'entrée et les résultats et le comportement souhaités.

Les bons candidats devraient 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 retourner dans [,333] ou s'il s'agit d'une erreur. "333-333-33" peut-il être séparé dans [333,333-33] or [333-333,33] ou s'agit-il d'une erreur? Et ainsi de suite.

Vous pouvez essayer comme ceci aussi

 String concatenated_String="hi^Hello";

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

En Supposant que

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

Le moyen le plus simple est d'utiliser StringUtils#split(java.lang.Chaîne, char) . C'est plus pratique que celui fourni par Java prêt à l'emploi si vous n'avez pas besoin d'expressions régulières. Comme le dit son manuel, 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 trucs que c'est utilisable. Cependant, si vous n'en avez pas besoin pour autre chose que de faire un fractionnement, alors vous implémenter ou échapper à l'expression régulière est une meilleure option.

Utiliser org.Apache.commun.lang.La méthode split de StringUtils peut diviser des chaînes en fonction du caractère ou de la chaîne que vous souhaitez diviser.

Signature de la méthode:

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

Dans votre cas, vous souhaitez 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.

Avec Java 8:

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

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

Chaîne divisée avec plusieurs caractères à l'aide de 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 ne vous attendez pas à la même sortie dans toutes les versions JDK. J'ai vu un bug, qui existe dans certaines versions JDK où la première chaîne null a été ignorée. Ce bogue n'est pas présent dans la dernière version de JDK, mais il existe dans certaines versions entre les versions tardives de JDK 1.7 et les versions précoces de 1.8.

Pour des cas d'utilisation simples String.split() devrait faire le travail. Si vous utilisez guava, il existe également une classe Splitter qui permet le chaînage de différentes opérations de chaîne et prend en charge CharMatcher :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

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

Le moyen le 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 '-'
}

Vous pouvez diviser une chaîne par un saut de ligne en utilisant l'instruction suivante:

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

Vous pouvez diviser une chaîne par un trait d'union/personnage en utilisant l'instruction suivante:

String textStr[] = yourString.split("-");

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

Une façon de le faire est de parcourir la chaîne dans une boucle for-each et d'utiliser le caractère divisé 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

Veuillez ne pas utiliser la classe StringTokenizer car c'est une classe héritée qui est conservée pour des raisons de compatibilité, et son utilisation est déconseillée dans le nouveau code. Et nous pouvons également utiliser la méthode split comme suggéré par d'autres.

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

Et comme prévu, il imprimera:

[004, 034556]

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

Quand il y a une correspondance de largeur positive au début de l'entrée séquence puis une sous chaîne principale vide est incluse au début de la matrice résultante. Une correspondance de largeur nulle au début cependant ne produit jamais une telle sous-chaîne principale vide.

Cela signifie pour l'exemple suivant:

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

Nous obtiendrons trois chaînes: [0, 0, 4] et non quatre comme ce fut le cas dans Java 7 et avant. Vérifiez également cette question similaire .

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

Voici deux façons d'y parvenir.

VOIE 1: Comme vous devez diviser deux nombres 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());
        }
    }
}

MÉTHODE 2: Utilisation de la méthode string 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);
        }
    }
}

Vous pouvez simplement utiliser StringTokenizer pour diviser une chaîne en deux parties ou plus, qu'il existe un type de délimiteurs:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

Pour résumer: il existe au moins cinq façons de diviser une chaîne en Java:

1. Chaîne.split():

   String[] parts ="10,20".split(",");
   

2. Motif.compiler (expression rationnelle).splitAsStream (entrée):

   List<String> strings = Pattern.compile("\\|")
         .splitAsStream("010|020202")
         .collect(Collectors.toList());
   

3. StringTokenizer (classe héritée):

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

Vous pouvez donc choisir la meilleure option pour vous en fonction de ce dont vous avez besoin, par exemple le type de retour (tableau, liste, ou itératif).

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.)

Consultez 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++;
}

Voici de nombreux exemples pour la chaîne fractionnée mais j'ai peu de code optimisé.

String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];

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 autre méthode peut utiliser substring ().

Pour diviser 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

Je voulais juste écrire un algorithme au lieu d'utiliser des fonctions intégrées 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;
}

Pour diviser une chaîne, utilise String.split(regex). Passez en revue les exemples suivants:

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

Sortie

004
034556

Remarque Cette division (regex) prend une regex comme argument, n'oubliez pas d'échapper aux caractères spéciaux regex, comme point/point.

De la documentation:

public String[] split(String regex,int limit) Divise cette chaîne autour de matchs de l'expression régulière donnée. Le tableau renvoyé par cette méthode contient sous-chaîne de cette chaîne terminée par une autre sous-chaîne qui correspond à l'expression donnée ou se termine à la fin de la chaîne. Les sous-chaînes dans le tableau sont dans le afin dans lequel ils se produire dans cette chaîne. Si l'expression ne correspond pas à une partie de la entrée puis le tableau résultant a juste un élément, à savoir ceci chaîne.

, Fondamentalement, vous pouvez faire quelque chose comme ceci:

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

 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 ( - ), 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 (^) ensuite, l'erreur générera ArrayIndexOutOfBoundsException . Pour cela, vous devez utiliser Pattern.quote.