¿Cómo eliminar el último carácter de una cadena?

Quiero eliminar el último carácter de una cadena. He intentado hacer esto:

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

Obteniendo la longitud de la cadena - 1 y reemplazando la última letra con nada (eliminándola), pero cada vez que ejecuto el programa, elimina las letras del medio que son las mismas que la última letra.

Por ejemplo, la palabra es "admirador"; después de ejecutar el método, obtengo "admirar". Quiero que me devuelva la palabra admirar.

replacereemplazará todas las instancias de una carta. Todo lo que necesitas hacer es usar 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;
}

¿Por qué no solo un revestimiento?

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

Código 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);
    }
}

Manifestación

Como estamos en un tema, también se pueden usar expresiones regulares

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

El problema descrito y las soluciones propuestas a veces se relacionan con la eliminación de separadores. Si este es su caso, eche un vistazo a Apache Commons StringUtils, tiene un método llamado removeEnd que es muy elegante.

Ejemplo:

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

Resultaría en: "cadena 1 | cadena 2 | cadena 3"

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

No intente reinventar la rueda, mientras que otros ya han escrito bibliotecas para realizar la manipulación de cadenas: org.apache.commons.lang3.StringUtils.chop()

Utilizar este:

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

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

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

Por ejemplo, la palabra es "admirador"; después de ejecutar el método, obtengo "admirar". Quiero que me devuelva la palabra admirar.

En caso de que estés tratando de detener las palabras en inglés

La derivación es el proceso para reducir las palabras flexionadas (o algunas veces derivadas) a su forma de raíz, base o raíz, generalmente una forma de palabra escrita.

...

Un stemmer para inglés, por ejemplo, debe identificar la cadena "cats" (y posiblemente "catlike", "catty", etc.) según la raíz "cat" y "stemmer", "stemming", "stemmed" como basado en "tallo". Un algoritmo derivado reduce las palabras "pesca", "pescado", "pez" y "pescador" a la palabra raíz, "pez".

Diferencia entre los stemmers de Lucene: EnglishStemmer, PorterStemmer, LovinsStemmer describe algunas opciones de Java.

En Kotlin puedes usar el método dropLast () de la clase string. Caerá el número dado de la cadena, devolverá una nueva cadena

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

En lo que respecta a la legibilidad, considero que esto es lo más conciso

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

Los índices negativos se pueden usar en la utilidad StringUtils de Apache. Todos los números negativos se tratan desde el desplazamiento desde el final de la cadena.

elimina la última aparición de 'xxx':

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

elimina la última aparición de 'xxx' si es la última:

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

puedes reemplazar el 'xxx' en lo que quieras pero ten cuidado con los caracteres especiales

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

Mire a la clase 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 respuesta de una sola línea (solo una alternativa divertida , no intente esto en casa, y ya hay excelentes respuestas):

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

¿Por qué no usar la secuencia de escape ...!

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

La vida es mucho más fácil ahora. XD! ~ Una línea legible

La mayoría de las respuestas aquí se olvidaron de los pares sustitutos .

Por ejemplo, el carácter 𝕫 (punto de código U + 1D56B) no cabe en un solo char, por lo que para ser representado, debe formar un par sustituto de dos caracteres.

Si uno simplemente aplica la respuesta actualmente aceptada (usando str.substring(0, str.length() - 1), uno divide el par sustituto, lo que lleva a resultados inesperados.

También se debe incluir una verificación de si el último personaje es un par sustituto:

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

Salida: test-ab

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

Estoy usando esto en mi código, es fácil y simple. solo funciona mientras la Cadena es> 0. Lo tengo conectado a un botón y dentro de la siguiente instrucción if

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

}

si tienes un carácter especial como; en json solo use String.replace (";", "") de lo contrario debe reescribir todos los caracteres en cadena menos el último.

Cómo hacer el char en la recursión al final:

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

por ejemplo:

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

Aquí hay una respuesta que funciona con puntos de código fuera del plano multilingüe básico (Java 8+).

Usando transmisiones:

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

Más eficiente quizás:

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

Podemos usar subcadenas. Aquí está el ejemplo,

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

simplemente reemplace la condición de "si" de esta manera:

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

esto hará el truco por ti.

Supongamos que la longitud total de mi cadena = 24 Quiero cortar el último carácter después de la posición 14 para terminar, lo que significa que quiero que comience el 14 para estar allí. Entonces aplico la siguiente solución.

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

Tuve que escribir código para un problema similar. Una forma en que pude resolverlo fue mediante un método recursivo de codificación.

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 mayor parte del código que he visto sobre este tema no usa la recursión, así que espero poder ayudarlo a usted oa alguien que tenga el mismo problema.

Pan comido:

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

Esta es la única forma de eliminar el último carácter de la cadena:

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