Recortar caracteres en Java

¿Cómo puedo recortar caracteres en Java?
p.ej

String j = “\joe\jill\”.Trim(new char[] {“\”}); 

j debería ser

“joe \ jill”

 String j = “jack\joe\jill\”.Trim("jack"); 

j debería ser

“\ joe \ jill \”

etc

Apache Commons tiene una excelente clase de StringUtils . En StringUtils hay un método de strip(String, String) que hará lo que quieras.

Recomiendo utilizar Apache Commons de todos modos, especialmente las bibliotecas Collections y Lang.

Esto hace lo que quieres:

 public static void main (String[] args) { String a = "\\joe\\jill\\"; String b = a.replaceAll("\\\\$", "").replaceAll("^\\\\", ""); System.out.println(b); } 

El $ se usa para eliminar la secuencia al final de la cadena. El ^ se usa para eliminar al principio.

Como alternativa, puede usar la syntax:

 String b = a.replaceAll("\\\\$|^\\\\", ""); 

El | significa “o”.

En caso de que desee recortar otros caracteres, simplemente adapte la expresión regular:

 String b = a.replaceAll("y$|^x", ""); // will remove all the y from the end and x from the beggining 

CharMatcher – Google Guava

En el pasado, yo respondía a la segunda respuesta de Apache commons-lang de Colins . Pero ahora que se publican las guava-libraries de Google, la clase CharMatcher hará bastante bien lo que usted desea:

 String j = CharMatcher.is('\\').trimFrom("\\joe\\jill\\"); // j is now joe\jill 

CharMatcher tiene un conjunto de API muy simple y potente, así como algunas constantes predefinidas que hacen que la manipulación sea muy fácil. Por ejemplo:

 CharMatcher.is(':').countIn("a:b:c"); // returns 2 CharMatcher.isNot(':').countIn("a:b:c"); // returns 3 CharMatcher.inRange('a', 'b').countIn("a:b:c"); // returns 2 CharMatcher.DIGIT.retainFrom("a12b34"); // returns "1234" CharMatcher.ASCII.negate().removeFrom("a®¶b"); // returns "ab"; 

Muy buenas cosas

Aquí hay otra solución non-regexp, no-super-awesome, no-super-optimizada, pero muy fácil de entender, no-externa-lib:

 public static String trimStringByString(String text, String trimBy) { int beginIndex = 0; int endIndex = text.length(); while (text.substring(beginIndex, endIndex).startsWith(trimBy)) { beginIndex += trimBy.length(); } while (text.substring(beginIndex, endIndex).endsWith(trimBy)) { endIndex -= trimBy.length(); } return text.substring(beginIndex, endIndex); } 

Uso:

 String trimmedString = trimStringByString(stringToTrim, "/"); 

Podría usar removeStart y removeEnd de Apache Commons Lang StringUtils

Hecho a mano para la primera opción:

 public class Rep { public static void main( String [] args ) { System.out.println( trimChar( '\\' , "\\\\\\joe\\jill\\\\\\\\" ) ) ; System.out.println( trimChar( '\\' , "joe\\jill" ) ) ; } private static String trimChar( char toTrim, String inString ) { int from = 0; int to = inString.length(); for( int i = 0 ; i < inString.length() ; i++ ) { if( inString.charAt( i ) != toTrim) { from = i; break; } } for( int i = inString.length()-1 ; i >= 0 ; i-- ){ if( inString.charAt( i ) != toTrim ){ to = i; break; } } return inString.substring( from , to ); } } 

Huellas dactilares

joe\jil

joe\jil

parece que no hay una API apta para Java que lo haga, pero puedes escribir un método para hacer eso por ti. este enlace podría ser útil

EDITAR : Enmendado por respuesta para reemplazar solo el primer y último carácter ‘\’.

 System.err.println("\\joe\\jill\\".replaceAll("^\\\\|\\\\$", "")); 

De hecho, escribiría mi propia pequeña función que hace el truco usando el viejo acceso char simple:

 public static String trimBackslash( String str ) { int len, left, right; return str == null || ( len = str.length() ) == 0 || ( ( left = str.charAt( 0 ) == '\\' ? 1 : 0 ) | ( right = len > left && str.charAt( len - 1 ) == '\\' ? 1 : 0 ) ) == 0 ? str : str.substring( left, len - right ); } 

