जावा में एक स्ट्रिंग उल्टा

Question

मैंने "Hello World"नाम के एक स्ट्रिंग चर में रखा है hi।

मुझे इसे प्रिंट करने की आवश्यकता है, लेकिन उलट।

मैं यह कैसे कर सकता हूँ? मैं समझता हूं कि जावा में पहले से निर्मित किसी प्रकार का एक फ़ंक्शन है जो ऐसा करता है।

संबंधित: जावा के साथ "हैलो वर्ल्ड" स्ट्रिंग के प्रत्येक व्यक्तिगत शब्द को उल्टा करें

Comments

@JRL वास्तव में स्ट्रिंग ih होना चाहिए = "dlroW olleH"; Println (IH);

— मैथ्यू फरवेल

काश मैं अपने करीबी वोट (एक डुप्लिकेट के रूप में) को वापस ले सकता। मैंने दूसरे प्रश्न को फिर से पढ़ा और महसूस किया कि यह इससे अलग है। हालाँकि, यह प्रश्न अभी भी साइट पर कई बार दोहराया गया है। शायद इस के एक निशान को चिह्नित करने के लिए बस एक अलग सवाल खोजना चाहिए।

— रोब Hruska

आप StringBuilder वर्ग, toCharArray () विधि, स्वैपिंग वर्णों और कई और अधिक के रिवर्स () फ़ंक्शन का उपयोग कर सकते हैं। अधिक उदाहरणों के लिए इस संसाधन को देखें, flowerbrackets.com/2-best-ways-to-reverse-a-string-in-java

— Shiva

StringBuilder.reverse () अधिक पठनीय और सुरुचिपूर्ण समाधान है।

— लोकेश

इंटरव्यूजेंडवांसर्स

— ।blogspot.com

Answer 1

आप इसका उपयोग कर सकते हैं:

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

या, JDK 1.5 की तुलना में पहले के संस्करणों के लिए, java.util.StringBufferइसके बजाय का उपयोग करें StringBuilder- उनके पास एक ही एपीआई है। यह इंगित करने के लिए धन्यवाद टिप्पणीकार StringBuilderआजकल पसंद किए जाते हैं जब कोई संगीन चिंता नहीं होती है।

Comments

"यह बताने के लिए धन्यवाद टिप्पणीकारों कि स्ट्रिंगबर्ल आजकल पसंद किए जाते हैं"? एक स्पष्ट बयान है कि अगर स्ट्रिंग-सुरक्षा एक चिंता का विषय है तो स्ट्रिंगबर्गर। अन्यथा, StringBuilder का उपयोग किया जा सकता है। StringBuilder StringBuffer के लिए एक प्रतिस्थापन नहीं है।

— ha9u63ar

@ ha9u63ar स्थानीय थ्रो कॉन्सर्ट के साथ इस परिदृश्य के लिए StringBuilderएक चिंता का विषय नहीं है (और मुझे लगता है कि उसका यही मतलब है)।

— xehpuk

यहाँ दोनों के बीच सटीक अंतर जानने के लिए लिंक है: javatpoint.com/… संक्षेप में: StringBuilder, StringBuffer की तुलना में अधिक कुशल है। यह थ्रेड सेफ नहीं है यानी कई थ्रेड्स एक साथ StringBuilder के तरीके कह सकते हैं।

— विष्णु नारंग

यह BMP के बाहर यूनिकोड वर्णों के लिए काम नहीं करेगा, जब तक कि वर्णों के संयोजन के लिए।

— nau

@ डैनियल ब्रॉकमैन, आपके अच्छे और संक्षिप्त उत्तर के लिए धन्यवाद। यहाँ ओपी ने कहा, मेरे पास "हैलो वर्ल्ड" है, जिसका नाम हाय नामक स्ट्रिंग चर रखा गया है । इसका मतलब है String hi = "Hello World";। इसलिए मुझे लगता है कि आपके उत्तर में कोई भी दोहरा उद्धरण नहीं होना चाहिए hi। मेरा मतलब है कि यह इस तरह होना चाहिएnew StringBuilder(hi).reverse().toString()

— Md। अबू नफ़ी इब्ना ज़ाहिद

Answer 2

