java - 如何以相反的顺序获取 char 数组？

Question

我的作业问题是这样的

编写一个程序，使用逆序打印字符数组中的字母

void printReverse(char letters[], int size);

例如，如果数组包含 {'c', 's', 'c', '2', '6', '1'}，则输出应为“162csc”。

试过了，不知道什么意思

void printReverse(char letters[], int size);

我这样做了，但是在主方法中调用方法“printReverse”时出现问题

import java.util.Arrays;
import java.util.Collections;
 
public class search {

    public static void main(String[] args) {          
 
        char[] letters = {'e', 'v', 'o', 'l', '4'};
        printReverse();

    }

    public void printReverse(char[] letters, int size) {
    
        for (int i = letters.length-1; i >= 0 ; i--) {
        System.out.print(letters[i]);
    }
}

Answer 1

您可以像这样使用StringBuilder#reverse()方法：

String reverse = new StringBuilder(new String(letters)).reverse().toString();

Answer 2

我相信你写的是你必须创建的方法的签名。

public void printReverse(char[] letters, int size){
   //code here
}

您将不得不迭代数组并向后打印它包含的内容。使用反向“for 循环”遍历“字母”中的每个项目。我会让你自己把这些结合起来，因为这是一项任务。下面是一个 for 循环的例子：

for (int i = array.length-1; i >= 0 ; i--){
    System.out.print(array[i]);
}

Answer 3

这大约需要 6 毫秒。它在打印之前“就地”反转 char 数组。

public static void reverseString(char[] s) {
    int len = s.length;

    if (len == 0)
        return;

    for (int i=0; i < (len/2); i++)
    {
        char l = s[i];
        s[i] = s[len-i-1];
        s[len-i-1] = l;
    }

    System.out.println(s);
}

Answer 4

`

//not only prints the reverse order, but creates new char array with chars in desired order
char[] letters = {'e', 'v', 'o', 'l', '4'};
int i = letters.length - 1, j = 0;
char[] let = new char[letters.length];
while(i >= 0){
     let[j] = letters[i];
     i--;
     j++;
}
for (char c : let){
     System.out.print(c);
}

`

输出：4爱

Answer 5

void printReverse(char letters[], int size)是您必须执行的功能的签名。例如

void printReverse(char letters[], int size) {
//your code goes here
}

并使用参数从主窗口调用它。

Answer 6

你的代码是对的，除了主方法和循环中的一些小改动，并且方法必须是静态的。

签名 printReverse(char[] letters, int size) 意味着当你调用它时，你必须传递 char 数组和数组的大小

尝试以下

import java.util.Arrays;
import java.util.Collections;

public class search {

    public static void main(String[] args) {          

   char[] letters = {'e', 'v', 'o', 'l', '4'};

   printReverse(letters,5);

}

public static void printReverse(char[] letters, int size){

    for (int i = size-1; i >= 0 ; i--)
    {

     System.out.print(letters[i]);
    }
  }

 }

Answer 7

public void printReverse(char[] word){

reverseWordMaxIndex = word.length -1;

char[] reverseWord = new char(reverseWordMaxIndex + 1)

for ( int i= 0; i < word.length; i++){

reverseWord[reverseWordMaxIndex-i] = word[i];

}

for( int i= 0; i < reverseWord.length; i++){
  System.out.println(reverseWord[i]);
   }

}

Answer 8

这是一个使用递归来尊重字符数组的类。

公共类 ReverseString {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String str = new String("Hello");
        char[] strcharArray = str.toCharArray();
        printReverse(strcharArray);

    }

    private static void printReverse(char [] str) {
          helper(0, str);
        }
        private static void helper(int index, char [] str) {
          if (str == null || index >= str.length) {
            return;
          }
          helper(index + 1, str);
          System.out.println(str[index]);
        }
}

Answer 9

#include<stdio.h>
int main()
  {
int i;
int temp;
int end;
int n=6;
int ar[6]={1, 2,3 , 4, 5, 6};
end=n-1;
printf("%d\n",end );
for(i = 0; i < 6; ++i)
 {
    temp=ar[i];
    ar[i]=ar[end];
    ar[end]=temp;
    end--;
    if(sizeof ar[6]/2==end){
        break;
    }
 } 
 printf("\n");
 for (int i = 0; i < 6; ++i)
 {
    printf("%d",ar[i] );
 }
 return 0;
}

/可以为任何类型的数组写相同的/

Answer 10

import java.util.Scanner;

public class StringReverse {

    static String input;
    void completeReverse(){
        char[] ch = StringReverse.input.toCharArray();
        for(int i =ch.length-1;i>=0;i--){
            System.out.print(ch[i]);
        }
    }
    void partialReverse(){
        String charOfSplit =" ";
        // splitting and creating array on space character.
        String[] split =StringReverse.input.split(charOfSplit);
        //using loop on each index of split characters.
        for(int i=0; i<split.length;i++){
           // System.out.println(split[i]);
            //breaking individual index in char array with different index value.
            char[] indexedValue = split[i].toCharArray();
            for(int j=indexedValue.length-1;j>=0;j--){
                //printing that char array reverse order
                System.out.print(indexedValue[j]);
            }
            // giving spaces for another index value after space given by user.
            System.out.print("  ");
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringReverse sr =new StringReverse();
        System.out.print("Enter the String: ");
        //trimming every space before and after the string.
        StringReverse.input = sc.nextLine().trim();
        System.out.print("Complete Reverse: ");
        sr.completeReverse();
        System.out.println();
        System.out.print("Partial Reverse: ");
        sr.partialReverse();
    }
}