web-dev-qa-db-fra.com

Découper des caractères en Java

Comment puis-je couper les caractères en Java?
par exemple. 

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

j devrait être 

"joe\jill"

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

j devrait être 

"\ joe\jill \"

etc

javastringtrim
53
Quintin Par

Apache Commons a une excellente classe StringUtils (org.Apache.commons.lang.StringUtils). Dans StringUtils, il existe une méthode strip(String, String) qui fera ce que vous voulez.

Quoi qu'il en soit, je recommande fortement d'utiliser Apache Commons, en particulier les bibliothèques Collections et Lang.

83
Colin Gislason

Cela fait ce que tu veux:

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

Le $ est utilisé pour supprimer la séquence en fin de chaîne. Le ^ est utilisé pour supprimer au début. 

Comme alternative, vous pouvez utiliser la syntaxe:

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

Le | signifie "ou".

Si vous souhaitez supprimer d'autres caractères, adaptez simplement l'expression rationnelle:

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

CharMatcher - Google Guava

Dans le passé, je secondais la réponse Apache commons-lang de Colins . Mais maintenant que les guava-libraries de Google sont disponibles, la classe CharMatcher fera tout ce que vous voulez:

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

CharMatcher a un ensemble très simple et puissant d’API ainsi que des constantes prédéfinies qui facilitent la manipulation. Par exemple:

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

Très belles choses.

18
Cowan

Voici une autre solution non-regexp, non-super-impressionnante, non-super-optimisée, mais très facile à comprendre, mais non-lisible:

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, "/");
7
jake_hetfield

Fabriqué à la main pour la première option: 

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

Impressions

joe\jil

joe\jil

1
OscarRyz

Vous pouvez utiliser removeStart et removeEnd d'Apache Commons Lang StringUtils

1
Valentin Rocher

Voici comment je le ferais.

Je pense que c'est à peu près aussi efficace que possible. Il optimise la casse d'un caractère et évite de créer plusieurs sous-chaînes pour chaque sous-séquence supprimée.

Notez que le cas du passage d'une chaîne vide à trim est traité (certaines des autres réponses seraient placées dans une boucle infinie).

/** 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;
    }
0
Lawrence Dol
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;
}
0
ilw

En fait, j'écrirais ma propre petite fonction qui fait l'affaire en utilisant un simple et ancien accès aux caractères:

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

Cela se comporte de la même manière que String.trim (), sauf que cela fonctionne avec '\' au lieu de l'espace.

Voici une alternative qui fonctionne et utilise réellement trim (). ;) Bien qu’il ne soit pas très efficace, il battra probablement toutes les approches basées sur l’expression rationnelle sur le plan des performances.

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

EDIT: Modifié par réponse pour ne remplacer que le premier et le dernier caractère '\'.

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

Je ne pense pas qu'il y ait de fonction intégrée à couper basée sur une chaîne passée en chaîne. Voici un petit exemple de la procédure à suivre. Ce n'est probablement pas la solution la plus efficace, mais il est probablement assez rapide pour la plupart des situations, évaluez et adaptez-vous à vos besoins. Je vous recommande de tester les performances et d'optimiser au besoin tous les extraits de code qui seront utilisés régulièrement. Ci-dessous, j'ai inclus des informations temporelles à titre d'exemple. 

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

Cette réponse suppose que les caractères à couper sont une chaîne. Par exemple, passer "abc" supprimera "abc" mais pas "bbc" ou "cba", etc.

Quelques performances pour chacune des 10 millions de fois suivantes.

" mile ".trim(); s'exécute en 248 ms inclus comme implémentation de référence pour les comparaisons de performances.

trim( "smiles", "s" ); s'exécute en 547 ms, environ 2 fois plus longtemps que la méthode String.trim() de Java.

"smiles".replaceAll("s$|^s",""); s'exécute en 12,306 ms, soit environ 48 fois plus longtemps que la méthode String.trim() de Java.

Et en utilisant un motif regex compilé, Pattern pattern = Pattern.compile("s$|^s");pattern.matcher("smiles").replaceAll(""); s'exécute en 7 804 ms, soit environ 31 fois plus longtemps que la méthode String.trim() de Java.

0
Alex B

il semble qu’il n’y ait pas d’API Java prête à l’emploi qui permette cela, mais vous pouvez écrire une méthode pour le faire pour vous . this link pourrait être utile

0
Ahmed Kotb

Une question de 10 ans, mais elle a estimé que la plupart des réponses étaient un peu compliquées ou ne fonctionnaient pas tout à fait comme elles ont été posées. Aussi, la réponse la plus votée ici ne fournit aucun exemple. Voici un cours simple que j'ai fait:

https://Gist.github.com/Maxdw/d71afd11db2df4f1297ad3722d6392ec

Utilisation :

Trim.left("\joe\jill\", "\") == "joe\jill\"

Trim.left("jack\joe\jill\", "jack") == "\joe\jill\"

Trim.left("\\\\joe\\jill\\\\", "\") == "joe\\jill\\\\"
0
Max