Обрезать символы в Java

Question

Как я могу обрезать символы в Java?
например

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

j должно быть

"джо \ Jill"

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

j должно быть

"\ джо \ Джил \"

* * Тысяча двадцать-одина и т.д. * * тысяча двадцать две

Answer 1

Apache Commons имеет отличный класс StringUtils (org.apache.commons.lang.StringUtils). В StringUtils есть метод strip(String, String), который будет делать то, что вы хотите.

Я настоятельно рекомендую использовать Apache Commons, особенно библиотеки Collections и Lang.

Answer 2

Это делает то, что вы хотите:

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

$ используется для удаления последовательности в конце строки. ^ используется для удаления в начале.

В качестве альтернативы вы можете использовать синтаксис:

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

| означает «или».

Если вы хотите обрезать другие символы, просто измените выражение:

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

Answer 3

CharMatcher - Google Guava

Раньше я отвечал Ответ Колинса на Apache commons-lang .Но теперь, когда Google guava-библиотеки выпущен, класс CharMatcher будет делать то, что вы хотите, очень приятно:

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

CharMatcher очень простой и мощный набор API, а также некоторые предопределенные константы, которые делают манипулирование очень простым.Например:

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

Очень хорошие вещи.

Answer 4

Вот еще одно не-регулярное выражение, не супер-удивительное, не супер-оптимизированное, но очень простое для понимания решение без внешней библиотеки:

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

Использование:

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

Answer 5

Ручная работа по первому варианту:

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

Печать

joe\jil

joe\jil

Answer 6

Вы можете использовать removeStart и removeEnd из Apache Commons Lang StringUtils

Answer 7

10-летний вопрос, но чувствовал, что большинство ответов были немного запутанными или не совсем так, как было задано. Также самый голосующий ответ здесь не предоставил никаких примеров. Вот простой класс, который я сделал:

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

Использование

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

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

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

Answer 8

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

Answer 9

Вот как бы я это сделал.

Я думаю, что это настолько эффективно, насколько это возможно. Он оптимизирует регистр одного символа и избегает создания нескольких подстрок для каждой удаленной подпоследовательности.

Обратите внимание, что обрабатывается угловой случай передачи пустой строки в обрезку (некоторые другие ответы будут идти в бесконечный цикл).

/** 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 10

Я бы на самом деле написал свою собственную маленькую функцию, которая добивается цели, используя обычный старый доступ к символам:

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

Это похоже на то, что делает String.trim (), только то, что оно работает с '\' вместо пробела.

Вот одна альтернатива, которая работает и на самом деле использует trim (). ;) Хотя это не очень эффективно, оно, вероятно, превзойдет все подходы, основанные на регулярных выражениях.

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