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

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

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 -

// 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. String class a beaucoup de méthode pour fonctionner avec string.

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.

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

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.

Avec Java 8:

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

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

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.

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

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

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 '-'
}

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

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

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 .

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.

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

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

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

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

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 méthode alternative peut être l'utilisation de substring().

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

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

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.

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