Come rimuovere l'ultimo carattere da una stringa?

Voglio rimuovere l'ultimo carattere da una stringa. Ho provato a fare questo:

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

Ottenere la lunghezza della stringa - 1 e sostituire l'ultima lettera con nulla (eliminandola), ma ogni volta che eseguo il programma, elimina le lettere intermedie che sono le stesse dell'ultima lettera.

Ad esempio, la parola è "ammiratore"; dopo aver eseguito il metodo, ottengo "admie". Voglio che restituisca la parola ammirare.

replacesostituirà tutte le istanze di una lettera. Tutto quello che devi fare è usare 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;
}

Perché non solo una fodera?

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

Codice completo

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

dimostrazione

Dato che siamo su un argomento, si possono usare anche espressioni regolari

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

Il problema descritto e le soluzioni proposte a volte riguardano la rimozione dei separatori. Se questo è il tuo caso, dai un'occhiata a StringUtils di Apache Commons, ha un metodo chiamato removeEnd che è molto elegante.

Esempio:

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

Risultati: "stringa 1 | stringa 2 | stringa 3"

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

Non tentare di reinventare la ruota, mentre altri hanno già scritto librerie per eseguire la manipolazione delle stringhe: org.apache.commons.lang3.StringUtils.chop()

Usa questo:

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

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

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

Ad esempio, la parola è "ammiratore"; dopo aver eseguito il metodo, ottengo "admie". Voglio che restituisca la parola ammirare.

Nel caso in cui stai cercando di arginare le parole inglesi

Lo stemming è il processo per ridurre le parole flesse (o talvolta derivate) alla loro forma radice, base o radice, generalmente una forma scritta.

...

Uno stemmer per l'inglese, ad esempio, dovrebbe identificare la stringa "cats" (e possibilmente "catlike", "catty" ecc.) Come basata sulla radice "cat", e "stemmer", "stemming", "stemmed" come basato su "radice". Un algoritmo derivante riduce le parole "pesca", "pescato", "pesce" e "pescatore" alla parola radice "pesce".

Differenza tra gli stemmer Lucene: EnglishStemmer, PorterStemmer, LovinsStemmer delinea alcune opzioni Java.

In Kotlin puoi usare il metodo dropLast () della classe stringa. Rilascerà il numero dato dalla stringa, restituirà una nuova stringa

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

Per quanto riguarda la leggibilità, trovo che questo sia il più conciso

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

Gli indici negativi possono essere utilizzati nell'utilità StringUtils di Apache. Tutti i numeri negativi vengono trattati dall'offset dalla fine della stringa.

rimuove l'ultima occorrenza di 'xxx':

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

rimuove l'ultima occorrenza di 'xxx' se è ultima:

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

puoi sostituire "xxx" con ciò che desideri ma fai attenzione ai caratteri speciali

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

Guarda la classe StringBuilder:

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

Una risposta di una sola riga (solo un'alternativa divertente - non provarla a casa e ottime risposte già fornite):

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

Perché non usare la sequenza di escape ...!

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

La vita è molto più semplice ora. XD! ~ One-liner leggibile

La maggior parte delle risposte qui ha dimenticato le coppie surrogate .

Ad esempio, il carattere 𝕫 (punto di codice U + 1D56B) non si adatta a un singolo char , quindi per essere rappresentato, deve formare una coppia surrogata di due caratteri.

Se si applica semplicemente la risposta attualmente accettata (usando str.substring(0, str.length() - 1) , si giunge alla coppia surrogata, portando a risultati inaspettati.

Si dovrebbe anche includere un controllo se l'ultimo personaggio è una coppia surrogata:

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

Uscita: test-ab

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

Sto usando questo nel mio codice, è facile e semplice. funziona solo mentre la stringa è> 0. L'ho collegato ad un pulsante e all'interno del seguente se dichiarazione

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

}

se hai un carattere speciale come; in json basta usare String.replace (";", "") altrimenti devi riscrivere tutti i caratteri nella stringa meno l'ultimo.

Come rendere il carattere nella ricorsione alla fine:

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

per esempio:

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

Ecco una risposta che funziona con i punti di codice al di fuori del piano multilingue di base (Java 8+).

Utilizzando i flussi:

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

Più efficiente forse:

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

Possiamo usare la sottostringa. Ecco l'esempio,

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

basta sostituire la condizione di "if" in questo modo:

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

questo farà il trucco per te.

Supponiamo che la lunghezza totale della mia stringa = 24 voglia tagliare l'ultimo carattere dopo la posizione 14 alla fine, significa che voglio che l'inizio 14 sia lì. Quindi applico la seguente soluzione.

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

Ho dovuto scrivere il codice per un problema simile. Un modo in cui sono stato in grado di risolverlo ha usato un metodo ricorsivo di codifica.

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

La maggior parte del codice che ho visto su questo argomento non usa la ricorsione, quindi spero di poter aiutare te o qualcuno che ha lo stesso problema.

Vai tranquillo:

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

Questo è l'unico modo per rimuovere l'ultimo carattere nella stringa:

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