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
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.
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);
}
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 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);
}
regardez L'API Java 6 sous StringBuffer
String s = "sample";
String result = new StringBuffer(s).reverse().toString();
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);
}
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));
}
}
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();
}
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
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"));
}
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));
}
}
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));
}
}
}
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.
public String reverse(String s) {
String reversedString = "";
for(int i=s.length(); i>0; i--) {
reversedString += s.charAt(i-1);
}
return reversedString;
}
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('"');
public class Test {
public static void main(String args[]) {
StringBuffer buffer = new StringBuffer("Game Plan");
buffer.reverse();
System.out.println(buffer);
}
}
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);
}
}
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){
}
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);
}
}
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
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();
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;
}
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);
}
}
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 */
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);
}
}
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!
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;
}
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);
}
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());