के लिए ऑनलाइन न्यायाधीशों समस्याओं की अनुमति देते हैं कि नहीं करता है StringBuilderया StringBuffer, आप यह कर सकते जगह में उपयोग करते हुए char[]निम्नलिखित के रूप में:

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);
}

Comments

हालांकि सिर्फ एक नोट। यह "पात्रों" के लिए बुरी तरह से विफल हो जाएगा जो दो बाइट्स पर कब्जा कर लेते हैं।

— मिनस मीना

दरअसल, यह आमतौर पर 2 बाइट्स पर कब्जा करने वाले अधिकांश पात्रों के लिए ठीक काम करता है। यूनिकोड कोडपॉइंट्स के लिए जो वास्तव में विफल होता है वह 2 x 16 बिट कोडुनिट्स (UTF-16 में) होता है।

— स्टीफन सी

यह अच्छा समाधान है, लेकिन क्या हम उसी के लिए कर सकते हैं यदि हमारे पास न्यूनतम जटिलता के साथ स्ट्रिंग में 10k अक्षर हैं।

— जतिंदर कुमार

Answer 3

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

Comments

अच्छा समाधान (1+)। एक वृद्धि - StringBuilder (java5 के बाद से) StringBuffer की तुलना में तेज़ होगी। सादर।

— मिशैल errajer

यह सामान्य मामले में काम नहीं करेगा क्योंकि यह ध्यान में नहीं रखता है कि यूनिकोड में कुछ "वर्ण" एक सरोगेट जोड़ी अर्थात दो जावा वर्णों द्वारा दर्शाए गए हैं, और इस समाधान के परिणामस्वरूप जोड़ी गलत क्रम में है। स्ट्रिंगडबल

— इयान फेयरमैन

Answer 4

String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);

Comments

इसकी जटिलता क्या है? ओ (एन) या अधिक? N, स्ट्रिंग की लंबाई के बराबर है।

— मुक्ता ०

O (n) चूंकि इसे स्ट्रिंग के वर्णों के माध्यम से कम से कम एक बार चलना है।

— PlsWork

Answer 5

मैं निम्नलिखित दो तरीकों का उपयोग करके ऐसा कर रहा हूं:

CHARACTERS द्वारा रिवर्स स्ट्रिंग:

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());    
}

कार्यों द्वारा रिवर्स स्ट्रिंग:

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);
}

Answer 6

स्ट्रिंग 6 बफ़र के तहत जावा 6 एपीआई पर एक नज़र डालें

String s = "sample";
String result = new StringBuffer(s).reverse().toString();

Comments

क्या यह StringBuilder से बेहतर है?

— CamHart

@CamHart नहीं, यह धीमा है, लेकिन शायद केवल एक छोटा सा है।

— jcsahnwaldt का कहना है कि GoFundMonica

लगभग 100 मिलियन मेथड कॉल्स के साथ थोड़ा सा बेंचमार्क StringBuffer और StringBuilder के बीच एक महत्वपूर्ण अंतर दिखाता है: stackoverflow.com/questions/355089/… लेकिन इस मामले में, केवल दो कॉल ( reverse()और toString()) हैं, इसलिए अंतर संभवतः भी नहीं होगा। औसत दर्जे का।

— jcsahnwaldt का कहना है कि GoFundMonica

Answer 7

यहाँ एक उदाहरण है पुनरावृत्ति का उपयोग कर:

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);
}

Comments

पहले से ही बेहतर जवाब हैं, खासकर @ डैनियलब्रुकमैन के। यदि एक एल्गोरिथ्म पहले से ही एक मानक पुस्तकालय में मौजूद है, तो इसे हैंडीक्राफ्ट करने और पहिया को सुदृढ़ करने की कोई आवश्यकता नहीं है।

— विली मेंजेल

एक "बहुत बेहतर उत्तर" अवधारणा व्यक्तिपरक है। यह ठीक वैसा ही हो सकता है जैसा कोई खोज रहा है।

— C0D3LIC1OU5

