¿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 progtwig, 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 “admie”. Quiero que devuelva la palabra admirar.

replace reemplazará 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 trazador de líneas?

 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 podemos 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 tu 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|", "|"); 

Daría como resultado: “cuerda 1 | cuerda 2 | cuerda 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 esta:

  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 “admie”. Quiero que devuelva la palabra admirar.

En caso de que intentes detener las palabras en inglés

Stemming es el proceso para reducir las palabras inflexas (o algunas veces derivadas) a su raíz, base o forma de raíz, generalmente una forma de palabra escrita.

Una lectora de inglés, por ejemplo, debe identificar la cadena “gatos” (y posiblemente “catlike”, “catty”, etc.) como basada en la raíz “cat”, y “stemmer”, “stemming”, “stemmed” como basado en “raíz”. Un algoritmo de reducción reduce las palabras “pescar”, “pescar”, “pez” y “pescador” a la palabra raíz, “pez”.

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

En lo que respecta a la legibilidad, creo que es la más concisa

 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 ocurrencia de ‘xxx’:

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

elimina la última ocurrencia de ‘xxx’ si es la última:

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

puedes reemplazar el ‘xxx’ por lo que quieras, pero ten cuidado con los caracteres especiales

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

Mire 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 única (solo una alternativa divertida : no intentes esto en casa, y ya se han dado 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! ~ Un one-liner legible

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: prueba-ab

si tiene un carácter especial como; en json simplemente use String.replace (“;”, “”); de lo contrario, debe volver a escribir todo el carácter en cadena menos el último.

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

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

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

Tuve que escribir el código para un problema similar. Una forma en que pude resolverlo usó un método recursivo de encoding.

 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 recursividad, así que espero poder ayudarte o a alguien que tenga el mismo problema.

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 tal vez:

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

Podemos usar subcadena. 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); } } 
  // creating StringBuilder StringBuilder builder = new StringBuilder(requestString); // removing last character from String builder.deleteCharAt(requestString.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]); }