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

pourquoi pas une seule doublure?

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 se rapportent parfois à l'enlèvement des séparateurs. Si C'est votre cas, alors regardez 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|", "|");

se traduirait par: "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îne: 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 revienne le mot admirer.

Dans le cas où vous êtes en essayant de souches des mots anglais

est le procédé qui permet de réduire les mots infléchis (ou parfois dérivés) à leur forme de base, de base ou de racine-généralement sous forme de mots écrits.

...

Un analyseur morphologique pour l'anglais, par exemple, devrait identifier la chaîne "chats" (et éventuellement "à", "méchant", etc.), basé sur la racine "chat", et "stemmer", "radical", "étaient" fondé sur des "souches". Un algorithme de bourrage réduit les mots "pêche", "pêché", "poisson", et "pêcheur" au mot racine, "poisson".

Difference between Lucene stemmers: EnglishStemmer, PorterStemmer, LovinsStemmer décrit quelques options Java.

en ce qui concerne la lisibilité, je trouve que c'est la plus concise

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 de 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]*)$", ""));

supprime la dernière occurrence du" 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 attention sur les caractères spéciaux

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

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

Un one-liner réponse (juste un drôle alternative - n'essayez pas ceci à la maison, et de grandes réponses déjà donné):

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

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

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

la Vie est beaucoup plus facile maintenant . XD ! ~ Lisible one-liner

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

si vous avez des caractères spéciaux comme ; dans json utilisez simplement String.remplacer (";","") sinon vous devez réécrire tous les caractères dans string moins le dernier.

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

Im utiliser ce dans mon code, c'est facile et simple. il ne fonctionne que lorsque la Chaîne est > 0. Je l'ai connecté à un bouton et à l'intérieur de la suivante si déclaration

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

j'ai dû coder wright pour un problème similaire. Une façon que j'ai pu résoudre il 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écursion donc j'espère pouvoir vous aider ou quelqu'un qui a le même problème.

Comment faire de l'omble chevalier 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 codépoints en dehors du Plan multilingue de base (Java 8+).

utilisant les flux:

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

peut-être plus efficace:

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

on peut utiliser du substrat. 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);    
    }
}

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

C'est le seul moyen 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]);
}