ओपी ने पहले ही कहा था कि "जावा में पहले से निर्मित किसी प्रकार का एक फ़ंक्शन है जो ऐसा करता है" तो उसका लक्ष्य यह जानना था कि यह कौन सा "फ़ंक्शन" है। बस एक उत्तर को पोस्ट करना जो कि पूछे गए वास्तविक प्रश्न के साथ बहुत कम है, गैर-समझदारी है। यदि किसी को एक कस्टम कार्यान्वयन के लिए पूछना था तो आपका जवाब उचित होगा, इस मामले में यह नहीं है।

— विली मेंजेल

Downvote। अधिकांश अन्य समाधान O (n) हैं और किसी भी लम्बाई के बहुत से तारों को संभाल सकते हैं, यह O (n ^ 2) है और लगभग 5000 वर्णों (JD8 8 VM, डिफ़ॉल्ट कॉन्फिग पर) से लंबे समय तक तार के लिए एक StackOverflowError के साथ दुर्घटनाग्रस्त हो जाता है। ।

— jcsahnwaldt का कहना है कि GoFundMonica

1. अन्य समाधान पुनरावृत्ति का उपयोग नहीं करते हैं और लंबे तारों को ठीक से संभाल सकते हैं। आप इस तरह के कार्य के लिए पुनरावृत्ति के बजाय पुनरावृत्ति का उपयोग क्यों करेंगे? इसका कोई मतलब नही बनता। (जब तक आप एक कार्यात्मक प्रोग्रामिंग पृष्ठभूमि से नहीं आ रहे हैं, जो अक्सर समस्याओं का कारण बनता है जब आप एक अनिवार्य / OO भाषा में कोड लिख रहे होते हैं।) 2. स्ट्रिंग संघनन (वह निर्दोष थोड़ा '+') O (n) है। आपको जावा में नया होना चाहिए, अन्यथा आपको पता चल जाएगा।

— jcsahnwaldt का कहना है कि GoFundMonica

Answer 8

यहाँ एक निम्न स्तर का समाधान है:

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));
    }
}

Answer 9

मैंने कोशिश की, सिर्फ मज़े के लिए, एक स्टैक का उपयोग करके। यहाँ मेरा कोड:

public String reverseString(String s) {
    Stack<Character> stack = new Stack<>();
    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();

}

Answer 10

चूंकि एक स्ट्रिंग को उलटने के लिए नीचे की विधि ( XOR का उपयोग ) सूचीबद्ध नहीं है, इसलिए मैं एक स्ट्रिंग को रिवर्स करने के लिए इस विधि को संलग्न कर रहा हूं।

एल्गोरिथ्म पर आधारित है:

1. (ए XOR B) XOR B = A

2. (ए एक्सओआर बी) एक्सओआर ए = बी

सांकेतिक टुकड़ा:

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]);
        }
    }

}

आउटपुट:

keetarp

Answer 11

जैसा कि दूसरों ने बताया है कि पसंदीदा तरीका उपयोग करना है:

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

लेकिन अगर आप इसे खुद से लागू करना चाहते हैं, तो मुझे डर है कि बाकी प्रतिक्रियाओं में खामियां हैं।

कारण यह है कि चर-लंबाई एन्कोडिंग के अनुसार एक सरणी में एन्कोडेड यूनिकोड बिंदुओं Stringकी एक सूची का प्रतिनिधित्व करता है : UTF-16 ।char[]

इसका मतलब है कि कुछ कोड पॉइंट ऐरे (एक कोड यूनिट) के एक तत्व का उपयोग करते हैं, लेकिन अन्य उनमें से दो का उपयोग करते हैं, इसलिए ऐसे पात्रों के जोड़े हो सकते हैं जिन्हें एकल यूनिट (लगातार "उच्च" और "कम" सरोगेट्स) माना जाना चाहिए ।

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"));
}

Comments

अच्छा समाधान, केवल एक हिस्सा गायब है जो अब डायक्ट्रीक्स के संयोजन से निपट रहा है :-D

— Ren

Answer 12

यह न्यूनतम कोड ऑफ लाइन्स में बहुत सरल है

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));
            }
    }
}

Comments

मैं अब यह लिखने जा रहा था .. पाया आपने पहले ही लिख दिया है!

— Jency

Answer 13

इसने मेरे लिए चाल चली

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

    for (int i = (text.length() - 1); i >= 0; i--) {
        System.out.print(text.charAt(i));
    }
}

Answer 14

