Wie entferne ich das letzte Zeichen aus einer Zeichenfolge?

Ich möchte das letzte Zeichen aus einer Zeichenfolge entfernen. Ich habe versucht, dies zu tun:

public String method(String str) {
    if (str.charAt(str.length()-1)=='x'){
        str = str.replace(str.substring(str.length()-1), "");
        return str;
    } else{
        return str;
    }
}

Ermitteln der Länge der Zeichenfolge - 1 und Ersetzen des letzten Buchstabens durch nichts (Löschen). Bei jedem Ausführen des Programms werden jedoch mittlere Buchstaben gelöscht, die mit dem letzten Buchstaben identisch sind.

Zum Beispiel ist das Wort "Bewunderer"; Nachdem ich die Methode ausgeführt habe, erhalte ich "admie". Ich möchte, dass es das Wort bewundern zurückgibt.

replaceersetzt alle Instanzen eines Briefes. Alles was Sie tun müssen, ist zu verwenden substring():

public String method(String str) {
    if (str != null && str.length() > 0 && str.charAt(str.length() - 1) == 'x') {
        str = str.substring(0, str.length() - 1);
    }
    return str;
}

Warum nicht nur ein Liner?

private static String removeLastChar(String str) {
    return str.substring(0, str.length() - 1);
}

Vollständiger Code

import java.util.*;
import java.lang.*;

public class Main {
    public static void main (String[] args) throws java.lang.Exception {
        String s1 = "Remove Last CharacterY";
        String s2 = "Remove Last Character2";
        System.out.println("After removing s1==" + removeLastChar(s1) + "==");
        System.out.println("After removing s2==" + removeLastChar(s2) + "==");

    }

    private static String removeLastChar(String str) {
        return str.substring(0, str.length() - 1);
    }
}

Demo

Da wir uns mit einem Thema befassen, kann man auch reguläre Ausdrücke verwenden

"aaabcd".replaceFirst(".$",""); //=> aaabc  

Das beschriebene Problem und die vorgeschlagenen Lösungen beziehen sich manchmal auf das Entfernen von Separatoren. Wenn dies Ihr Fall ist, schauen Sie sich Apache Commons StringUtils an. Es gibt eine Methode namens removeEnd die sehr elegant ist.

Beispiel:

StringUtils.removeEnd("string 1|string 2|string 3|", "|");

Würde ergeben: "string 1 | string 2 | string 3"

public String removeLastChar(String s) {
    if (s == null || s.length() == 0) {
        return s;
    }
    return s.substring(0, s.length()-1);
}

Versuchen Sie nicht, das Rad neu zu erfinden, während andere bereits Bibliotheken geschrieben haben, um Zeichenfolgenmanipulationen durchzuführen: org.apache.commons.lang3.StringUtils.chop()

Benutze das:

 if(string.endsWith("x")) {

    string= string.substring(0, string.length() - 1);
 }

if (str.endsWith("x")) {
  return str.substring(0, str.length() - 1);
}
return str;

Zum Beispiel ist das Wort "Bewunderer"; Nachdem ich die Methode ausgeführt habe, erhalte ich "admie". Ich möchte, dass es das Wort bewundern zurückgibt.

Für den Fall , Sie versuchen zu Stammzellen englischen Wörtern

Stemming ist der Prozess zum Reduzieren von gebogenen (oder manchmal abgeleiteten) Wörtern auf ihre Stamm-, Basis- oder Wurzelform - im Allgemeinen eine geschriebene Wortform.

...

Ein Stemmer für Englisch sollte beispielsweise die Zeichenfolge "Katzen" (und möglicherweise "katzenartig", "keck" usw.) als basierend auf der Wurzel "Katze" und "Stemmer", "Stemming", "Stiel" als identifizieren basierend auf "Stiel". Ein Stemming-Algorithmus reduziert die Wörter "Fischen", "Fischen", "Fisch" und "Fischer" auf das Wurzelwort "Fisch".

Unterschied zwischen Lucene-Stemmern: EnglishStemmer, PorterStemmer, LovinsStemmer beschreiben einige Java-Optionen.

