это то, что вы хотите:

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

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

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

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

The | означает "или".

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

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

CharMatcher - Google Guava

в прошлом, я бы второй Colins ' Apache commons-lang ответ. Но теперь, когда Google гуава-библиотеки этот 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";

очень приятно материал.

вот еще одно нерегулярное выражение, не супер-удивительное, не супер-оптимизированное, однако очень простое для понимания решение без внешнего 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);
}

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

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

вы могли бы использовать removeStart и removeEnd от Apache Commons Lang StringUtils

ручная работа для первого варианта:

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

похоже, что нет готового к использованию Java api, который делает это, но вы можете написать метод, чтобы сделать это за вас. это ссылке может быть полезным

редактировать: исправлено ответом, чтобы заменить только первый и последний символ'\'.

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

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

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

это ведет себя подобно тому, что строка.trim () делает, только то, что он работает с '\' вместо пространства.

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

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

Я не думаю, что есть какая-либо встроенная функция для обрезки на основе переданной строки. Вот небольшой пример того, как это сделать. Это, вероятно, не самое эффективное решение, но оно, вероятно, достаточно быстро для большинства ситуаций, оценки и адаптации к вашим потребностям. Я рекомендую тестировать производительность и оптимизировать по мере необходимости для любого фрагмента кода, который будет использоваться регулярно. Ниже я включил некоторую информацию о времени в качестве примера.

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

этот ответ предполагает, что символы, которые будут обрезаны, являются строкой. Например, переход в " abc "будет обрезать" abc", но не" bbc "или" cba " и т. д.

некоторые времена производительности для запуска каждого из следующих 10 миллионов раз.

" mile ".trim(); работает в 248 МС включены в качестве эталонной реализации для сравнения производительности.

trim( "smiles", "s" ); работает в 547 МС-примерно в 2 раза дольше, чем java String.trim() метод.

"smiles".replaceAll("s$|^s",""); работает в 12,306 МС - примерно в 48 раз больше, чем java String.trim() метод.

и с помощью скомпилированного шаблона регулярных выражений Pattern pattern = Pattern.compile("s$|^s"); pattern.matcher("smiles").replaceAll(""); работает в 7,804 МС-примерно в 31 раз дольше, чем java String.trim() метод.

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

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

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

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

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