1. चरित्र सरणी का उपयोग:

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. StringBuilder का उपयोग करना:

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

या

return new StringBuilder(inputString).reverse().toString();

Answer 15

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);

मैंने इस पद्धति का उपयोग नामों को पीछे की ओर और निचले मामलों में बदलने के लिए किया।

Answer 16

    public String reverse(String s) {

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

        return reversedString;
    }

Comments

फिर, सरोगेट जोड़े इस तरह से भ्रष्ट हो जाएंगे।

— हाइपरएन्यूट्रीनो

क्या आप इस पर विस्तार कर सकते हैं?

— डोम शाहबाज

कुछ यूनिकोड वर्णों में दो वर्ण होते हैं; यदि इन दोनों को चारों ओर घुमाया जाता है, तो स्ट्रिंग दूषित हो जाती है। इसके अलावा, एक आम तौर पर अनदेखी की गई त्रुटि regex है।

— HyperNeutrino

Answer 17

एक रिवर्स करने के लिए एक प्राकृतिक तरीका Stringएक StringTokenizerऔर एक स्टैक का उपयोग करना है । Stackएक ऐसा वर्ग है जो वस्तुओं के पहले-आउट (एलआईएफओ) के लिए एक आसान-से-उपयोग का उपयोग करता है।

String s = "Hello My name is Sufiyan";

इसे स्टैक में आगे की तरफ रखें

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

स्टैक को पीछे की तरफ प्रिंट करें

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

System.out.println('"');

Answer 18

public class Test {

public static void main(String args[]) {
   StringBuffer buffer = new StringBuffer("Game Plan");
   buffer.reverse();
   System.out.println(buffer);
 }  
}

Comments

इस सवाल का जवाब नहीं है।

— रयान

Answer 19

उपरोक्त सभी समाधान बहुत अच्छा है, लेकिन यहाँ मैं पुनरावर्ती प्रोग्रामिंग का उपयोग करके रिवर्स स्ट्रिंग बना रहा हूं।

यह रिवर्स स्ट्रिंग करने के पुनरावर्ती तरीके की तलाश में कौन है के लिए सहायक है।

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);

}

}

Answer 20

प्रक्रिया:

हम स्ट्रिंग को विभाजित करने के लिए स्प्लिट () का उपयोग कर सकते हैं। फिर रिवर्स लूप का उपयोग करें और वर्ण जोड़ें।

---

सांकेतिक टुकड़ा:

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

---

Answer 21

सार्वजनिक स्ट्रिंग रिवर्सस्क्रिप्ट (स्ट्रिंग 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);

}

Answer 22

आप यह भी आज़मा सकते हैं:

public class StringReverse {
    public static void main(String[] args) {
        String str = "Dogs hates cats";
        StringBuffer sb = new StringBuffer(str);
        System.out.println(sb.reverse());
    }
}

Comments

string.this को रिवर्स करने के लिए कई तरीके हैं। उनमें से एक है java के stringbuffer class।

— अनुराग गोयल

Answer 23

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){
  }

Answer 24

प्रत्यावर्तन:

 public String stringReverse(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }
    return stringReverse(string.substring(1)) + string.charAt(0);
 }

Answer 25

सिर्फ मनोरंजन के लिए..:)

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

I को 0 से len / 2 तक और फिर पीछे ले जाएँ

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

समय जटिलता: O (n)

अंतरिक्ष की जटिलता: 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);
    }

}

Answer 26

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

Answer 27

    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(); 

    }

Comments

यह सिर्फ एक-एक करके स्ट्रिंग का आउटपुट देता है। और यह भी कार्यक्रम में कहीं भी इस्तेमाल नहीं किया जा सकता है। स्ट्रिंग चर बनाने के लिए बेहतर है, स्ट्रिंग में एक-एक करके "चार" डालें, फिर स्ट्रिंग वापस करें।

— ज़ोंबी चबी एक्सडी

Answer 28

    //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.

Comments

@ डर्मन प्रतिक्रिया के लिए धन्यवाद। जोड़ा स्पष्टीकरण और एक और समाधान।

— अबी

Answer 29

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);

}

}

Answer 30

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);        
    }
}

यदि आप लूप के लिए एक सरल का उपयोग करना चाहते हैं!