Inverser une chaîne de caractères en Java

j'ai "Hello World" conservés dans une variable de Chaîne nommée hi .

je dois l'imprimer, mais inversé.

Comment faire? Je comprends qu'il y a une sorte de fonction déjà intégrée dans Java qui fait cela.

Related: Inverser chaque mot individuel de" Hello World "chaîne avec Java

360
demandé sur Massimiliano Kraus 2011-09-27 16:44:42

30 réponses

vous pouvez utiliser ceci:

new StringBuilder("hi").reverse().toString()

ou, pour les versions antérieures à JDK 1.5, utilisez java.util.StringBuffer au lieu de StringBuilder - ils ont la même API. Remercie les commentateurs de souligner que StringBuilder est préférable de nos jours.

810
répondu Daniel Brockman 2018-05-25 15:33:20

Pour en Ligne Juges problèmes qui ne permet pas de StringBuilder ou StringBuffer , vous pouvez le faire en place à l'aide char[] comme suit:

public static String reverse(String input){
    char[] in = input.toCharArray();
    int begin=0;
    int end=in.length-1;
    char temp;
    while(end>begin){
        temp = in[begin];
        in[begin]=in[end];
        in[end] = temp;
        end--;
        begin++;
    }
    return new String(in);
}
91
répondu Sami Eltamawy 2018-02-28 07:15:59
public static String reverseIt(String source) {
    int i, len = source.length();
    StringBuilder dest = new StringBuilder(len);

    for (i = (len - 1); i >= 0; i--){
        dest.append(source.charAt(i));
    }

    return dest.toString();
}

http://www.java2s.com/Code/Java/Language-Basics/ReverseStringTest.htm

60
répondu Kevin Bowersox 2014-11-11 20:52:07
String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);
53
répondu Luchian Grigore 2011-09-27 12:48:20

je fais ceci en utilisant les deux façons suivantes:

chaîne inversée par caractères:

public static void main(String[] args) {
    // Using traditional approach
    String result="";
    for(int i=string.length()-1; i>=0; i--) {
        result = result + string.charAt(i);
    }
    System.out.println(result);

    // Using StringBuffer class
    StringBuffer buffer = new StringBuffer(string);
    System.out.println(buffer.reverse());    
}

chaîne inversée par mots:

public static void reverseStringByWords(String string) {
    StringBuilder stringBuilder = new StringBuilder();
    String[] words = string.split(" ");

    for (int j = words.length-1; j >= 0; j--) {
        stringBuilder.append(words[j]).append(' ');
    }
    System.out.println("Reverse words: " + stringBuilder);
}
25
répondu VicJordan 2017-11-15 15:56:28

regardez L'API Java 6 sous StringBuffer

String s = "sample";
String result = new StringBuffer(s).reverse().toString();
18
répondu Andrew Briggs 2011-09-27 12:50:30

voici un exemple d'utilisation de la récursion:

public void reverseString() {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String reverseAlphabet = reverse(alphabet, alphabet.length()-1);
}

String reverse(String stringToReverse, int index){
    if(index == 0){
        return stringToReverse.charAt(0) + "";
    }

    char letter = stringToReverse.charAt(index);
    return letter + reverse(stringToReverse, index-1);
}
17
répondu C0D3LIC1OU5 2014-11-03 15:36:59

Voici une solution de bas niveau:

import java.util.Scanner;

public class class1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String inpStr = in.nextLine();
        System.out.println("Original String :" + inpStr);
        char temp;
        char[] arr = inpStr.toCharArray();
        int len = arr.length;
        for(int i=0; i<(inpStr.length())/2; i++,len--){
            temp = arr[i];
            arr[i] = arr[len-1];
            arr[len-1] = temp;
        }

        System.out.println("Reverse String :" + String.valueOf(arr));
    }
}
11
répondu Grigio 2017-06-20 01:02:51

j'ai essayé, juste pour le plaisir, en utilisant une pile. Voici mon code:

public String reverseString(String s) {
    Stack<Character> stack = new Stack<Character>();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        stack.push(s.charAt(i));
    }
    while (!stack.empty()) {
        sb.append(stack.pop());
    }
    return sb.toString();

}
9
répondu Enrico Giurin 2015-11-01 02:06:01

