Java模拟并组织传入流

我的家庭作业如下：

“编写一个程序，将一个非负整数流分离成一个由以下内容组成的流：；首先是可被3整除的整数，其次是等价于1模3的整数，最后是等价于2模3的整数。您的程序应该通过生成0到100之间的20个随机整数来模拟传入流，并且应该最多使用4个整数堆栈来解决问题。”

我对streams不太熟悉，我对streams的体验仅限于从文件中简单地读写。因此，当我考虑解决方案时，我自然认为我可以生成一个文件并向其中写入20个随机整数。然后读入它以模拟传入的流

这就是我开始感到困惑的地方，因为我应该在流中分离流（？？？）。我理解分离的数学方面：x%3=0，x%3=1，x%3=2，但是我应该在这里创建一个新流吗？所以我会将输入流“分离”成一个输出流

然后他提到使用最多四个堆栈，我不知道我需要在哪里使用堆栈来完成这个问题，除非我应该在将整数放入新流之前使用堆栈来保存整数

请让我知道我对这个问题的理解是否合理和正确

编辑：我当前的解决方案

import java.io.*;
import java.util.Iterator;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;

/**
 * write a program which will seperate a stream of nonnegative integers into a stream     consisting of, firstly , the
 * integers which are divisible by 3, secondly, the integers equivalent to 1 modula three, and lastly, the integers
 * equivalent to 2 modulo 3.  Your program should simulate the incoming stream by generating 20 random integers between
 * 0 and 100 and should use at most 4 stack of integers to solve the problem.
*/
public class StreamSeperator {
public static void main (String[] args)
{
    /*
     *  Generate file to simulate incoming stream
     */
    int arr[] = new int[20];
    Random rand = new Random();
    for(int i = 0; i<20;i++){
        arr[i] = rand.nextInt(100);
    }
    try{
        File inputFile = new File("stream_sim.txt");

        if(!inputFile.exists()){
            inputFile.createNewFile();
        }
        FileWriter inputWriter = new FileWriter(inputFile.getAbsoluteFile());
        BufferedWriter bw = new BufferedWriter(inputWriter);
        for(int j=0;j<arr.length-1;j++){
            bw.write(String.valueOf(arr[j]));
            bw.newLine();
        }
        bw.close();
        System.out.println("Sim file generated");
    }catch (IOException e){
        e.printStackTrace();
    }
    /*
     * Read file in and sort into stacks
     */
    Stack<Integer> divisByThree = new Stack<Integer>();
    Stack<Integer> remainderOne = new Stack<Integer>();
    Stack<Integer> remainderTwo = new Stack<Integer>();

    BufferedReader br = null;
    try {

        String sCurrentLine;

        br = new BufferedReader(new FileReader("stream_sim.txt"));

        while ((sCurrentLine = br.readLine()) != null) {
            int _temp = Integer.parseInt(sCurrentLine);
            //divisible by three
            if(_temp%3==0){
                divisByThree.push(_temp);
            }
            //remainder of one
            else if(_temp%3==1){
                remainderOne.push(_temp);
            }
            //remainder of two
            else if(_temp%3==2){
                remainderTwo.push(_temp);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (br != null)br.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    /*
     * Feed stacks into output stream
     */
    try{
        File outFile = new File("out.txt");
        if(!outFile.exists()){
            outFile.createNewFile();
        }
        FileWriter outWriter = new FileWriter(outFile.getAbsoluteFile());
        BufferedWriter outbw = new BufferedWriter(outWriter);
        Iterator itStack1 = divisByThree.iterator();
        Iterator itStack2 = remainderOne.iterator();
        Iterator itStack3 = remainderTwo.iterator();
        //first stack
        while(itStack1.hasNext()){
            outbw.write(String.valueOf(divisByThree.pop()));
            outbw.newLine();
        }
        //second stack
        while(itStack2.hasNext()){
            outbw.write(String.valueOf(remainderOne.pop()));
            outbw.newLine();
        }
        //thrid stack
        while(itStack3.hasNext()){
            outbw.write(String.valueOf(remainderTwo.pop()));
            outbw.newLine();
        }
        outbw.close();
        System.out.println("Out file generated");
    }catch (IOException e){
        e.printStackTrace();
    }
}

import java.io.*；
导入java.util.Iterator；
导入java.util.Random；
导入java.util.Scanner；
导入java.util.Stack；
/**
*编写一个程序，将一个非负整数流分离成一个流，首先由
*可被3整除的整数，第二，等于1模3的整数，最后是整数
*相当于2模3。您的程序应该通过在两个值之间生成20个随机整数来模拟传入流
*0和100，最多应使用4个整数堆栈来解决此问题。
*/
公共类流分离器{
公共静态void main（字符串[]args）
{
/*
*生成文件以模拟传入流
*/
int arr[]=新int[20]；
Random rand=新的Random（）；
对于（int i=0；i
我对溪流不太熟悉

这就是作业的重点——让你更熟悉

你在正确的轨道上。将问题分解为几个部分：阅读、组织和重定向

为每种情况创建一个
OutputStream
，并写入与您的标准相匹配的值。
我仍然不确定堆栈是如何处理问题的，分配指示我应该将这些值分成一个流。是否有理由为每种情况创建一个流？我应该在完成后使用堆栈保存整数吗读入整数并对其进行排序，然后创建一个输出流，然后按顺序写入它们？我认为“堆栈”一词不应该让你想到另一种数据结构。我认为你也不必对任何东西进行排序。我的看法是：“接受一个值，决定在哪里写入，然后写入。"这就是多个输出流出现的原因。问问自己：一个值是否可以写入多个流？没有？堆栈可以引用一个流？我们在流之前研究了堆栈/队列，所以我仍然认为他希望我使用堆栈来解决问题。他也希望输出是一个流，所以我认为排序是必要的必要。我在上面也添加了我当前的解决方案。好吧，我明白你的意思。我对措辞的解释不同。我现在同意你的观点。我不认为数据结构需要是一个堆栈；如果必须对它们进行排序，我会说任何集合都可以。你需要每种类型一个，并且需要一个大的集合来将它们组合在一起。