У меня есть "Hello World", хранящийся в строковой переменной с именем 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);
Я делаю это, используя следующие два способа:
Обратная строка с помощью 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);
}
Взгляните на API Java 6 под 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);
}
Вот решение низкого уровня:
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));
}
}
Поскольку приведенный ниже метод (с использованием XOR) для изменения строки не указан, я привязываю этот метод для изменения строки.
Алгоритм основан на:
1. (A XOR B) XOR B = A
2. (A XOR B) XOR A = B
Фрагмент кода:
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
Я попробовал, просто для удовольствия, используя Stack. Здесь мой код:
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();
}
Как указывали другие, предпочтительным способом является использование:
new StringBuilder(hi).reverse().toString()
но если вы хотите реализовать это сами, я боюсь, что остальные ответы имеют недостатки.
Причина в том, что String представляет список точек Unicode, закодированных в массиве 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"));
}
Это очень просто в минимальном коде строк
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);
Я использовал этот метод для преобразования имен назад и в нижний регистр.
Это сделало трюк для меня
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;
}
Одним из естественных способов обратного преобразования String является использование StringTokenizer и стека. Stack - это класс, который реализует простой в использовании стек с конечным результатом (LIFO) для последнего объекта.
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('"');
public class Test {
public static void main(String args[]) {
StringBuffer buffer = new StringBuffer("Game Plan");
buffer.reverse();
System.out.println(buffer);
}
}
Просто для удовольствия.. :)
Algorithm (str,len)
char reversedStr[] =new reversedStr[len]
Переместите я от 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);
}
}
Все вышеизложенное решение слишком хорошо, но здесь я делаю обратную строку, используя рекурсивное программирование.
Это полезно для тех, кто ищет рекурсивный способ сделать обратную строку.
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 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);
}
}
Реверсирование строки по слову:
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);
}
}
Мы можем использовать split() для разделения строки. Затем используйте обратный цикл и добавьте символы.
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
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);
}
Вы также можете попробовать следующее:
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);
}
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){
}
рекурсии:
public String stringReverse(String string) {
if (string == null || string.length() == 0) {
return string;
}
return stringReverse(string.substring(1)) + string.charAt(0);
}
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();
}
//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.