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

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

public class Main
{
    public static void main(String[] args) 
    {
        String s = "test string";
        //char lastChar = ???
    }   
}

Le code:

public class Test {
    public static void main(String args[]) {
        String string = args[0];
        System.out.println("last character: " +
                           string.substring(string.length() - 1)); 
    }
}

La sortie de java Test abcdef:

last character: f

Voici une méthode utilisant String.charAt():

String str = "India";
System.out.println("last char = " + str.charAt(str.length() - 1));

Le résultat obtenu est last char = a.

Les autres réponses contiennent beaucoup de texte et de code inutiles. Voici deux façons d'obtenir le dernier caractère d'une chaîne:

carboniser

char lastChar = myString.charAt(myString.length() - 1);

Chaîne

String lastChar = myString.substring(myString.length() - 1);

Les autres réponses sont très complètes et vous devriez certainement les utiliser si vous essayez de trouver le dernier caractère d'une chaîne. Mais si vous essayez simplement d'utiliser un conditionnel (par exemple, le dernier caractère «g»), vous pouvez également faire ce qui suit:

if (str.endsWith("g")) {

ou, chaînes

if (str.endsWith("bar")) {

Essaye ça:

if (s.charAt(0) == s.charAt(s.length() - 1))

La solution simple est:

public String frontBack(String str) {
  if (str == null || str.length() == 0) {
    return str;
  }
  char[] cs = str.toCharArray();
  char first = cs[0];
  cs[0] = cs[cs.length -1];
  cs[cs.length -1] = first;
  return new String(cs);
}

Utilisation d'un tableau de caractères (attention au vilain argument String vide ou String nul!)

Une autre solution utilise StringBuilder (qui est généralement utilisé pour faire la manupilation de String puisque String lui-même est immuable.

public String frontBack(String str) {
  if (str == null || str.length() == 0) {
    return str;
  }
  StringBuilder sb = new StringBuilder(str);  
  char first = sb.charAt(0);
  sb.setCharAt(0, sb.charAt(sb.length()-1));
  sb.setCharAt(sb.length()-1, first);
  return sb.toString();
}

Encore une autre approche (plus pour l'instruction que pour l'utilisation réelle) est celle-ci:

public String frontBack(String str) {
  if (str == null || str.length() < 2) {
    return str;
  }
  StringBuilder sb = new StringBuilder(str);
  String sub = sb.substring(1, sb.length() -1);
  return sb.reverse().replace(1, sb.length() -1, sub).toString();
}

Ici, la chaîne complète est inversée, puis la partie qui ne doit pas être inversée est remplacée par la sous-chaîne. ;)

public String lastChars(String a) {
if(a.length()>=1{
String str1 =a.substring(b.length()-1);
}
return str1;
}

public char LastChar(String a){
    return a.charAt(a.length() - 1);
}

String aString = "This will return the letter t";
System.out.println(aString.charAt(aString.length() - 1));

La sortie doit être:

t

Bon codage!

Voici une méthode que j'utilise pour obtenir le dernier xx d'une chaîne:

public static String takeLast(String value, int count) {
    if (value == null || value.trim().length() == 0) return "";
    if (count < 1) return "";

    if (value.length() > count) {
        return value.substring(value.length() - count);
    } else {
        return value;
    }
}

Ensuite, utilisez-le comme ceci:

String testStr = "this is a test string";
String last1 = takeLast(testStr, 1); //Output: g
String last4 = takeLast(testStr, 4); //Output: ring

 public char lastChar(String s) {
     if (s == "" || s == null)
        return ' ';
    char lc = s.charAt(s.length() - 1);
    return lc;
}