¿Cómo dividir una cadena, pero también mantener los delimitadores?

Tengo una cadena multilínea que está delimitada por un conjunto de delimitadores diferentes:

(Text1)(DelimiterA)(Text2)(DelimiterC)(Text3)(DelimiterB)(Text4) 

Puedo dividir esta cadena en sus partes, usando String.split , pero parece que no puedo obtener la cadena real, que coincide con la expresión regular del delimitador.

En otras palabras, esto es lo que obtengo:

  • Text1
  • Text2
  • Text3
  • Text4

Esto es lo que quiero

  • Text1
  • DelimiterA
  • Text2
  • DelimiterC
  • Text3
  • DelimiterB
  • Text4

¿Hay alguna forma JDK para dividir la cadena utilizando un delimitador de expresiones regulares, pero también mantener los delimitadores?

Puedes usar Lookahead y Lookbehind. Me gusta esto:

 System.out.println(Arrays.toString("a;b;c;d".split("(?<=;)"))); System.out.println(Arrays.toString("a;b;c;d".split("(?=;)"))); System.out.println(Arrays.toString("a;b;c;d".split("((?<=;)|(?=;))"))); 

Y obtendrás:

 [a;, b;, c;, d] [a, ;b, ;c, ;d] [a, ;, b, ;, c, ;, d] 

El último es lo que quieres.

((?<=;)|(?=;)) equivale a seleccionar un carácter vacío antes ; o después ; .

Espero que esto ayude.

EDITAR comentarios de Fabian Steeg sobre la legibilidad es válido. La legibilidad siempre es el problema para RegEx. Una cosa que hago para ayudar a facilitar esto es crear una variable cuyo nombre represente lo que hace la expresión regular y use el formato Java String para ayudarlo. Me gusta esto:

 static public final String WITH_DELIMITER = "((?<=%1$s)|(?=%1$s))" ; ... public void someMethod() { ... final String[] aEach = "a;b;c;d". split(String.format(WITH_DELIMITER, ";")) ; ... } ... 

Esto ayuda un poco. :-RE

