如何使用Java语言以相反的顺序进行输出？

我面临一个问题，从标准输入中提取所有行，并将它们以相反的顺序写入标准输出。 即按与输入相反的顺序输出每一行

下面是我的代码：

  import java.util.Scanner;

  public class ReverseOrderProgram {
   public static void main(String args[]) {
    //get input
    Scanner sc = new Scanner(System.in);
    System.out.println("Type some text with line breaks, end by 
    \"-1\":");
    String append = "";
    while (sc.hasNextLine()) {
        String input = sc.nextLine();
        if ("-1".equals(input)) {
            break;
        }
        append += input + " ";
    }
    sc.close();
    System.out.println("The current append: " + append);
    String stringArray[] = append.split(" strings" + "");



    System.out.println("\n\nThe reverse order is:\n");

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

        System.out.println(stringArray[i]);
    }
   }
  }

我得到以下输出：

  The current append: My name is John. David is my best friend. James also is my best friend.


  The reverse order is:

  My name is John. David is my best friend. James also is my best friend.

鉴于，所需的输出如下：

  Type some text with line breaks, end by "-1":
  My name is John.
  David is my best friend.
  James also is my best friend.
  -1

  The current append: My name is John. David is my best friend. James also is my best friend.


  The reverse order is:

  James also is my best friend.
  David is my best friend. 
  My name is John.

---

有人能帮我检查代码的错误并修复它吗？

你应该将输入字符串添加到列表中，然后从底部打印，或者使用集合。reverse（）方法，然后直接打印它

而不是将输入附加到附加字符串。您应该将输入字符串添加到列表中，然后从底部打印或使用集合。反转（）方法，然后直接打印

1-1方法是从backword开始运行循环

for (int i = stringArray.length; i >=0 ; i++) {

    System.out.println(stringArray[i]);
}

2-对列表使用Collections.reverse（）方法并打印它。像

    List<String> list = Arrays.asList(stringArray); 

    Collections.reverse(list ); 

    System.out.println("Modified List: " + list ); 

List List=Arrays.asList（stringArray）；
收款。反向（列表）；
System.out.println（“修改列表：+列表”）；

1-1方法是从backword运行循环

for (int i = stringArray.length; i >=0 ; i++) {

    System.out.println(stringArray[i]);
}

2-对列表使用Collections.reverse（）方法并打印它。像

    List<String> list = Arrays.asList(stringArray); 

    Collections.reverse(list ); 

    System.out.println("Modified List: " + list ); 

List List=Arrays.asList（stringArray）；
收款。反向（列表）；
System.out.println（“修改列表：+列表”）；

尝试下面的代码

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class ReverseOrderProgram {
public static void main(String args[]) {

    Scanner sc = new Scanner(System.in);
    System.out.println("Type some text with line breaks, end by\"-1\":");
    List<String> list= new LinkedList<String>();
    String append = "";
    while (sc.hasNextLine()) {
        String input = sc.nextLine();
        if ("-1".equals(input)) {
            break;
        }
        list.add(input);
    }
    sc.close();
    System.out.println("The current append: " + append);

    Collections.reverse(list);
    for (String string : list) {
        System.out.println(string);
    }
  }
}

import java.util.Collections；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Scanner；
公共类反向排序程序{
公共静态void main（字符串参数[]）{
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“键入一些带换行符的文本，以\“-1\”：”结尾）；
列表=新建LinkedList（）；
字符串append=“”；
while（sc.hasNextLine（））{
字符串输入=sc.nextLine（）；
如果（“-1”。等于（输入））{
打破
}
列表。添加（输入）；
}
sc.close（）；
System.out.println（“当前追加：“+append”）；
收款。反向（列表）；
用于（字符串：列表）{
System.out.println（字符串）；
}
}
}

希望这将帮助您

尝试以下代码

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class ReverseOrderProgram {
public static void main(String args[]) {

    Scanner sc = new Scanner(System.in);
    System.out.println("Type some text with line breaks, end by\"-1\":");
    List<String> list= new LinkedList<String>();
    String append = "";
    while (sc.hasNextLine()) {
        String input = sc.nextLine();
        if ("-1".equals(input)) {
            break;
        }
        list.add(input);
    }
    sc.close();
    System.out.println("The current append: " + append);

    Collections.reverse(list);
    for (String string : list) {
        System.out.println(string);
    }
  }
}

import java.util.Collections；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.Scanner；
公共类反向排序程序{
公共静态void main（字符串参数[]）{
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“键入一些带换行符的文本，以\“-1\”：”结尾）；
列表=新建LinkedList（）；
字符串append=“”；
while（sc.hasNextLine（））{
字符串输入=sc.nextLine（）；
如果（“-1”。等于（输入））{
打破
}
列表。添加（输入）；
}
sc.close（）；
System.out.println（“当前追加：“+append”）；
收款。反向（列表）；
用于（字符串：列表）{
System.out.println（字符串）；
}
}
}

---

希望这将帮助您进行编辑-基本上与前面的答案相同，但使用了for循环：

import java.util.ArrayList;
import java.util.Scanner;

