Taglia caratteri in Java

Question

Come posso tagliare i caratteri in Java?
ad es.

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

j dovrebbe essere

"joe \ Jill"

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

j dovrebbe essere

"\ joe \ Jill \"

ecc

Answer 1

Apache Commons ha una grande StringUtils class. In StringUtils c'è un metodo strip(String, String) che farà ciò che vuoi.

Consiglio vivamente di utilizzare comunque Apache Commons, in particolare le raccolte e le librerie Lang.

Answer 2

EDIT: Modificato da risposta a sostituire solo il primo e l'ultimo '\' carattere.

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

Answer 3

Non credo che ci sia alcuna costruito in funzione di TRIM basato su un passato nella stringa. Ecco un piccolo esempio di come farlo. Questa non è probabilmente la soluzione più efficiente, ma è probabilmente abbastanza veloce per la maggior parte delle situazioni, valutare e adattarsi alle proprie esigenze. Raccomando di testare le prestazioni e di ottimizzare come necessario per qualsiasi frammento di codice che verrà usato regolarmente. Di seguito, ho incluso alcune informazioni sul tempo come esempio.

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

Questa risposta presuppone che i caratteri da ritagliare siano una stringa. Ad esempio, il passaggio in "abc" eliminerà "abc" ma non "bbc" o "cba", ecc.

Alcuni tempi di esecuzione per eseguire ciascuno dei seguenti 10 milioni di volte.

" mile ".trim(); eseguito in 248 ms incluso come implementazione di riferimento per il confronto delle prestazioni.

trim("smiles", "s"); eseguito in 547 ms - circa 2 volte più lungo del metodo java String.trim().

"smiles".replaceAll("s$|^s",""); eseguito in 12,306 ms - circa 48 volte più lungo del metodo java String.trim().

E l'utilizzo di un modello di espressione regolare compilata Pattern pattern = Pattern.compile("s$|^s"); pattern.matcher("smiles").replaceAll(""); viene eseguito in 7.804 ms - circa 31 volte fino a quando il metodo di java String.trim().

Answer 4

sembra che non ci sia java api pronta per l'uso, ma è possibile scrivere un metodo per farlo. questo link potrebbe essere utile

Answer 5

Questo non fa ciò che si vuole:

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

Il $ viene utilizzato per rimuovere la sequenza alla fine della stringa. Il ^ viene utilizzato per rimuovere all'inizio.

In alternativa, è possibile utilizzare la sintassi:

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

Le | significa "o".

Nel caso in cui si vuole tagliare altri caratteri, basta adattare la regex:

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

Answer 6

Si potrebbe utilizzare removeStart e removeEnd da Apache Commons Lang StringUtils

Answer 7

Fatto a mano per la prima opzione:

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

Stampe

joe\jil

joe\jil

Answer 8

vorrei davvero scrivere la mia piccola funzione che fa il trucco utilizzando pianura vecchio accesso char:

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

Questo comporta simile a quello che fa String.trim(), solo che funziona con '\' al posto dello spazio.

Ecco una alternativa che funziona e utilizza effettivamente trim(). ;) Anche se non è molto efficiente, probabilmente vincerà tutti gli approcci basati su regexp in termini di prestazioni.

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

Answer 9

CharMatcher - Google Guava

In passato, avevo secondo Colins’ Apache commons-lang answer. Ma ora che Google guava-libraries viene rilasciato, la classe CharMatcher farà ciò che si vuole molto bene:

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

CharMatcher ha un insieme molto semplice e potente di API così come alcune costanti predefinite che rendono la manipolazione molto facile. Ad esempio:

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

Molto bello.

Answer 10

Ecco come lo farei.

Penso che sia più efficiente che possa ragionevolmente essere. Ottimizza il caso a carattere singolo ed evita di creare sottostringhe multiple per ogni sottosequenza rimossa.

Si noti che viene gestito il caso d'angolo di passare una stringa vuota da tagliare (alcune delle altre risposte andranno in un ciclo infinito).

/** Trim all occurrences of the string <code>rmvval</code> from the left and right of <code>src</code>. Note that <code>rmvval</code> constitutes an entire string which must match using <code>String.startsWith</code> and <code>String.endsWith</code>. */ 
static public String trim(String src, String rmvval) { 
    return trim(src,rmvval,rmvval,true); 
    } 

/** Trim all occurrences of the string <code>lftval</code> from the left and <code>rgtval</code> from the right of <code>src</code>. Note that the values to remove constitute strings which must match using <code>String.startsWith</code> and <code>String.endsWith</code>. */ 
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(str<end && src.charAt(str)==chr) { str++; } 
     } 
    else if(lftval.length()>1) {            // 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(str<end && src.charAt(end-1)==chr) { end--; } 
     } 
    else if(rgtval.length()>1) {            // 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<end) { src=src.substring(str,end); }       // str is inclusive, end is exclusive 
     else  { src="";      } 
     } 

    return src; 
    } 

Answer 11

Ecco un altro non-regexp, non super impressionante, non super-ottimizzato, ma molto facile da capire soluzione non esterno-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); 
} 

Usage:

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

Answer 12

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