Inverser une chaîne dans Java
J'ai "Hello World" conservé dans une variable String nommée hi.
J'ai besoin de l'imprimer, mais inversé.
Comment puis-je faire ceci? Je crois comprendre qu’il existe déjà une sorte de fonction intégrée dans Java.
Connexes: Inverser chaque mot individuel de la chaîne "Hello World" avec Java
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 - elles ont la même API. Merci aux commentateurs de souligner que StringBuilder est préférable de nos jours lorsqu'il n'y a pas de problème de concurrence.
Pour problèmes de juges en ligne qui ne permettent pas StringBuilder ou StringBuffer, vous pouvez le faire en place en utilisant 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);
}
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
String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);
Je le fais en utilisant les deux méthodes suivantes:
Chaîne inversée par les 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);
}
Examinez l'API Java 6 sous StringBuffer.
String s = "sample";
String result = new StringBuffer(s).reverse().toString();
Voici un exemple utilisant la récursivité:
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);
}
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));
}
}
Puisque la méthode ci-dessous (en utilisant XOR) pour inverser une chaîne n'est pas répertoriée, j'attache cette méthode pour inverser un string.
Le Algorithm est basé sur:
1. (A XOR B) XOR B = A
2. (A XOR B) XOR A = B
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
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();
}
Comme d’autres l’ont souligné, la méthode privilégiée consiste à utiliser:
new StringBuilder(hi).reverse().toString()
mais si vous voulez appliquer cela vous-même, je crains que le reste des réponses ne présente des défauts.
La raison en est que String représente une liste de points Unicode , codés dans un tableau char[] conformément au codage à longueur variable: TF-16 .
Cela signifie que certains points de code utilisent un seul élément du tableau (une unité de code), tandis que d'autres en utilisent deux, de sorte qu'il peut 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"));
}
C'est très simple en code minimum de 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));
}
}
}
Cela a fait le tour 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));
}
}
1. Utiliser Character Array:
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. Utilisation de StringBuilder:
public String reverseString(String inputString) {
StringBuilder stringBuilder = new StringBuilder(inputString);
stringBuilder = stringBuilder.reverse();
return stringBuilder.toString();
}
OR
return new StringBuilder(inputString).reverse().toString();
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 transformer les noms en arrière et en minuscules.
Procédure:
Nous pouvons utiliser split () pour scinder la chaîne. Utilisez ensuite la boucle inverse et ajoutez les caractères.
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
Toute la solution ci-dessus est trop bonne, mais je fais ici une chaîne inverse en utilisant une programmation récursive.
Ceci est utile pour ceux qui cherchent une manière récursive de faire de la chaîne inversée.
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);
}
}
public class Test {
public static void main(String args[]) {
StringBuffer buffer = new StringBuffer("Game Plan");
buffer.reverse();
System.out.println(buffer);
}
}
Une méthode naturelle pour inverser une String consiste à utiliser une StringTokenizer et une pile. Stack est une classe qui implémente une pile d'objets LIFO (dernier entré, premier sorti) facile à utiliser.
String s = "Hello My name is Sufiyan";
Mettez-le dans la pile vers l'avant
Stack<String> myStack = new Stack<>();
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
myStack.Push(st.nextToken());
}
Imprimer la pile en arrière
System.out.print('"' + s + '"' + " backwards by Word is:\n\t\"");
while (!myStack.empty()) {
System.out.print(myStack.pop());
System.out.print(' ');
}
System.out.println('"');
public String reverse(String s) {
String reversedString = "";
for(int i=s.length(); i>0; i--) {
reversedString += s.charAt(i-1);
}
return reversedString;
}
Juste pour le fun..:)
Algorithm (str,len)
char reversedStr[] =new reversedStr[len]
Traverse i de 0 à len/2 puis
reversedStr[i]=str[len-1-i]
reversedStr[len-1=i]=str[i]
return reversedStr;
Complexité temporelle: O (n)
Complexité de l'espace: 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);
}
}
public static String revString(String str){
char[] revCharArr = str.toCharArray();
for (int i=0; i< str.length()/2; i++){
char f = revCharArr[i];
char l = revCharArr[str.length()-i-1];
revCharArr[i] = l;
revCharArr[str.length()-i-1] = f;
}
String revStr = new String(revCharArr);
return revStr;
}
public static void reverseString(String s){
System.out.println("---------");
for(int i=s.length()-1; i>=0;i--){
System.out.print(s.charAt(i));
}
System.out.println();
}
public static void main(String[] args) {
String str = "Prashant";
int len = str.length();
char[] c = new char[len];
for (int j = len - 1, i = 0; j >= 0; j--, i++) {
c[i] = str.charAt(j);
}
str = String.copyValueOf(c);
System.out.println(str);
}
récursion:
public String stringReverse(String string) {
if (string == null || string.length() == 0) {
return string;
}
return stringReverse(string.substring(1)) + string.charAt(0);
}
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){
}
Vous pouvez aussi essayer ceci:
public class StringReverse {
public static void main(String[] args) {
String str = "Dogs hates cats";
StringBuffer sb = new StringBuffer(str);
System.out.println(sb.reverse());
}
}
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);
}
Tout le monde propose un moyen d'inverser la chaîne ici. Si vous, le lecteur de la réponse, êtes intéressé, mon chemin en utilisant
\u202Eunicode est ici.
_public static String reverse(String s) {
return "\u202E" + s;
}
_Il peut être testé à partir de ici .
//Solution #1 -- Using array and charAt()
String name = "reverse"; //String to reverse
Character[] nameChar = new Character[name.length()]; // Declaring a character array with length as length of the String which you want to reverse.
for(int i=0;i<name.length();i++)// this will loop you through the String
nameChar[i]=name.charAt(name.length()-1-i);// Using built in charAt() we can fetch the character at a given index.
for(char nam:nameChar)// Just to print the above nameChar character Array using an enhanced for loop
System.out.print(nam);
//Solution #2 - Using StringBuffer and reverse ().
StringBuffer reverseString = new StringBuffer("reverse");
System.out.println(reverseString.reverse()); //reverse () Causes the character sequence to be replaced by the reverse of the sequence.
Il obtient la valeur que vous avez tapée et la retourne 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;
}
Boucle For simple en Java
public void reverseString(char[] s) {
int length = s.length;
for (int i = 0; i < s.length / 2; i++) {
// swaping character
char temp = s[length - i - 1];
s[length - i - 1] = s[i];
s[i] = temp;
}
}
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 une simple boucle for!
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);
}
}
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());
Séquence de caractères (ou) ChaîneFamille de String:
String testString = "Yashwanth@777"; // ~1 1⁄4→D800₁₆«2²⁰
Utilisation de API Java 8 Stream
Nous convertissons d’abord String en flux en utilisant la méthode CharSequence.chars(), puis nous utilisons la méthode IntStream.range pour générer un flux séquentiel de nombres. Ensuite, nous mappons cette séquence de flux dans String.
public static String reverseString_Stream(String str) {
IntStream cahrStream = str.chars();
final int[] array = cahrStream.map( x -> x ).toArray();
int from = 0, upTo = array.length;
IntFunction<String> reverseMapper = (i) -> ( Character.toString((char) array[ (upTo - i) + (from - 1) ]) );
String reverseString = IntStream.range(from, upTo) // for (int i = from; i < upTo ; i++) { ... }
.mapToObj( reverseMapper ) // array[ lastElement ]
.collect(Collectors.joining()) // Joining stream of elements together into a String.
.toString(); // This object (which is already a string!) is itself returned.
System.out.println("Reverse Stream as String : "+ reverseString);
return reverseString;
}
Utiliser une boucle traditionnelle
Si vous souhaitez inverser la chaîne, nous devons suivre ces étapes.
- Convertir une chaîne en un tableau de caractères.
- Parcourez un tableau dans l'ordre inverse, ajoutez chaque caractère à une variable chaîne temporaire jusqu'au dernier caractère.
public static String reverseString( String reverse ) {
if( reverse != null && reverse != "" && reverse.length() > 0 ) {
char[] arr = reverse.toCharArray();
String temp = "";
for( int i = arr.length-1; i >= 0; i-- ) {
temp += arr[i];
}
System.out.println("Reverse String : "+ temp);
}
return null;
}
Moyen facile d'utiliser la méthode inverse fournie sous forme de StringBuffer ou de Classes StringBuilder
StringBuilder et StringBuffer sont des séquences de caractères mutables. Cela signifie que l'on peut changer la valeur de ces objets.
StringBuffer buffer = new StringBuffer(str);
System.out.println("StringBuffer - reverse : "+ buffer.reverse() );
String builderString = (new StringBuilder(str)).reverse().toString;
System.out.println("StringBuilder generated reverse String : "+ builderString );
StringBuffer a les mêmes méthodes que StringBuilder, mais chaque méthode de StringBuffer est synchronisée de sorte qu'elle soit thread-safe.
Il y a plusieurs façons d'inverser une chaîne.
1. Conversion de chaîne en octets: la méthode getBytes () permet de convertir la chaîne d'entrée en octets [].
import Java.lang.*;
import Java.io.*;
import Java.util.*;
class ReverseString{
public static void main(String[] args)
{
String input = "GeeksforGeeks";
byte [] strAsByteArray = input.getBytes();
byte [] result = new byte [strAsByteArray.length];
for (int i = 0; i<strAsByteArray.length; i++)
result[i] =
strAsByteArray[strAsByteArray.length-i-1];
System.out.println(new String(result));
}
}
2. Conversion d'une chaîne en tableau de caractères: l'utilisateur a saisi la chaîne à inverser. (personnellement suggéré)
import Java.lang.*;
import Java.io.*;
import Java.util.*;
class ReverseString{
public static void main(String[] args)
{
String input = "GeeksForGeeks";
// convert String to character array
// by using toCharArray
char[] try1 = input.toCharArray();
for (int i = try1.length-1; i>=0; i--)
System.out.print(try1[i]);
}
}
3.Utilisation de l'objet ArrayList: convertissez la chaîne d'entrée en tableau de caractères à l'aide de la méthode intégrée toCharArray (). Ajoutez ensuite les caractères du tableau dans l'objet ArrayList. Java a également intégré la méthode reverse () pour la classe Collections. Puisque la méthode Collections class reverse () prend un objet de liste, pour inverser la liste, nous allons passer à l'objet LinkedList, qui est un type de liste de caractères.
import Java.lang.*;
import Java.io.*;
import Java.util.*;
class ReverseString{
public static void main(String[] args)
{
String input = "Geeks For Geeks";
char[] hello = input.toCharArray();
List<Character> trial1 = new ArrayList<>();
for (char c: hello)
trial1.add(c);
Collections.reverse(trial1);
ListIterator li = trial1.listIterator();
while (li.hasNext())
System.out.print(li.next());
}
}