puisque la méthode ci-dessous (en utilisant XOR ) à inverser une chaîne de caractères n'est pas listée, je joins cette méthode pour inverser une chaîne de caractères.

L'algorithme est basé sur:

1.(A XOR B) XOR B = A 151960920"

2.(A XOR B) XOR A = B 151960920"

extrait de Code:

public class ReverseUsingXOR {
    public static void main(String[] args) {
        String str = "prateek";
        reverseUsingXOR(str.toCharArray());
    }   

    /*Example:
     * str= prateek;
     * str[low]=p;
     * str[high]=k;
     * str[low]=p^k;
     * str[high]=(p^k)^k =p;
     * str[low]=(p^k)^p=k;
     * 
     * */
    public static void reverseUsingXOR(char[] str) {
        int low = 0;
        int high = str.length - 1;

        while (low < high) {
            str[low] = (char) (str[low] ^ str[high]);
            str[high] = (char) (str[low] ^ str[high]);   
            str[low] = (char) (str[low] ^ str[high]);
            low++;
            high--;
        }

        //display reversed string
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]);
        }
    }

}

Sortie:

keetarp

9
répondu Prateek Joshi 2016-07-20 08:27:22

Comme d'autres l'ont souligné, le meilleur moyen est d'utiliser:

new StringBuilder(hi).reverse().toString()

mais si vous voulez mettre cela en œuvre par vous-même, je crains que le reste des réponses ont des défauts.

la raison en est que la chaîne représente une liste de Unicode points, codés dans un tableau char[] selon le codage de longueur variable: UTF-16 .

This signifie que certains points de code utilisent un seul élément du tableau (une unité de code) mais que d'autres en utilisent deux, de sorte qu'il pourrait y avoir des paires de caractères qui doivent être traités comme une seule unité (substituts consécutifs "haut" et "bas")

public static String reverseString(String s) {
    char[] chars = new char[s.length()];
    boolean twoCharCodepoint = false;
    for (int i = 0; i < s.length(); i++) {
        chars[s.length() - 1 - i] = s.charAt(i);
        if (twoCharCodepoint) {
            swap(chars, s.length() - 1 - i, s.length() - i);
        }
        twoCharCodepoint = !Character.isBmpCodePoint(s.codePointAt(i));
    }
    return new String(chars);
}

private static void swap(char[] array, int i, int j) {
    char temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

public static void main(String[] args) throws Exception {
    FileOutputStream fos = new FileOutputStream("C:/temp/reverse-string.txt");
    StringBuilder sb = new StringBuilder("Linear B Syllable B008 A: ");
    sb.appendCodePoint(65536); //http://unicode-table.com/es/#10000
    sb.append(".");
    fos.write(sb.toString().getBytes("UTF-16"));
    fos.write("\n".getBytes("UTF-16"));
    fos.write(reverseString(sb.toString()).getBytes("UTF-16"));
}
6
répondu idelvall 2016-09-05 11:21:18

Cela a fonctionné pour moi

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

    for (int i = (text.length() - 1); i >= 0; i--) {
        System.out.print(text.charAt(i));
    }
}
4
répondu DarkMental 2017-01-18 15:39:26

il est très simple dans le code minimum des lignes

public class ReverseString {
    public static void main(String[] args) {
        String s1 = "neelendra";
        for(int i=s1.length()-1;i>=0;i--)
            {
                System.out.print(s1.charAt(i));
            }
    }
}
3
répondu Neelendra 2015-03-12 04:24:38
System.out.print("Please enter your name: ");
String name = keyboard.nextLine();

String reverse = new StringBuffer(name).reverse().toString();
String rev = reverse.toLowerCase();
System.out.println(rev);

j'ai utilisé cette méthode pour changer les noms en minuscules.

2
répondu Stormhawks 2014-10-01 21:40:41
    public String reverse(String s) {

        String reversedString = "";
        for(int i=s.length(); i>0; i--) {
            reversedString += s.charAt(i-1);
        }   

        return reversedString;
    }
2
répondu Dom Shahbazi 2014-11-02 14:32:50

