¿Cómo divido una cadena en Java?

Quiero dividir la cadena "004-034556" en dos cadenas por el delimitador "-":

part1 = "004";
part2 = "034556";

Eso significa que la primera cadena contendrá los caracteres anteriores '-'y la segunda cadena contendrá los caracteres después '-'.

También quiero comprobar si la cadena tiene '-' en eso.

Una alternativa para procesar la cadena directamente sería usar una expresión regular con grupos de captura. Esto tiene la ventaja de que facilita la implicación de restricciones más sofisticadas en la entrada. Por ejemplo, lo siguiente divide la cadena en dos partes y garantiza que ambas constan solo de dígitos:

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

Como el patrón es fijo en esta instancia, se puede compilar de antemano y almacenar como un miembro estático (inicializado en el momento de carga de la clase en el ejemplo). La expresión regular es:

(\d+)-(\d+)

Los paréntesis indican los grupos de captura; se puede acceder a la cadena que coincidió con esa parte de la expresión regular mediante el método Match.group(), como se muestra. El \d coincide con un solo dígito decimal, y el + significa “coincide con una o más de la expresión anterior”. El – no tiene un significado especial, por lo que solo coincide con ese carácter en la entrada. Tenga en cuenta que necesita escapar dos veces de las barras diagonales inversas al escribir esto como una cadena Java.Algunos otros ejemplos:

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

Este:

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

debe hacer lo que quiere. los cuerda La clase tiene muchos métodos para operar con una cadena.

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

Con Java 8:

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

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