In Kotlin können Sie die dropLast () -Methode der Zeichenfolgenklasse verwenden. Die angegebene Nummer wird aus der Zeichenfolge entfernt und eine neue Zeichenfolge zurückgegeben

var string1 = "Some Text"
string1 = string1.dropLast(1)

Was die Lesbarkeit betrifft, finde ich dies am prägnantesten

StringUtils.substring("string", 0, -1);

Die negativen Indizes können im StringUtils-Dienstprogramm von Apache verwendet werden. Alle negativen Zahlen werden ab dem Ende der Zeichenfolge vom Versatz behandelt.

Entfernt das letzte Vorkommen von 'xxx':

    System.out.println("aaa xxx aaa xxx ".replaceAll("xxx([^xxx]*)$", "$1"));

Entfernt das letzte Vorkommen von 'xxx', wenn es das letzte ist:

    System.out.println("aaa xxx aaa  ".replaceAll("xxx\\s*$", ""));

Sie können das 'xxx' ersetzen, wenn Sie möchten, aber achten Sie auf spezielle Zeichen

 // creating StringBuilder
 StringBuilder builder = new StringBuilder(requestString);
 // removing last character from String
 builder.deleteCharAt(requestString.length() - 1);

public String removeLastChar(String s) {
    if (!Util.isEmpty(s)) {
        s = s.substring(0, s.length()-1);
    }
    return s;
}

Schauen Sie sich die StringBuilder-Klasse an:

    StringBuilder sb=new StringBuilder("toto,");
    System.out.println(sb.deleteCharAt(sb.length()-1));//display "toto"

// Remove n last characters  
// System.out.println(removeLast("Hello!!!333",3));

public String removeLast(String mes, int n) {
    return mes != null && !mes.isEmpty() && mes.length()>n
         ? mes.substring(0, mes.length()-n): mes;
}

// Leave substring before character/string  
// System.out.println(leaveBeforeChar("Hello!!!123", "1"));

public String leaveBeforeChar(String mes, String last) {
    return mes != null && !mes.isEmpty() && mes.lastIndexOf(last)!=-1
         ? mes.substring(0, mes.lastIndexOf(last)): mes;
}

Eine einzeilige Antwort (nur eine lustige Alternative - probieren Sie dies nicht zu Hause aus und es gibt bereits großartige Antworten):

public String removeLastChar(String s){return (s != null && s.length() != 0) ? s.substring(0, s.length() - 1): s;}

Warum nicht die Escape-Sequenz verwenden ...!

System.out.println(str + '\b');

Das Leben ist jetzt viel einfacher. XD! ~ Ein lesbarer Einzeiler

Die meisten Antworten hier haben Ersatzpaare vergessen .

Zum Beispiel passt das Zeichen 𝕫 (Codepunkt U + 1D56B) nicht in ein einzelnes char Zeichen. Um dargestellt zu werden, muss es ein Ersatzpaar aus zwei Zeichen bilden.