public class ReverseOrderProgram {
    public static void main(String args[]) {

    //create arraylist for lines
    ArrayList<String> lines = new ArrayList<String>();
    //get input

    Scanner sc = new Scanner(System.in);
    System.out.println("Type some text with line breaks, end by \"-1\":");
    String append = "";
    while (sc.hasNextLine()) {
        String input = sc.nextLine();
        if ("-1".equals(input)) {
            break;
        }
        lines.add(input);
    }

    sc.close();
    System.out.println("The current append: ");
    for(String line : lines){
        System.out.print(line + ". ");
    }

    System.out.println("\n\nThe reverse order is:\n");

    for (int i = lines.size()-1; i >=0 ; i--) {
        System.out.println(lines.get(i));
    }
}
}

import java.util.ArrayList；
导入java.util.Scanner；
公共类反向排序程序{
公共静态void main（字符串参数[]）{
//为行创建arraylist
ArrayList行=新的ArrayList（）；
//获取输入
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“键入一些带换行符的文本，以\“-1\”：”结尾）；
字符串append=“”；
while（sc.hasNextLine（））{
字符串输入=sc.nextLine（）；
如果（“-1”。等于（输入））{
打破
}
行。添加（输入）；
}
sc.close（）；
System.out.println（“当前附加：”）；
用于（字符串行：行）{
系统输出打印（行+”）；
}
System.out.println（“\n\n相反顺序为：\n”）；
对于（int i=lines.size（）-1；i>=0；i--）{
System.out.println（lines.get（i））；
}
}
}

编辑-与前面的答案基本相同，但使用for循环：

import java.util.ArrayList;
import java.util.Scanner;

public class ReverseOrderProgram {
    public static void main(String args[]) {

    //create arraylist for lines
    ArrayList<String> lines = new ArrayList<String>();
    //get input

    Scanner sc = new Scanner(System.in);
    System.out.println("Type some text with line breaks, end by \"-1\":");
    String append = "";
    while (sc.hasNextLine()) {
        String input = sc.nextLine();
        if ("-1".equals(input)) {
            break;
        }
        lines.add(input);
    }

    sc.close();
    System.out.println("The current append: ");
    for(String line : lines){
        System.out.print(line + ". ");
    }

    System.out.println("\n\nThe reverse order is:\n");

    for (int i = lines.size()-1; i >=0 ; i--) {
        System.out.println(lines.get(i));
    }
}
}

import java.util.ArrayList；
导入java.util.Scanner；
公共类反向排序程序{
公共静态void main（字符串参数[]）{
//为行创建arraylist
ArrayList行=新的ArrayList（）；
//获取输入
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“键入一些带换行符的文本，以\“-1\”：”结尾）；
字符串append=“”；
while（sc.hasNextLine（））{
字符串输入=sc.nextLine（）；
如果（“-1”。等于（输入））{
打破
}
行。添加（输入）；
}
sc.close（）；
System.out.println（“当前附加：”）；
用于（字符串行：行）{
系统输出打印（行+”）；
}
System.out.println（“\n\n相反顺序为：\n”）；
对于（int i=lines.size（）-1；i>=0；i--）{
System.out.println（lines.get（i））；
}
}
}

您可以使用具有LIFO行为的堆栈数据结构来插入和读取元素。更完整的Java堆栈实现是Deque，它具有方法“DegendingOrder”，该方法以相反的顺序返回元素的迭代器

        Deque deque = new LinkedList();

        // We can add elements to the queue in various ways
        deque.add("Element 1 (Tail)"); // add to tail
        deque.addFirst("Element 2 (Head)");
        deque.addLast("Element 3 (Tail)");
        deque.push("Element 4 (Head)"); //add to head
        deque.offer("Element 5 (Tail)");
        deque.offerFirst("Element 6 (Head)");
        deque.offerLast("Element 7 (Tail)");

        Iterator reverse = deque.descendingIterator();
        System.out.println("Iterating over Deque with Reverse Iterator");
        while (reverse.hasNext()) {
            System.out.println("\t" + reverse.next());
        }

---

可以使用具有LIFO行为的堆栈数据结构来插入和读取元素。更完整的Java堆栈实现是Deque，它具有方法“DegendingOrder”，该方法以相反的顺序返回元素的迭代器

        Deque deque = new LinkedList();

        // We can add elements to the queue in various ways
        deque.add("Element 1 (Tail)"); // add to tail
        deque.addFirst("Element 2 (Head)");
        deque.addLast("Element 3 (Tail)");
        deque.push("Element 4 (Head)"); //add to head
        deque.offer("Element 5 (Tail)");
        deque.offerFirst("Element 6 (Head)");
        deque.offerLast("Element 7 (Tail)");

        Iterator reverse = deque.descendingIterator();
        System.out.println("Iterating over Deque with Reverse Iterator");
        while (reverse.hasNext()) {
            System.out.println("\t" + reverse.next());
        }

---

您可以使用其他答案建议的

Collections.reverse（）

。但是标准的反转方法是使用

堆栈

<代码>堆栈是一种后进先出的数据结构，它准确地展示了您所需的行为。您需要将所有结果推送到

堆栈

并

弹出

直到

堆栈

变为

空

。下面的代码片段将为您提供一个提纲

String input = " Hello \n World \n Here you go";
List<String> inputList = Arrays.asList(input.split("\n"));
        Stack<String> myStringStack = new Stack<>();
        myStringStack.addAll(inputList); // This is to exhibit your input scenario from user.
        while (!myStringStack.isEmpty()) { // While your stack is not empty, keep popping!
            System.out.println(myStringStack.pop());
         }

String input=“Hello\n World\n在这里”；
List-inputList=Arrays.asList（input.split（“\n”）；
Stack myStringStack=新堆栈（）；
迈斯特