Wie kann man eine Zeichenfolge in Java umkehren? Insgesamt 7 verschiedene Möglichkeiten…

Veröffentlicht: 2020-08-10

Auf Crunchify haben wir mehr als 500 Java-Tutorials veröffentlicht und in diesem Tutorial gehen wir die Schritte durch, wie man eine Zeichenfolge in Java umkehrt.

  • Es gibt 7 verschiedene Möglichkeiten, wie Sie einen String in Java umkehren können.

Wie kann man eine Zeichenfolge in Java umkehren? Insgesamt 7 verschiedene Möglichkeiten

CrunchifyReverseString.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package crunchify . com . tutorials ;
 
import org . apache . commons . lang3 . StringUtils ;
 
import java . nio . charset . StandardCharsets ;
 
/**
* @author Crunchify.com
* How to Reverse a string in Java?
* Version: 2.0
*/
 
public class CrunchifyReverseString {
 
     public static void main ( String [ ] args ) {
         String testString = "Crunchify.com Example" ;
         System . out . println ( "String: " + testString ) ;
         System . out . println ( "\nSolution1: Reverse Using reverseStringBuffer: " + reverseStringBuffer ( testString ) ) ;
         System . out . println ( "Solution2: Reverse Using reverseCharArray: " + reverseCharArray ( testString ) ) ;
         System . out . println ( "Solution3: Reverse Using reverseStringVariable: " + reverseStringVariable ( testString ) ) ;
         System . out . println ( "Solution4: Reverse Using reverseRecursion: " + reverseRecursion ( testString ) ) ;
         System . out . println ( "Solution5: Reverse Using BuilderReverse: " + StringBuilderReverse ( testString ) ) ;
         System . out . println ( "Solution6: Reverse Using reverseApacheCommonsLang3: " + reverseApacheCommonsLang3 ( testString ) ) ;
         System . out . println ( "Solution7: Reverse Using reverseApacheCommonsLang3Separator: " + reverseApacheCommonsLang3Separator ( testString ) ) ;
     }
 
     // Solution1: Reverse using StringBuffer Example
     public static String reverseStringBuffer ( String s ) {
 
         // Causes this character sequence to be replaced by the reverse of the sequence.
// If there are any surrogate pairs included in the sequence, these are treated as single characters for the reverse operation.
         return new StringBuffer ( s ) . reverse ( ) . toString ( ) ;
     }
 
     // Solution2: Reverse using Char Array Example
     public static String reverseCharArray ( String s ) {
         char [ ] reverseStringArray = new char [ s . length ( ) ] ;
         for ( int i = s . length ( ) - 1 , j = 0 ; i ! = - 1 ; i -- , j ++ ) {
         // Returns the char value at the specified index. An index ranges from 0 to length() - 1.
// The first char value of the sequence is at index 0, the next at index 1, and so on, as for array indexing.
             reverseStringArray [ j ] = s . charAt ( i ) ;
         }
         return new String ( reverseStringArray ) ;
     }
 
     // Solution3: Reverse using String Variable Example
     public static String reverseStringVariable ( String s ) {
         String reverseStringVariable = "" ;
         for ( int i = s . length ( ) - 1 ; i ! = - 1 ; i -- ) {
             reverseStringVariable += s . charAt ( i ) ;
         }
         return reverseStringVariable ;
     }
 
     // Solution4: Reverse using Recursion Example
     public static String reverseRecursion ( String s ) {
         if ( s . length ( ) < = 1 ) {
             return s ;
         }
// Returns a string that is a substring of this string.
// The substring begins at the specified beginIndex and extends to the character at index endIndex - 1.
return reverseRecursion ( s . substring ( 1 , s . length ( ) ) ) + s . charAt ( 0 ) ;
     }
 
     // Solution5: Reverse using StringBuilder(str).reverse()
     public static String StringBuilderReverse ( String crunchifyString ) {
         byte [ ] crunchifyValue = crunchifyString . getBytes ( StandardCharsets . UTF_8 ) ;
         int length = crunchifyValue . length - 1 ;
 
         for ( int crunchifyStart = ( length - 1 ) > > 1 ; crunchifyStart > = 0 ; crunchifyStart -- ) {
             int crunchifyEnd = length - crunchifyStart ;
             byte crunchifyTemp = crunchifyValue [ crunchifyStart ] ;
             crunchifyValue [ crunchifyStart ] = crunchifyValue [ crunchifyEnd ] ;
             crunchifyValue [ crunchifyEnd ] = crunchifyTemp ;
         }
         return new String ( crunchifyValue ) ;
 
     }
 
     // Solution6: Reverse using Apache commons lang3
     public static String reverseApacheCommonsLang3 ( String s ) {
         return ( StringUtils . reverse ( "Crunchify.com Tutorial" ) ) ;
 
     }
 
     // Solution7: Reverse using Apache commons lang3
     public static String reverseApacheCommonsLang3Separator ( String s ) {
         return ( StringUtils . reverseDelimited ( "Crunchify.com Tutorial" , ' ' ) ) ;
     }
 
}

Ausgabe:

Output
1
2
3
4
5
6
7
8
9
10
11
12
/ Library / Java / JavaVirtualMachines / jdk - 14.0.2.jdk / Contents / Home / bin / java - javaagent : / Applications / IntelliJ IDEA . app / Contents / lib / idea_rt . jar = 52056 : / Applications / IntelliJ IDEA . app / Contents / bin - Dfile . encoding = UTF - 8 - classpath / Users / appshah / crunchify / github / CrunchifyTutorials / target / classes
String : Crunchify . com Example
 
Solution1 : Reverse Using reverseStringBuffer : elpmaxE moc . yfihcnurC
Solution2 : Reverse Using reverseCharArray : elpmaxE moc . yfihcnurC
Solution3 : Reverse Using reverseStringVariable : elpmaxE moc . yfihcnurC
Solution4 : Reverse Using reverseRecursion : elpmaxE moc . yfihcnurC
Solution5 : Reverse Using BuilderReverse : elpmaxE moc . yfihcnurC
Solution6 : Reverse Using reverseApacheCommonsLang3 : lairotuT moc . yfihcnurC
Solution7 : Reverse Using reverseApacheCommonsLang3Separator : Tutorial Crunchify . com
 
Process finished with exit code 0

Ich freue mich auf Ihre unterschiedlichen Ansätze zur Lösung dieser Aufgabe.