Comment supprimer le dernier caractère d'une chaîne?

Je souhaite supprimer le dernier caractère d'une chaîne. J'ai essayé de faire ça:

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

Obtenir la longueur de la chaîne - 1 et remplacer la dernière lettre par rien (la supprimer), mais chaque fois que j'exécute le programme, il supprime les lettres du milieu qui sont les mêmes que la dernière lettre.

Par exemple, le mot est "admirateur"; après avoir exécuté la méthode, je reçois "admie". Je veux qu'il renvoie le mot admirer.

replaceremplacera toutes les instances d'une lettre. Il vous suffit d'utiliser 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;
}

Pourquoi pas un seul paquebot?

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

Code complet

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

Démo

Puisque nous sommes sur un sujet, on peut aussi utiliser des expressions régulières

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

Le problème décrit et les solutions proposées concernent parfois la suppression des séparateurs. Si c'est votre cas, jetez un œil à Apache Commons StringUtils, il a une méthode appelée removeEnd qui est très élégante.

Exemple:

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

Résultat: "chaîne 1 | chaîne 2 | chaîne 3"

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

N'essayez pas de réinventer la roue, alors que d'autres ont déjà écrit des bibliothèques pour effectuer des manipulations de chaînes: org.apache.commons.lang3.StringUtils.chop()

Utilisez ceci:

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

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

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

Par exemple, le mot est "admirateur"; après avoir exécuté la méthode, je reçois "admie". Je veux qu'il renvoie le mot admirer.

Dans le cas où vous essayez d' endiguer les mots anglais

La racine est le processus de réduction des mots fléchis (ou parfois dérivés) à leur forme racine, base ou racine - généralement une forme de mot écrite.

...

Un stemmer pour l'anglais, par exemple, devrait identifier la chaîne "cats" (et éventuellement "catlike", "catty" etc.) comme étant basée sur la racine "cat", et "stemmer", "stemming", "stemmed" comme basé sur "tige". Un algorithme de dérivation réduit les mots «pêche», «pêché», «poisson» et «pêcheur» au mot racine «poisson».

Différence entre les stemmers Lucene: EnglishStemmer, PorterStemmer, LovinsStemmer décrit certaines options Java.

Dans Kotlin, vous pouvez utiliser la méthode dropLast () de la classe de chaîne. Il supprimera le nombre donné de la chaîne, retournera une nouvelle chaîne

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

En ce qui concerne la lisibilité, je trouve que c'est le plus concis

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

Les index négatifs peuvent être utilisés dans l'utilitaire StringUtils d'Apache. Tous les nombres négatifs sont traités à partir du décalage à partir de la fin de la chaîne.

supprime la dernière occurrence du 'xxx':

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

supprime la dernière occurrence de 'xxx' si elle est la dernière:

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

vous pouvez remplacer le «xxx» sur ce que vous voulez mais faites attention aux caractères spéciaux

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

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

Une réponse à une ligne (juste une alternative amusante - n'essayez pas cela à la maison, et d'excellentes réponses déjà données):

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

Pourquoi ne pas utiliser la séquence d'échappement ...!

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

La vie est beaucoup plus facile maintenant. XD! ~ Une doublure lisible

La plupart des réponses ici ont oublié les paires de substitution .

Par exemple, le caractère 𝕫 (point de code U + 1D56B) ne rentre pas dans un seul char , donc pour être représenté, il doit former une paire de substitution de deux caractères.

Si l'on applique simplement la réponse actuellement acceptée (en utilisant str.substring(0, str.length() - 1) , on épissure la paire de substitution, ce qui conduit à des résultats inattendus.

Il convient également de vérifier si le dernier caractère est une paire de substitution:

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

Sortie: test-ab

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

J'utilise ceci dans mon code, c'est facile et simple. cela ne fonctionne que lorsque la chaîne est> 0. Je l'ai connecté à un bouton et à l'intérieur de l' instruction if suivante

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 vous avez un caractère spécial comme; dans json, utilisez simplement String.replace (";", "") sinon vous devez réécrire tous les caractères de la chaîne moins le dernier.

Comment faire le caractère dans la récursivité à la fin:

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

par exemple:

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

Voici une réponse qui fonctionne avec des points de code en dehors du plan multilingue de base (Java 8+).

Utilisation de flux:

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

Plus efficace peut-être:

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

Nous pouvons utiliser une sous-chaîne. Voici l'exemple,

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

remplacez simplement la condition "si" comme ceci:

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

cela fera l'affaire pour vous.

Supposons que la longueur totale de ma chaîne = 24 Je veux couper le dernier caractère après la position 14 pour terminer, je veux dire que le début de 14 doit être là. J'applique donc la solution suivante.

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

J'ai dû écrire du code pour un problème similaire. Une façon que j'ai pu le résoudre a utilisé une méthode récursive de codage.

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 plupart du code que j'ai vu sur ce sujet n'utilise pas la récursivité, donc j'espère pouvoir vous aider, vous ou quelqu'un qui a le même problème.

Peasy facile:

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

C'est la seule façon de supprimer le dernier caractère de la chaîne:

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