Java 如何以相反的顺序获取字符数组？

我的作业问题是这样的

编写一个程序，使用

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

void printReverse（字符字母[]，int size）

是您必须执行的函数的签名。例如

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

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

void printReverse（char letters[]，int size）是必须执行的函数的签名。例如

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

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

您可以使用如下方法：

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

您可以使用如下方法：

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

---

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

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

---

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

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

---

你的代码是正确的，除了在主方法和循环中有一些小的改变，并且方法必须是静态的

签名printReverse（char[]字母，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]);
    }
  }

 }

---

你的代码是正确的，除了在主方法和循环中有一些小的改变，并且方法必须是静态的

签名printReverse（char[]字母，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]);
    }
  }

 }

`

`

输出： 4爱`

`

输出：

---

4love

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

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

publicstaticvoidreversestring（char[]s）{
int len=s.长度；
如果（len==0）
回来
对于（int i=0；i<（len/2）；i++）
{
charl=s[i]；
s[i]=s[len-i-1]；
s[len-i-1]=l；
}
系统输出打印项次；
}

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

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

publicstaticvoidreversestring（char[]s）{
int len=s.长度；
如果（len==0）
回来
对于（int i=0；i<（len/2）；i++）
{
charl=s[i]；
s[i]=s[len-i-1]；
s[len-i-1]=l；
}
系统输出打印项次；
}

公共作废打印反转（char[]word）{
reverseWordMaxIndex=word.length-1；
char[]reverseWord=新字符（reverseWordMaxIndex+1）
for（int i=0；i

公共作废打印反转（char[]word）{
reverseWordMaxIndex=word.length-1；
char[]reverseWord=新字符（reverseWordMaxIndex+1）
for（int i=0；i

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

公共类反向限制{

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

---

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

公共类反向限制{

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

import java.util.Scanner；
公共类字符串反转{
静态字符串输入；
void completeReverse（）{
char[]ch=StringReverse.input.toCharArray（）；
对于（int i=ch.length-1；i>=0；i--）{
系统输出打印（ch[i]）；
}
}
void partialReverse（）{
字符串charOfSplit=“”；
//在空格字符上拆分和创建数组。
String[]split=StringReverse.input.split（charOfSplit）；
//在拆分字符的每个索引上使用循环。
对于（int i=0；i=0；j--）{
//按相反顺序打印该字符数组
系统输出打印（indexedValue[j]）；
}
//在用户给定的空格之后为另一个索引值指定空格。
系统输出打印（“”）；
}
}
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
StringReverse sr=新的StringReverse（）；
System.out.print（“输入字符串：”）；
//修剪字符串前后的每个空格。
StringReverse.input=sc.nextLine（）.trim（）；
系统输出打印（“完全反转：”）；
sr.completeReverse（）；
System.out.println（）；
系统输出打印（“部分反转：”）；
sr.partialReverse（）；
}
}

导入java.util.Scanner；
公共类字符串反转{
静态字符串输入；
void completeReverse（）{
char[]ch=StringReverse.input.toCharArray（）；
对于（int i=ch.length-1；i>=0；i--）{
系统输出打印（ch[i]）；
}
}
void partialReverse（）{
字符串charOfSplit=“”；
//在空格字符上拆分和创建数组。
String[]split=StringReverse.input.split（charOfSplit）；
//在拆分字符的每个索引上使用循环。
对于（int i=0；i=0；j--）{
//按相反顺序打印该字符数组
系统输出打印（indexedValue[j]）；
}
//在用户给定的空格之后为另一个索引值指定空格。
系统输出打印（“”）；
}
}
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
StringReverse sr=新的StringReverse（）；
系统输出打印（“Ent