Un moyen naturel pour inverser une String est d'utiliser un StringTokenizer et une pile. Stack est une classe qui implémente une pile d'objets facile à utiliser, dernier entré, premier sorti (LIFO).

String s = "Hello My name is Sufiyan";

Mettre dans la pile frontwards

Stack<String> myStack = new Stack<>();
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
     myStack.push(st.nextToken());
}

Imprimer la pile à l'envers

System.out.print('"' + s + '"' + " backwards by word is:\n\t\"");
while (!myStack.empty()) {
  System.out.print(myStack.pop());
  System.out.print(' ');
}

System.out.println('"');
2
répondu Sufiyan Ghori 2015-01-07 09:48:37
public class Test {

public static void main(String args[]) {
   StringBuffer buffer = new StringBuffer("Game Plan");
   buffer.reverse();
   System.out.println(buffer);
 }  
}
2
répondu Joby Wilson Mathews 2015-02-14 14:15:05

tout la solution ci-dessus est trop bon, mais ici je fais chaîne inverse en utilisant la programmation récursive.

ceci est utile pour qui cherche une façon récursive de faire la chaîne inverse.

public class ReversString {

public static void main(String args[]) {
    char s[] = "Dhiral Pandya".toCharArray();
    String r = new String(reverse(0, s));
    System.out.println(r);
}

public static char[] reverse(int i, char source[]) {

    if (source.length / 2 == i) {
        return source;
    }

    char t = source[i];
    source[i] = source[source.length - 1 - i];
    source[source.length - 1 - i] = t;

    i++;
    return reverse(i, source);

}

}
2
répondu Dhiral Pandya 2016-03-23 07:15:35
public void reverString(){
System.out.println("Enter value");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 try{

  String str=br.readLine();
  char[] charArray=str.toCharArray();
  for(int i=charArray.length-1; i>=0; i--){
   System.out.println(charArray[i]);
  }
  }
   catch(IOException ex){
  }
2
répondu Deepak Singh 2016-08-07 07:02:03

Inverser une chaîne de caractères:

public class Main {

    public static void main(String[] args) {

        String str1 = "whatever string something";

        StringBuffer str1buff = new StringBuffer(str1);

        String str1rev = str1buff.reverse().toString();

        System.out.println(str1rev);


    }
}

Inverser une chaîne de caractères par le mot:

public class Main {

public static void main(String[] args) {

    String str1 = "reverse this string";

    Stack<Object> stack = new Stack<>();

    StringTokenizer strTok = new StringTokenizer(str1);

    while(strTok.hasMoreTokens()){

        stack.push(strTok.nextElement());
    }

    StringBuffer str1rev = new StringBuffer();

    while(!stack.empty()){

        str1rev.append(stack.pop());
        str1rev.append(" ");


    }

    System.out.println(str1rev);



}
}
2
répondu Ege Kuzubasioglu 2017-03-03 16:41:57

procédure:

nous pouvons utiliser split() pour séparer la chaîne .Ensuite, utilisez la boucle inverse et ajoutez les caractères.


"151910920 extrait de Code":
class test
{
  public static void main(String args[]) 
  {
      String str = "world";
      String[] split= str.split("");

      String revers = "";
      for (int i = split.length-1; i>=0; i--)
      {
        revers += split[i];
      }
      System.out.printf("%s", revers);
   }  
}

 //output : dlrow

2
répondu rashedcs 2017-03-28 18:08:22

1. En Utilisant Le Tableau De Caractères:

public String reverseString(String inputString) {
    char[] inputStringArray = inputString.toCharArray();
    String reverseString = "";
    for (int i = inputStringArray.length - 1; i >= 0; i--) {
        reverseString += inputStringArray[i];
    }
    return reverseString;
}

2. En Utilisant StringBuilder:

public String reverseString(String inputString) {
    StringBuilder stringBuilder = new StringBuilder(inputString);
    stringBuilder = stringBuilder.reverse();
    return stringBuilder.toString();
}

ou

return new StringBuilder(inputString).reverse().toString();
2
répondu Avijit Karmakar 2018-02-10 15:47:07

tout le monde propose un moyen d'inverser la chaîne ici. Si vous, lecteur de la réponse, sont intéressés, ma façon d'utiliser \u202E unicode est ici.

public static String reverse(String s) {
        return "\u202E" + s;
}
2
répondu snr 2018-06-17 05:12:07

Juste Pour S'Amuser..:)



Algorithm (str,len)
char reversedStr[] =new reversedStr[len]

Traverse i de 0 à len/2 et puis

reversedStr[i]=str[len-1-i]  
reversedStr[len-1=i]=str[i]
return reversedStr;

complexité temporelle: O (n)

l'Espace de la Complexité :O(n)

public class Reverse {
    static char reversedStr[];

    public static void main(String[] args) {
        System.out.println(reversestr("jatin"));
    }


    private static String reversestr(String str) {
        int strlen = str.length();
        reversedStr = new char[strlen];

        for (int i = 0; i <= strlen / 2; i++) {
            reversedStr[i] = str.charAt(strlen - 1 - i);
            reversedStr[strlen - 1 - i] = str.charAt(i);

        }
        return new String(reversedStr);
    }

}
2
répondu jatin Goyal 2018-09-24 08:52:02
import java.util.Scanner;
public class StringReverseExample
{
    public static void main(String[] args)
    {
        String str,rev;
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the string : ");
        str = in.nextLine();
        rev = new StringBuffer(str).reverse().toString();
        System.out.println("\nString before reverse:"+str);
        System.out.println("String after reverse:"+rev);
    }
}
/* Output : 
Enter the string : satyam

String before reverse:satyam
String after reverse:maytas */
1
répondu Sandeep16 2014-09-19 13:07:52
package logicprogram;
import java.io.*;

public class Strinrevers {
public static void main(String args[])throws IOException
{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    System.out.println("enter data");
    String data=br.readLine();
    System.out.println(data);
    String str="";
    char cha[]=data.toCharArray();

    int l=data.length();
    int k=l-1;
    System.out.println(l);


    for(int i=0;k>=i;k--)
    {

        str+=cha[k];


    }
    //String text=String.valueOf(ch);
    System.out.println(str);

}

}
1
répondu kumaravel j 2014-12-18 17:05:58
import java.util.Scanner;

public class Test {

    public static void main(String[] args){
        Scanner input = new Scanner (System.in);
        String word = input.next();
        String reverse = "";
        for(int i=word.length()-1; i>=0; i--)
            reverse += word.charAt(i);
        System.out.println(reverse);        
    }
}

si vous voulez utiliser un simple pour boucle!

1
répondu Apetrei Ionut 2014-12-18 17:06:46

Il obtient la valeur que vous avez tapé et le renvoie inversée ;)

