У меня есть "Hello World"
, хранящийся в переменной String с именем hi
.
Мне нужно напечатать его, но в обратном порядке.
Как я могу это сделать? Я понимаю, что в Java уже есть какая-то встроенная функция, которая это делает.
Похожие вопросы: Обратный перевод каждого отдельного слова строки "Hello World" с помощью Java
Вы можете использовать это:
new StringBuilder(hi).reverse().toString()
Или, для версий более ранних, чем JDK 1.5, используйте java.util.StringBuffer
вместо StringBuilder
- у них одинаковый API. Спасибо комментаторам за указание на то, что StringBuilder
предпочтительнее в настоящее время, когда нет проблем с параллелизмом.
Для онлайн проблемы судей, что не позволяет класса 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);
}
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);
Я делаю это с помощью следующих двух способов:
Обратная строку символов:
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);
}
Взгляните на языке Java 6 API в StringBuffer
String s = "sample";
String result = new StringBuffer(s).reverse().toString();
Вот пример использования рекурсии:
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);
}
Я попробовал, просто ради удовольствия, с помощью стека. Вот мой код:
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();
}
Вот это низкая уровень:
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));
}
}
Поскольку ниже способ (используя исключающее или) в реверс строки не числится, я прилагаю этот метод для обратного строку.
В алгоритм базируется на :
1.(ИСКЛЮЧАЮЩЕЕ ИЛИ Б) ИСКЛЮЧАЮЩЕЕ ИЛИ Б = А
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
Как другие указали предпочтительный способ заключается в использовании:
новое окно инструментов(привет).обратный().метод toString()
но если вы хотите реализовать это с себя, я'боюсь, что остальные ответы есть недостатки.
Причина в том, что строки представляют собой список Юникод точек, закодированных в массив char[]` по переменной длиной кодирования: в UTF-16.
Это означает, что некоторые кодовые точки использовать один элемент массива (один код подразделения), а другие используют их два, так что может быть пар персонажей, которые должны рассматриваться как единое целое (подряд на "высокой" и "низкий" и суррогаты)
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"));
}
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);
Я использовал этот метод, чтобы включить имена в обратном направлении и в нижнем регистре.
Это сделал трюк для меня
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. Используя Символьный Массив:
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();
public String reverse(String s) {
String reversedString = "";
for(int i=s.length(); i>0; i--) {
reversedString += s.charAt(i-1);
}
return reversedString;
}
Мы можем использовать сплит() для разбиения строки .Затем с помощью обратной петли и добавить персонажей.
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
Просто для удовольствия..:)<БР><БР>
Algorithm (str,len)
char reversedStr[] =new reversedStr[len]
Траверс I от 0 до лен/2, а затем <БР>
reversedStr[i]=str[len-1-i]
reversedStr[len-1=i]=str[i]
return reversedStr;
Временная сложность:o(п)
Место асимптотика :o(Н)
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);
}
}
Один естественный способ обратить вспять эту строку, чтобы использовать StringTokenizer и стек. "Стек" - это класс, который реализует простой в использовании последний раз-в обратном порядке (LIFO) стек объектов.
String s = "Hello My name is Sufiyan";
Положить его в frontwards стек
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('"');
public class Test {
public static void main(String args[]) {
StringBuffer buffer = new StringBuffer("Game Plan");
buffer.reverse();
System.out.println(buffer);
}
}