Desea utilizar vistas alternativas y dividir en coincidencias de ancho cero. Aquí hay unos ejemplos:

 public class SplitNDump { static void dump(String[] arr) { for (String s : arr) { System.out.format("[%s]", s); } System.out.println(); } public static void main(String[] args) { dump("1,234,567,890".split(",")); // "[1][234][567][890]" dump("1,234,567,890".split("(?=,)")); // "[1][,234][,567][,890]" dump("1,234,567,890".split("(?<=,)")); // "[1,][234,][567,][890]" dump("1,234,567,890".split("(?<=,)|(?=,)")); // "[1][,][234][,][567][,][890]" dump(":a:bb::c:".split("(?=:)|(?<=:)")); // "[][:][a][:][bb][:][:][c][:]" dump(":a:bb::c:".split("(?=(?!^):)|(?<=:)")); // "[:][a][:][bb][:][:][c][:]" dump(":::a::::bb::c:".split("(?=(?!^):)(? 

Y sí, eso es una afirmación triplemente anidada en el último patrón.

Preguntas relacionadas

  • La división de Java está comiendo mis personajes.
  • ¿Se puede usar una expresión regular de coincidencia de ancho cero en String split?
  • ¿Cómo convierto CamelCase en nombres legibles para humanos en Java?
  • Backreferences en lookbehind

Ver también

  • regular-expressions.info/Lookarounds

Una solución muy ingenua, que no implica regex sería realizar una cadena de reemplazo en su delimitador a lo largo de las líneas de (suponiendo que coma para el delimitador):

 string.replace(FullString, "," , "~,~") 

Donde puede reemplazar tilda (~) con un delimitador único apropiado.

Entonces, si haces una división en tu nuevo delimitador, entonces creo que obtendrás el resultado deseado.

 import java.util.regex.*; import java.util.LinkedList; public class Splitter { private static final Pattern DEFAULT_PATTERN = Pattern.compile("\\s+"); private Pattern pattern; private boolean keep_delimiters; public Splitter(Pattern pattern, boolean keep_delimiters) { this.pattern = pattern; this.keep_delimiters = keep_delimiters; } public Splitter(String pattern, boolean keep_delimiters) { this(Pattern.compile(pattern==null?"":pattern), keep_delimiters); } public Splitter(Pattern pattern) { this(pattern, true); } public Splitter(String pattern) { this(pattern, true); } public Splitter(boolean keep_delimiters) { this(DEFAULT_PATTERN, keep_delimiters); } public Splitter() { this(DEFAULT_PATTERN); } public String[] split(String text) { if (text == null) { text = ""; } int last_match = 0; LinkedList splitted = new LinkedList(); Matcher m = this.pattern.matcher(text); while (m.find()) { splitted.add(text.substring(last_match,m.start())); if (this.keep_delimiters) { splitted.add(m.group()); } last_match = m.end(); } splitted.add(text.substring(last_match)); return splitted.toArray(new String[splitted.size()]); } public static void main(String[] argv) { if (argv.length != 2) { System.err.println("Syntax: java Splitter  "); return; } Pattern pattern = null; try { pattern = Pattern.compile(argv[0]); } catch (PatternSyntaxException e) { System.err.println(e); return; } Splitter splitter = new Splitter(pattern); String text = argv[1]; int counter = 1; for (String part : splitter.split(text)) { System.out.printf("Part %d: \"%s\"\n", counter++, part); } } } /* Example: > java Splitter "\W+" "Hello World!" Part 1: "Hello" Part 2: " " Part 3: "World" Part 4: "!" Part 5: "" */ 

Realmente no me gusta para el otro lado, donde obtienes un elemento vacío al frente y atrás. Por lo general, un delimitador no está al principio o al final de la cadena, por lo que a menudo terminas desperdiciando dos ranuras de buena matriz.

Editar: casos límite fijos. Fuente comentada con casos de prueba se puede encontrar aquí: http://snippets.dzone.com/posts/show/6453

Llegué tarde, pero volviendo a la pregunta original, ¿por qué no usar solo lookarounds?

 Pattern p = Pattern.compile("(?<=\\w)(?=\\W)|(?<=\\W)(?=\\w)"); System.out.println(Arrays.toString(p.split("'ab','cd','eg'"))); System.out.println(Arrays.toString(p.split("boo:and:foo"))); 

salida:

 [', ab, ',', cd, ',', eg, '] [boo, :, and, :, foo] 

EDITAR: Lo que ves arriba es lo que aparece en la línea de comando cuando ejecuto ese código, pero ahora veo que es un poco confuso. Es difícil hacer un seguimiento de las comas que forman parte del resultado y que fueron agregadas por Arrays.toString() . El resaltado de syntax de SO tampoco ayuda. Con la esperanza de que el resaltado trabaje conmigo en lugar de contra mí, así es como se verían esas matrices, las declaraba en el código fuente:

 { "'", "ab", "','", "cd", "','", "eg", "'" } { "boo", ":", "and", ":", "foo" } 

Espero que sea más fácil de leer. Gracias por el aviso, @finnw.

Sé que esta es una pregunta muy vieja y la respuesta también ha sido aceptada. Pero aún me gustaría enviar una respuesta muy simple a la pregunta original. Considera este código:

 String str = "Hello-World:How\nAre You&doing"; inputs = str.split("(?!^)\\b"); for (int i=0; i 

SALIDA:

 a[0] = "Hello" a[1] = "-" a[2] = "World" a[3] = ":" a[4] = "How" a[5] = " " a[6] = "Are" a[7] = " " a[8] = "You" a[9] = "&" a[10] = "doing" 

Solo estoy usando el límite de palabras \b para delimitar las palabras, excepto cuando es el comienzo del texto.

Eché un vistazo a las respuestas anteriores y, sinceramente, ninguna de ellas me parece satisfactoria. Lo que quiere hacer es imitar esencialmente la funcionalidad de división de Perl. Por qué Java no permite esto y tiene un método join () en alguna parte me supera, pero estoy divagando. Ni siquiera necesitas una clase para esto realmente. Es solo una función. Ejecute este progtwig de ejemplo:

Algunas de las respuestas anteriores tienen una verificación nula excesiva, que recientemente escribí una respuesta a una pregunta aquí:

https://stackoverflow.com/users/18393/cletus

De todos modos, el código:

 public class Split { public static List split(String s, String pattern) { assert s != null; assert pattern != null; return split(s, Pattern.compile(pattern)); } public static List split(String s, Pattern pattern) { assert s != null; assert pattern != null; Matcher m = pattern.matcher(s); List ret = new ArrayList(); int start = 0; while (m.find()) { ret.add(s.substring(start, m.start())); ret.add(m.group()); start = m.end(); } ret.add(start >= s.length() ? "" : s.substring(start)); return ret; } private static void testSplit(String s, String pattern) { System.out.printf("Splitting '%s' with pattern '%s'%n", s, pattern); List tokens = split(s, pattern); System.out.printf("Found %d matches%n", tokens.size()); int i = 0; for (String token : tokens) { System.out.printf(" %d/%d: '%s'%n", ++i, tokens.size(), token); } System.out.println(); } public static void main(String args[]) { testSplit("abcdefghij", "z"); // "abcdefghij" testSplit("abcdefghij", "f"); // "abcde", "f", "ghi" testSplit("abcdefghij", "j"); // "abcdefghi", "j", "" testSplit("abcdefghij", "a"); // "", "a", "bcdefghij" testSplit("abcdefghij", "[bdfh]"); // "a", "b", "c", "d", "e", "f", "g", "h", "ij" } } 

Me gusta la idea de StringTokenizer porque es Enumerable.
Pero también es obsoleto y lo reemplaza por String.split, que devuelve una cadena aburrida [] (y no incluye los delimitadores).

Así que implementé un StringTokenizerEx que es un Iterable, y que toma una verdadera expresión regular para dividir una cadena.

Una expresión regular verdadera significa que no se repite una ‘secuencia de caracteres’ para formar el delimitador:
‘o’ solo coincidirá con ‘o’, y dividirá ‘ooo’ en tres delimitadores, con dos cadenas vacías dentro:

 [o], '', [o], '', [o] 

Pero la expresión regular + devolverá el resultado esperado al dividir “aooob”

 [], 'a', [ooo], 'b', [] 

Para usar este StringTokenizerEx:

 final StringTokenizerEx aStringTokenizerEx = new StringTokenizerEx("boo:and:foo", "o+"); final String firstDelimiter = aStringTokenizerEx.getDelimiter(); for(String aString: aStringTokenizerEx ) { // uses the split String detected and memorized in 'aString' final nextDelimiter = aStringTokenizerEx.getDelimiter(); } 

El código de esta clase está disponible en DZone Snippets .

Como es habitual para una respuesta de desafío de código (una clase autónoma con casos de prueba incluidos), cópiela y péguela (en un directorio ‘src / test’) y ejecútela . Su método main () ilustra los diferentes usos.


Nota: (edición de finales de 2009)

El artículo Final Thoughts: Java Puzzler: Splitting Hairs hace un buen trabajo al explicar el comportamiento extraño en String.split() .
Josh Bloch incluso comentó en respuesta a ese artículo:

Sí, esto es un dolor FWIW, fue hecho por una muy buena razón: compatibilidad con Perl.
El tipo que lo hizo es Mike “madbot” McCloskey, que ahora trabaja con nosotros en Google. Mike se aseguró de que las expresiones regulares de Java pasaran prácticamente todas las pruebas de expresiones regulares de 30K Perl (y se ejecutaran más rápido).

La biblioteca común de Google Guava contiene también un Splitter que es:

  • más simple de usar
  • mantenido por Google (y no por usted)

Entonces vale la pena que lo revisen. De su primera documentación aproximada (pdf) :

JDK tiene esto:

 String[] pieces = "foo.bar".split("\\."); 

Está bien usar esto si quieres exactamente lo que hace: – expresión regular – resultado como una matriz – su forma de manejar las piezas vacías

Mini-rompecabezas: “, a ,, b,”. Split (“,”) devuelve …

 (a) "", "a", "", "b", "" (b) null, "a", null, "b", null (c) "a", null, "b" (d) "a", "b" (e) None of the above 

Respuesta: (e) Ninguna de las anteriores.

 ",a,,b,".split(",") returns "", "a", "", "b" 

¡Solo se vacían los vacíos finales! (¿Quién sabe la solución para evitar el salto? Es divertido …)

En cualquier caso, nuestro Splitter es simplemente más flexible: el comportamiento predeterminado es simplista:

 Splitter.on(',').split(" foo, ,bar, quux,") --> [" foo", " ", "bar", " quux", ""] 

Si desea funciones adicionales, ¡solicítelas!

 Splitter.on(',') .trimResults() .omitEmptyStrings() .split(" foo, ,bar, quux,") --> ["foo", "bar", "quux"] 

El orden de los métodos de configuración no es importante: durante la división, el recorte ocurre antes de verificar si hay vacíos.

Aquí hay una implementación sencilla y limpia que es consistente con la Pattern#split y funciona con patrones de longitud variable, que no se puede utilizar detrás de la vista atrás, y es más fácil de usar. Es similar a la solución proporcionada por @cletus.

 public static String[] split(CharSequence input, String pattern) { return split(input, Pattern.compile(pattern)); } public static String[] split(CharSequence input, Pattern pattern) { Matcher matcher = pattern.matcher(input); int start = 0; List result = new ArrayList<>(); while (matcher.find()) { result.add(input.subSequence(start, matcher.start()).toString()); result.add(matcher.group()); start = matcher.end(); } if (start != input.length()) result.add(input.subSequence(start, input.length()).toString()); return result.toArray(new String[0]); } 

Aquí no hago comprobaciones nulas, la Pattern#split no, ¿por qué? No me gusta if al final, pero se requiere coherencia con la Pattern#split del Pattern#split . De lo contrario, anexaría incondicionalmente, lo que daría como resultado una cadena vacía como último elemento del resultado si la cadena de entrada finaliza con el patrón.

Convierto a String [] por consistencia con Pattern#split , utilizo new String[0] new String[result.size()] lugar de new String[result.size()] , mire aquí por qué.

Aquí están mis pruebas:

 @Test public void splitsVariableLengthPattern() { String[] result = Split.split("/foo/$bar/bas", "\\$\\w+"); Assert.assertArrayEquals(new String[] { "/foo/", "$bar", "/bas" }, result); } @Test public void splitsEndingWithPattern() { String[] result = Split.split("/foo/$bar", "\\$\\w+"); Assert.assertArrayEquals(new String[] { "/foo/", "$bar" }, result); } @Test public void splitsStartingWithPattern() { String[] result = Split.split("$foo/bar", "\\$\\w+"); Assert.assertArrayEquals(new String[] { "", "$foo", "/bar" }, result); } @Test public void splitsNoMatchesPattern() { String[] result = Split.split("/foo/bar", "\\$\\w+"); Assert.assertArrayEquals(new String[] { "/foo/bar" }, result); } 

Pase el tercer auriga como “verdadero”. También devolverá delimitadores.

 StringTokenizer(String str, String delimiters, true); 

También publicaré mis versiones de trabajo (la primera es realmente similar a Markus).

 public static String[] splitIncludeDelimeter(String regex, String text){ List list = new LinkedList<>(); Matcher matcher = Pattern.compile(regex).matcher(text); int now, old = 0; while(matcher.find()){ now = matcher.end(); list.add(text.substring(old, now)); old = now; } if(list.size() == 0) return new String[]{text}; //adding rest of a text as last element String finalElement = text.substring(old); list.add(finalElement); return list.toArray(new String[list.size()]); } 

Y aquí hay una segunda solución y es redonda 50% más rápida que la primera:

 public static String[] splitIncludeDelimeter2(String regex, String text){ List list = new LinkedList<>(); Matcher matcher = Pattern.compile(regex).matcher(text); StringBuffer stringBuffer = new StringBuffer(); while(matcher.find()){ matcher.appendReplacement(stringBuffer, matcher.group()); list.add(stringBuffer.toString()); stringBuffer.setLength(0); //clear buffer } matcher.appendTail(stringBuffer); ///dodajemy reszte ciagu list.add(stringBuffer.toString()); return list.toArray(new String[list.size()]); } 

No sé de una función existente en la API de Java que hace esto (lo que no quiere decir que no existe), pero aquí está mi propia implementación (uno o más delimitadores se devolverán como un único token; si quieres cada delimitador que se devolverá como un token separado, necesitará un poco de adaptación):

 static String[] splitWithDelimiters(String s) { if (s == null || s.length() == 0) { return new String[0]; } LinkedList result = new LinkedList(); StringBuilder sb = null; boolean wasLetterOrDigit = !Character.isLetterOrDigit(s.charAt(0)); for (char c : s.toCharArray()) { if (Character.isLetterOrDigit(c) ^ wasLetterOrDigit) { if (sb != null) { result.add(sb.toString()); } sb = new StringBuilder(); wasLetterOrDigit = !wasLetterOrDigit; } sb.append(c); } result.add(sb.toString()); return result.toArray(new String[0]); } 

Sugiero usar Pattern y Matcher, que seguramente lograrán lo que quieres. Su expresión regular tendrá que ser algo más complicada de lo que está usando en String.split.

No creo que sea posible con String#split , pero puedes usar un StringTokenizer , aunque eso no te permitirá definir tu delimitador como una expresión regular, sino solo como una clase de caracteres de un solo dígito:

 new StringTokenizer("Hello, world. Hi!", ",.!", true); // true for returnDelims 

Si puede pagar, utilice el método de reemplazo de Java (objective CharSequence, reemplazo de la secuencia Char) y complete otro delimitador para dividir. Ejemplo: Quiero dividir la cadena “boo: and: foo” y mantener ‘:’ en su String a la derecha.

 String str = "boo:and:foo"; str = str.replace(":","newdelimiter:"); String[] tokens = str.split("newdelimiter"); 

Nota importante: ¡Esto solo funciona si no tienes más “nuevodelimitador” en tu Cadena! Por lo tanto, no es una solución general. Pero si conoce una CharSequence de la cual puede estar seguro de que nunca aparecerá en la Cadena, esta es una solución muy simple.

Otra solución candidata usando una expresión regular. Retiene el orden de token, coincide correctamente con múltiples tokens del mismo tipo en una fila. La desventaja es que la expresión regular es desagradable.

 package javaapplication2; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; public class JavaApplication2 { /** * @param args the command line arguments */ public static void main(String[] args) { String num = "58.5+variable-+98*78/96+a/78.7-3443*12-3"; // Terrifying regex: // (a)|(b)|(c) match a or b or c // where // (a) is one or more digits optionally followed by a decimal point // followed by one or more digits: (\d+(\.\d+)?) // (b) is one of the set + * / - occurring once: ([+*/-]) // (c) is a sequence of one or more lowercase latin letter: ([az]+) Pattern tokenPattern = Pattern.compile("(\\d+(\\.\\d+)?)|([+*/-])|([az]+)"); Matcher tokenMatcher = tokenPattern.matcher(num); List tokens = new ArrayList<>(); while (!tokenMatcher.hitEnd()) { if (tokenMatcher.find()) { tokens.add(tokenMatcher.group()); } else { // report error break; } } System.out.println(tokens); } } 

Muestra de salida:

 [58.5, +, variable, -, +, 98, *, 78, /, 96, +, a, /, 78.7, -, 3443, *, 12, -, 3] 

Respuesta rápida: use límites no físicos como \ b para dividir. Probaré y experimentaré para ver si funciona (lo usé en PHP y JS).

Es posible, y el tipo de trabajo, pero podría dividirse demasiado. En realidad, depende de la cadena que desea dividir y el resultado que necesita. Da más detalles, te ayudaremos mejor.

Otra forma es hacer su propia división, capturar el delimitador (suponiendo que sea variable) y agregarlo después al resultado.

Mi prueba rápida:

 String str = "'ab','cd','eg'"; String[] stra = str.split("\\b"); for (String s : stra) System.out.print(s + "|"); System.out.println(); 

Resultado:

 '|ab|','|cd|','|eg|'| 

Un poco demasiado… 🙂

Tweaked Pattern.split () para incluir un patrón coincidente en la lista

Adicional

 // add match to the list matchList.add(input.subSequence(start, end).toString()); 

Fuente completa

 public static String[] inclusiveSplit(String input, String re, int limit) { int index = 0; boolean matchLimited = limit > 0; ArrayList matchList = new ArrayList(); Pattern pattern = Pattern.compile(re); Matcher m = pattern.matcher(input); // Add segments before each match found while (m.find()) { int end = m.end(); if (!matchLimited || matchList.size() < limit - 1) { int start = m.start(); String match = input.subSequence(index, start).toString(); matchList.add(match); // add match to the list matchList.add(input.subSequence(start, end).toString()); index = end; } else if (matchList.size() == limit - 1) { // last one String match = input.subSequence(index, input.length()) .toString(); matchList.add(match); index = end; } } // If no match was found, return this if (index == 0) return new String[] { input.toString() }; // Add remaining segment if (!matchLimited || matchList.size() < limit) matchList.add(input.subSequence(index, input.length()).toString()); // Construct result int resultSize = matchList.size(); if (limit == 0) while (resultSize > 0 && matchList.get(resultSize - 1).equals("")) resultSize--; String[] result = new String[resultSize]; return matchList.subList(0, resultSize).toArray(result); } 

Aquí hay una versión maravillosa basada en algunos de los códigos anteriores, en caso de que ayude. Es corto, de todos modos. Condicionalmente incluye la cabeza y la cola (si no están vacías). La última parte es una demostración / caso de prueba.

 List splitWithTokens(str, pat) { def tokens=[] def lastMatch=0 def m = str=~pat while (m.find()) { if (m.start() > 0) tokens << str[lastMatch..this is the title',/<[^>]+>/], ['beforethis is the titleafter',/<[^>]+>/] ].each { println splitWithTokens(*it) } 

Una solución extremadamente ingenua e ineficaz que funciona sin embargo. Utilice dividir dos veces en la cadena y luego concatenar las dos matrices

 String temp[]=str.split("\\W"); String temp2[]=str.split("\\w||\\s"); int i=0; for(String string:temp) System.out.println(string); String temp3[]=new String[temp.length-1]; for(String string:temp2) { System.out.println(string); if((string.equals("")!=true)&&(string.equals("\\s")!=true)) { temp3[i]=string; i++; } // System.out.println(temp.length); // System.out.println(temp2.length); } System.out.println(temp3.length); String[] temp4=new String[temp.length+temp3.length]; int j=0; for(i=0;i 
  String expression = "((A+B)*CD)*E"; expression = expression.replaceAll("\\+", "~+~"); expression = expression.replaceAll("\\*", "~*~"); expression = expression.replaceAll("-", "~-~"); expression = expression.replaceAll("/+", "~/~"); expression = expression.replaceAll("\\(", "~(~"); //also you can use [(] instead of \\( expression = expression.replaceAll("\\)", "~)~"); //also you can use [)] instead of \\) expression = expression.replaceAll("~~", "~"); if(expression.startsWith("~")) { expression = expression.substring(1); } String[] expressionArray = expression.split("~"); System.out.println(Arrays.toString(expressionArray)); 

Si le preocupan las complicaciones, es posible que las cosas que se ven por delante o que se ven por detrás se presenten, y solo quiera un método de utilidad sólida que pueda hacer frente a cualquier patrón de fichas y cualquier separador que arroje. (¡Cuál es probablemente el caso!)

NB sorprendió al descubrir que la gente de Apache Commons no parece haber proporcionado esto, por ejemplo, en StringUtils .

También sugiero que esto debería ser una bandera en Pattern : i..e INCLUDE_SEPARATORS .

Pero esto es bastante simple si usa las clases Pattern y Matcher right:

  // NB could be a different spec for identifying tokens, of course! Pattern sepAndTokenPattern = Pattern.compile("(.*?)(\\w+)"); Matcher matcher = sepAndTokenPattern.matcher( stringForTokenising ); List tokenAndSeparatorList = new ArrayList(); // for most processing purposes you are going to want to know whether your // combined list of tokens and separators begins with a token or separator boolean startsWithToken = true; int matchEnd = -1; while (matcher.find()) { String preSep = matcher.group(1); if (!preSep.isEmpty()) { if( tokenAndSeparatorList.isEmpty() ){ startsWithToken = false; } // in implementation you wouldn't want these | characters, of course tokenAndSeparatorList.add("|" + preSep + "|"); // add sep } tokenAndSeparatorList.add("|" + matcher.group(2) + "|"); // add token matchEnd = matcher.end(); } // get trailing separator, if there is one: if( matchEnd != -1 ){ String trailingSep = stringForTokenising.substring( matchEnd ); if( ! trailingSep.isEmpty() ){ tokenAndSeparatorList.add( "|" + trailingSep + "|" ); } } System.out.println(String.format("# starts with token? %b - matchList %s", startsWithToken, tokenAndSeparatorList)); 

I don’t know Java too well, but if you can’t find a Split method that does that, I suggest you just make your own.

 string[] mySplit(string s,string delimiter) { string[] result = s.Split(delimiter); for(int i=0;i 

Its not too elegant, but it'll do.