Esto se comporta de manera similar a String.trim (), solo que funciona con ‘\’ en lugar de espacio.

Aquí hay una alternativa que funciona y realmente usa trim (). 😉 A pesar de que no es muy eficiente, probablemente superará todos los enfoques basados ​​en expresiones regulares en cuanto al rendimiento.

 String j = “\joe\jill\”; j = j.replace( '\\', '\f' ).trim().replace( '\f', '\\' ); 

No creo que haya ninguna función incorporada para recortar en función de una cadena pasada. Aquí hay un pequeño ejemplo de cómo hacer esto. Esta no es probablemente la solución más eficiente, pero probablemente sea lo suficientemente rápida para la mayoría de las situaciones, evalúe y adapte a sus necesidades. Recomiendo probar el rendimiento y optimizarlo según sea necesario para cualquier fragmento de código que se use regularmente. A continuación, he incluido algo de información de tiempo como ejemplo.

 public String trim( String stringToTrim, String stringToRemove ) { String answer = stringToTrim; while( answer.startsWith( stringToRemove ) ) { answer = answer.substring( stringToRemove.length() ); } while( answer.endsWith( stringToRemove ) ) { answer = answer.substring( 0, answer.length() - stringToRemove.length() ); } return answer; } 

Esta respuesta supone que los caracteres a recortar son una cadena. Por ejemplo, al pasar en “abc” se recortará “abc” pero no “bbc” o “cba”, etc.

Algunos tiempos de rendimiento para ejecutar cada uno de los siguientes 10 millones de veces.

" mile ".trim(); se ejecuta en 248 ms incluido como una implementación de referencia para las comparaciones de rendimiento.

trim( "smiles", "s" ); se ejecuta en 547 ms, aproximadamente 2 veces más que el método String.trim() Java.

"smiles".replaceAll("s$|^s",""); se ejecuta en 12.306 ms, aproximadamente 48 veces más que el método String.trim() Java.

Y utilizando un Pattern pattern = Pattern.compile("s$|^s"); regulares comstackdo Pattern pattern = Pattern.compile("s$|^s"); pattern.matcher("smiles").replaceAll(""); se ejecuta en 7,804 ms, aproximadamente 31 veces más que el método String.trim() Java.

Así es como lo haría.

Creo que es tan eficiente como razonablemente puede ser. Optimiza el caso de un solo carácter y evita crear subcadenas múltiples para cada subsecuencia eliminada.

Tenga en cuenta que se maneja el caso de esquina de pasar una cadena vacía para recortar (algunas de las otras respuestas entrarían en un ciclo infinito).

 /** Trim all occurrences of the string rmvval from the left and right of src. Note that rmvval constitutes an entire string which must match using String.startsWith and String.endsWith. */ static public String trim(String src, String rmvval) { return trim(src,rmvval,rmvval,true); } /** Trim all occurrences of the string lftval from the left and rgtval from the right of src. Note that the values to remove constitute strings which must match using String.startsWith and String.endsWith. */ static public String trim(String src, String lftval, String rgtval, boolean igncas) { int str=0,end=src.length(); if(lftval.length()==1) { // optimize for common use - trimming a single character from left char chr=lftval.charAt(0); while(str1) { // handle repeated removal of a specific character sequence from left int vallen=lftval.length(),newstr; while((newstr=(str+vallen))<=end && src.regionMatches(igncas,str,lftval,0,vallen)) { str=newstr; } } if(rgtval.length()==1) { // optimize for common use - trimming a single character from right char chr=rgtval.charAt(0); while(str1) { // handle repeated removal of a specific character sequence from right int vallen=rgtval.length(),newend; while(str<=(newend=(end-vallen)) && src.regionMatches(igncas,newend,rgtval,0,vallen)) { end=newend; } } if(str!=0 || end!=src.length()) { if(str
 public static String trim(String value, char c) { if (c <= 32) return value.trim(); int len = value.length(); int st = 0; char[] val = value.toCharArray(); /* avoid getfield opcode */ while ((st < len) && (val[st] == c)) { st++; } while ((st < len) && (val[len - 1] == c)) { len--; } return ((st > 0) || (len < value.length())) ? value.substring(st, len) : value; }