자바에서 문자 자르기

자바에서 문자 자르기

---

Java에서 문자를 어떻게 다듬을 수 있습니까?
예 :

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

j 는

"joe \ jill"

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

j 는

"\ joe \ jill \"

기타

---

Apache Commons 에는 훌륭한 StringUtils 클래스 (org.apache.commons.lang.StringUtils)가 있습니다. 에서 StringUtils이 strip(String, String)당신이 원하는 것을 할 것입니다 방법.

어쨌든 Apache Commons, 특히 Collections 및 Lang 라이브러리를 사용하는 것이 좋습니다.

---

이것은 당신이 원하는 것을합니다 :

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

은 $문자열의 끝에서 순서를 제거하는 데 사용됩니다. 는 ^beggining에서 제거하는 데 사용됩니다.

대안으로 다음 구문을 사용할 수 있습니다.

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

|수단 "또는".

다른 문자를 자르려면 정규식을 조정하십시오.

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아파치 코 몬즈 랭에서 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

---

그것을 만드는 자바 API를 사용할 준비가 된 것 같지 않지만 당신을 위해 그것을 할 수있는 메소드를 작성할 수 있습니다. 이 링크 가 유용 할 수 있습니다.

---

편집 : 첫 번째와 마지막 '\'문자 만 대체하도록 답변으로 수정되었습니다.

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

---

나는 실제로 일반 오래된 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 );
}

이것은 String.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"등은 제거되지 않습니다.

다음 1 천만 회를 각각 실행하기위한 일부 성능 시간.

" mile ".trim();성능 비교를위한 참조 구현으로 포함 된 248ms에서 실행됩니다 .

trim( "smiles", "s" ); runs in 547 ms - approximately 2 times as long as java's String.trim() method.

"smiles".replaceAll("s$|^s",""); runs in 12,306 ms - approximately 48 times as long as java's String.trim() method.

And using a compiled regex pattern Pattern pattern = Pattern.compile("s$|^s"); pattern.matcher("smiles").replaceAll(""); runs in 7,804 ms - approximately 31 times as long as java's String.trim() method.

---

Here's how I would do it.

I think it's about as efficient as it reasonably can be. It optimizes the single character case and avoids creating multiple substrings for each subsequence removed.

Note that the corner case of passing an empty string to trim is handled (some of the other answers would go into an infinite loop).

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

---

10 year old question but felt most of the answers were a bit convoluted or didn't quite work the way that was asked. Also the most upvoted answer here didn't provide any examples. Here's a simple class I made:

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

Usage:

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

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

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

ReferenceURL : https://stackoverflow.com/questions/2088037/trim-characters-in-java