Wenn man einfach die aktuell akzeptierte Antwort anwendet (mit str.substring(0, str.length() - 1) spleißt man das Ersatzpaar, was zu unerwarteten Ergebnissen führt.

Man sollte auch prüfen, ob das letzte Zeichen ein Ersatzpaar ist:

public static String removeLastChar(String str) {
    Objects.requireNonNull(str, "The string should not be null");
    if (str.isEmpty()) {
        return str;
    }

    char lastChar = str.charAt(str.length() - 1);
    int cut = Character.isSurrogate(lastChar) ? 2 : 1;
    return str.substring(0, str.length() - cut);
}

Java 8

import java.util.Optional;

public class Test
{
  public static void main(String[] args) throws InterruptedException
  {
    System.out.println(removeLastChar("test-abc"));
  }

  public static String removeLastChar(String s) {
    return Optional.ofNullable(s)
      .filter(str -> str.length() != 0)
      .map(str -> str.substring(0, str.length() - 1))
      .orElse(s);
    }
}

Ausgabe: test-ab

 "String name" = "String name".substring(0, ("String name".length() - 1));

Ich verwende dies in meinem Code, es ist einfach und unkompliziert. Es funktioniert nur, wenn der String> 0 ist. Ich habe ihn mit einer Schaltfläche verbunden und in der folgenden if- Anweisung

if ("String name".length() > 0) {
    "String name" = "String name".substring(0, ("String name".length() - 1));
}

public String removeLastCharacter(String str){
       String result = null;
        if ((str != null) && (str.length() > 0)) {
          return str.substring(0, str.length() - 1);
        }
        else{
            return "";
        }

}

wenn Sie einen besonderen Charakter haben wie; Verwenden Sie in json einfach String.replace (";", ""), andernfalls müssen Sie alle Zeichen in der Zeichenfolge abzüglich der letzten neu schreiben.

So machen Sie das Zeichen in der Rekursion am Ende:

public static String  removeChar(String word, char charToRemove)
    {
        String char_toremove=Character.toString(charToRemove);
        for(int i = 0; i < word.length(); i++)
        {
            if(word.charAt(i) == charToRemove)
            {
                String newWord = word.substring(0, i) + word.substring(i + 1);
                return removeChar(newWord,charToRemove);
            }
        }
        System.out.println(word);
        return word;
    }

zum Beispiel:

removeChar ("hello world, let's go!",'l') → "heo word, et's go!llll"
removeChar("you should not go",'o') → "yu shuld nt goooo"

Hier ist eine Antwort, die mit Codepunkten außerhalb der mehrsprachigen Grundebene (Java 8+) funktioniert.

Verwenden von Streams:

public String method(String str) {
    return str.codePoints()
            .limit(str.codePoints().count() - 1)
            .mapToObj(i->new String(Character.toChars(i)))
            .collect(Collectors.joining());
}

Effizienter vielleicht:

public String method(String str) {
    return str.isEmpty()? "": str.substring(0, str.length() - Character.charCount(str.codePointBefore(str.length())));
}

Wir können Teilzeichenfolgen verwenden. Hier ist das Beispiel:

public class RemoveStringChar 
{
    public static void main(String[] args) 
    {   
        String strGiven = "Java";
        System.out.println("Before removing string character - " + strGiven);
        System.out.println("After removing string character - " + removeCharacter(strGiven, 3));
    }

    public static String removeCharacter(String strRemove, int position)
    {   
        return strRemove.substring(0, position) + strRemove.substring(position + 1);    
    }
}

Ersetzen Sie einfach die Bedingung "wenn" wie folgt:

if(a.substring(a.length()-1).equals("x"))'

Dies wird den Trick für Sie tun.

Angenommen, die Gesamtlänge meiner Zeichenfolge = 24 Ich möchte das letzte Zeichen nach Position 14 bis zum Ende ausschneiden, dh ich möchte, dass Start 14 dort ist. Also wende ich folgende Lösung an.

String date = "2019-07-31T22:00:00.000Z";
String result = date.substring(0, date.length() - 14);

Ich musste Code für ein ähnliches Problem schreiben. Eine Möglichkeit, die ich lösen konnte, war eine rekursive Codierungsmethode.

static String removeChar(String word, char charToRemove)
{
    for(int i = 0; i < word.lenght(); i++)
    {
        if(word.charAt(i) == charToRemove)
        {
            String newWord = word.substring(0, i) + word.substring(i + 1);
            return removeChar(newWord, charToRemove);
        }
    }

    return word;
}

Der größte Teil des Codes, den ich zu diesem Thema gesehen habe, verwendet keine Rekursion. Hoffentlich kann ich Ihnen oder jemandem helfen, der das gleiche Problem hat.

Kinderleicht:

StringBuilder sb= new StringBuilder();
for(Entry<String,String> entry : map.entrySet()) {
        sb.append(entry.getKey() + "_" + entry.getValue() + "|");
}
String requiredString = sb.substring(0, sb.length() - 1);

Dies ist die einzige Möglichkeit, das letzte Zeichen in der Zeichenfolge zu entfernen:

Scanner in = new Scanner(System.in);
String s = in.nextLine();
char array[] = s.toCharArray();
int l = array.length;
for (int i = 0; i < l-1; i++) {
    System.out.print(array[i]);
}