it-swarm.com.de

Zeichen in Java zuschneiden

Wie kann ich Zeichen in Java beschneiden?
z.B. 

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

j sollte sein 

"joe\jill"

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

j sollte sein 

"\ joe\jill \"

usw

53
Quintin Par

Apache Commons hat eine tolle StringUtils-Klasse (org.Apache.commons.lang.StringUtils). In StringUtils gibt es eine strip(String, String)-Methode, die das tut, was Sie wollen.

Ich empfehle dringend, Apache Commons zu verwenden, besonders die Collections- und Lang-Bibliotheken.

83
Colin Gislason

Das macht was Sie wollen:

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

Der $ wird verwendet, um die Sequenz am Ende der Zeichenfolge zu entfernen. Der ^ wird verwendet, um am Anfang zu entfernen. 

Alternativ können Sie die Syntax verwenden:

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

Der | bedeutet "oder".

Wenn Sie andere Zeichen trimmen möchten, passen Sie einfach den Regex an:

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

In der Vergangenheit würde ich Colins 'Apache commons-lang antworten . Aber jetzt, da die Guava-Libraries von Google veröffentlicht werden, wird die CharMatcher -Klasse das tun, was Sie wollen:

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

CharMatcher verfügt über sehr einfache und leistungsfähige APIs sowie einige vordefinierte Konstanten, die die Manipulation sehr einfach machen. Zum Beispiel:

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

Sehr schönes Zeug.

18
Cowan

Hier ist eine weitere nicht-regexp, nicht super-awesome, nicht super-optimierte, jedoch sehr leicht verständliche, nicht-externe-lib-Lösung:

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

Verwendungszweck:

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

Handgefertigt für die erste 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 );
    }
}

Drucke

joe\jil

joe\jil

1
OscarRyz

Sie können removeStart und removeEnd von Apache Commons Lang StringUtils verwenden.

1
Valentin Rocher

So würde ich es machen.

Ich denke, es ist ungefähr so ​​effizient, wie es vernünftigerweise möglich ist. Es optimiert die Groß- und Kleinschreibung und vermeidet die Erstellung mehrerer Teilzeichenfolgen für jede entfernte Untersequenz.

Beachten Sie, dass der Eckfall der Übergabe einer leeren Zeichenfolge zum Zuschneiden behandelt wird (einige der anderen Antworten würden in eine Endlosschleife geraten).

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

Ich würde tatsächlich meine eigene kleine Funktion schreiben, die den Trick tut, indem sie den einfachen Zugriff auf alte Zeichen verwendet:

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

Dies verhält sich ähnlich wie String.trim (), nur dass es mit '\' anstelle von Leerzeichen funktioniert.

Hier ist eine Alternative, die funktioniert und tatsächlich trim () verwendet. ;) Obwohl es nicht sehr effizient ist, wird es wahrscheinlich alle leistungsorientierten Ansätze, die auf dem Regex basieren, übertreffen.

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

EDIT: Durch Antwort ergänzt, um nur das erste und letzte '\' zu ersetzen.

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

Ich glaube nicht, dass es eine eingebaute Funktion gibt, die basierend auf einer übergebenen Zeichenfolge getrimmt wird. Hier ist ein kleines Beispiel, wie das geht. Dies ist wahrscheinlich nicht die effizienteste Lösung, ist aber wahrscheinlich für die meisten Situationen schnell genug, um Ihre Anforderungen zu bewerten und anzupassen. Ich empfehle das Testen der Leistung und die Optimierung bei Bedarf für jeden Code-Snippet, der regelmäßig verwendet wird. Im Folgenden habe ich einige Timing-Informationen als Beispiel hinzugefügt. 

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

Bei dieser Antwort wird davon ausgegangen, dass die zu beschneidenden Zeichen eine Zeichenfolge sind. Wenn Sie beispielsweise "abc" übergeben, wird "abc" abgeschnitten, aber nicht "bbc" oder "cba" usw.

Einige Leistungszeiten für jedes der folgenden 10 Millionen Mal.

" mile ".trim(); läuft in 248 ms als Referenzimplementierung für Leistungsvergleiche enthalten.

trim( "smiles", "s" ); läuft in 547 ms - ungefähr zwei Mal so lang wie Javas String.trim()-Methode.

"smiles".replaceAll("s$|^s",""); läuft in 12.306 ms - etwa 48 Mal so lang wie Javas String.trim()-Methode.

Die Verwendung eines kompilierten Regex-Musters Pattern pattern = Pattern.compile("s$|^s");pattern.matcher("smiles").replaceAll(""); läuft in 7.804 ms - etwa 31-mal so lang wie die Javas String.trim()-Methode.

0
Alex B

es scheint, dass es keine gebrauchsfertige Java -API gibt, die dies ermöglicht, aber Sie können eine Methode schreiben, um dies für Sie zu tun. Dies Link könnte nützlich sein

0
Ahmed Kotb

Die Frage war 10 Jahre alt, aber die meisten Antworten waren etwas verwickelt oder funktionierten nicht so, wie sie gestellt wurden. Auch die am besten bewertete Antwort hier lieferte keine Beispiele. Hier ist eine einfache Klasse, die ich gemacht habe:

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

Verwendung :

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

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

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