public static  String reverse (String a){
    char[] rarray = a.toCharArray();
    String finalvalue = "";
    for (int i = 0; i < rarray.length; i++)
    {
        finalvalue += rarray[rarray.length - 1 - i];
    }   
return finalvalue;

}

1
répondu Kelk 2015-01-13 15:24:24

public String reverseWords (String s) {

    String reversedWords = "";

    if(s.length()<=0) {
        return reversedWords;
    }else if(s.length() == 1){
        if(s == " "){
            return "";
        }
        return s;
    }

    char arr[] = s.toCharArray();
    int j = arr.length-1;
    while(j >= 0 ){
        if( arr[j] == ' '){
            reversedWords+=arr[j];
        }else{
            String temp="";
            while(j>=0 && arr[j] != ' '){
                temp+=arr[j];
                j--;
            }
            j++;
            temp = reverseWord(temp);
            reversedWords+=temp;
        }
        j--;

    }

    String[] chk = reversedWords.split(" ");

    if(chk == null || chk.length == 0){
        return "";
    }

    return reversedWords;



}

public String reverseWord(String s){

    char[] arr = s.toCharArray();

    for(int i=0,j=arr.length-1;i<=j;i++,j--){
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    return String.valueOf(arr);

}
1
répondu rvd 2015-05-07 01:31:33
StringBuilder s = new StringBuilder("racecar");
    for (int i = 0, j = s.length() - 1; i < (s.length()/2); i++, j--) {
        char temp = s.charAt(i);
        s.setCharAt(i, s.charAt(j));
        s.setCharAt(j, temp);
    }

    System.out.println(s.toString());
1
répondu camel-man 2016-02-05 20:09:18