Java 字符串数组未反向输出

我有一个问题是这样的

创建一个名为Lab2Part4的Java程序，该程序包含一个名为 输出反向。该方法必须输入三个字符串，然后输出 三条反向的字符串，中间有空格， 例如。，

outputInReverse（“The”、“Black”、“Cat”）

将

“Cat Black”作为一个字符串输出

我想做一个嵌套的for循环，其中原始数组将以相反的顺序覆盖一个新数组，然后打印新数组，但似乎有点混乱

public static void main(String[] args) {
     String[] ArrayInput = new String[] { "The", "Black", "Cat" };
     outputInReverse(ArrayInput);
}

public static void outputInReverse(String[] FirstOrder) {
     String[] FinalOrder = new String[] {"One", "Two", "Three"};

     for (int i = 2; i >= 0; i--) {
         for (int j = 0; j <= 2; j++) {
            FinalOrder[j] = FirstOrder[i];
         }
     }
     System.out.println(Arrays.toString(FinalOrder));
     }
}

publicstaticvoidmain（字符串[]args）{
字符串[]ArrayInput=新字符串[]{“The”，“Black”，“Cat”}；
输出反向（ArrayInput）；
}
公共静态void outputInReverse（字符串[]第一顺序）{
字符串[]FinalOrder=新字符串[]{“一”、“二”、“三”}；
对于（int i=2；i>=0；i--）{
对于（int j=0；j您正在为嵌套循环中的
FinalOrder
数组的所有元素指定相同的值

Final order[0]: Cat 
Final order[1]: Cat 
Final order[2]: Cat 
Final order[0]: Black   
Final order[1]: Black   
Final order[2]: Black   
Final order[0]: The 
Final order[1]: The 
Final order[2]: The

试试这个：

public static void outputInReverse(String[] FirstOrder) {
    String[] FinalOrder = new String[] {"One", "Two", "Three"};

    int j = 0;
    for (int i = 2; i >= 0; i--) {
            FinalOrder[j] = FirstOrder[i];
            j++;
    }
    System.out.println(Arrays.toString(FinalOrder));
}

输出：

[Cat, Black, The]

您正在为嵌套循环中的
FinalOrder
数组的所有元素指定相同的值

Final order[0]: Cat 
Final order[1]: Cat 
Final order[2]: Cat 
Final order[0]: Black   
Final order[1]: Black   
Final order[2]: Black   
Final order[0]: The 
Final order[1]: The 
Final order[2]: The

试试这个：

public static void outputInReverse(String[] FirstOrder) {
    String[] FinalOrder = new String[] {"One", "Two", "Three"};

    int j = 0;
    for (int i = 2; i >= 0; i--) {
            FinalOrder[j] = FirstOrder[i];
            j++;
    }
    System.out.println(Arrays.toString(FinalOrder));
}

输出：

[Cat, Black, The]

嵌套循环的工作方式与您在这种情况下使用的方式不同

如果我们试图一步一步地了解这些循环中发生了什么：

for (int i = 2; i >= 0; i--) {
    for (int j = 0; j <= 2; j++) {
        FinalOrder[j] = FirstOrder[i];
    }
}

在此类操作的情况下，您的输出将是：
“
”，因为
FirstOrder
数组的第一个元素作为最后3个操作分配给
FinalOrder
数组的所有索引

因此，您不能使用这样的循环来实现您想要实现的目标。
要做到这一点，我宁愿做以下事情：

for (int i = 2; i >= 0; i--) {
    FinalOrder[2 - i] = FirstOrder[i];
}

此外，您不需要用元素填充
FinalOrder
数组。您只需创建一个大小为3的空数组，如：

String[]FinalOrder=new String[3]；
嵌套循环的工作方式与您在这种情况下使用的方式不同

如果我们试图一步一步地了解这些循环中发生了什么：

for (int i = 2; i >= 0; i--) {
    for (int j = 0; j <= 2; j++) {
        FinalOrder[j] = FirstOrder[i];
    }
}

在此类操作的情况下，您的输出将是：
“
”，因为
FirstOrder
数组的第一个元素作为最后3个操作分配给
FinalOrder
数组的所有索引

因此，您不能使用这样的循环来实现您想要实现的目标。
要做到这一点，我宁愿做以下事情：

for (int i = 2; i >= 0; i--) {
    FinalOrder[2 - i] = FirstOrder[i];
}

此外，您不需要用元素填充
FinalOrder
数组。您只需创建一个大小为3的空数组，如：

String[]FinalOrder=new String[3]；
我使用java编译器尝试了您的代码，只做了一点修改，添加了一个print语句：

import java.util.Arrays;
public class MyClass {
    public static void main(String[] args) {

        String[] ArrayInput = new String[] { "The", "Black", "Cat" };

        outputInReverse(ArrayInput);

    }




    public static void outputInReverse(String[] FirstOrder) {
        String[] FinalOrder = new String[] {"One", "Two", "Three"};

        for (int i = 2; i >= 0; i--) {
            for (int j = 0; j <= 2; j++) {
                FinalOrder[j] = FirstOrder[i];
                System.out.println(FinalOrder[j]);
            
            }
        }
        System.out.println(Arrays.toString(FinalOrder));
    }

}

导入java.util.array；
公共类MyClass{
公共静态void main（字符串[]args）{
字符串[]ArrayInput=新字符串[]{“The”，“Black”，“Cat”}；
输出反向（ArrayInput）；
}
公共静态void outputInReverse（字符串[]第一顺序）{
字符串[]FinalOrder=新字符串[]{“一”、“二”、“三”}；
对于（int i=2；i>=0；i--）{
对于（int j=0；j，我使用java编译器尝试了您的代码，只做了一点修改，添加了一个print语句：

import java.util.Arrays;
public class MyClass {
    public static void main(String[] args) {

        String[] ArrayInput = new String[] { "The", "Black", "Cat" };

        outputInReverse(ArrayInput);

    }




    public static void outputInReverse(String[] FirstOrder) {
        String[] FinalOrder = new String[] {"One", "Two", "Three"};

        for (int i = 2; i >= 0; i--) {
            for (int j = 0; j <= 2; j++) {
                FinalOrder[j] = FirstOrder[i];
                System.out.println(FinalOrder[j]);
            
            }
        }
        System.out.println(Arrays.toString(FinalOrder));
    }

}

导入java.util.array；
公共类MyClass{
公共静态void main（字符串[]args）{
字符串[]ArrayInput=新字符串[]{“The”，“Black”，“Cat”}；
输出反向（ArrayInput）；
}
公共静态void outputInReverse（字符串[]第一顺序）{
字符串[]FinalOrder=新字符串[]{“一”、“二”、“三”}；
对于（int i=2；i>=0；i--）{
对于（int j=0；j），您学习过如何调试java代码吗？您学习过如何调试java代码吗？