合工大2022春Java实验二：货物进销管理系统

import java.io.BufferedReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

//第一次调试：Error.txt为空，shipping.txt为空
//newInventory.txt 之中根本没有进行删改
public class CargoManagement {
    public static void main(String[] args) throws Exception {
        new getInventory();
        System.out.println("文件处理完成。");
    }
}

// 库存货物类
class Goods {
    // Item number 字符串型，货物编号
    // Quantity 整型，货物数量
    // Supplier 字符串型，供应商编号
    // Description 字符串型，货物描述

    String itemNumber;
    int quantity;
    String supplier;
    String description;

    public Goods(String itemNumber, String quantity, String supplier, String description) {
        this.itemNumber = itemNumber;
        this.quantity = Integer.parseInt(quantity);
        this.supplier = supplier;
        this.description = description;
    }

    // 构造函数
    public Goods(String itemNumber, int quantity, String supplier, String description) {
        this.itemNumber = itemNumber;
        this.quantity = quantity;
        this.supplier = supplier;
        this.description = description;
    }

    public String getItemNumber() {
        return itemNumber;
    }

    public void setItemNumber(String itemNumber) {
        this.itemNumber = itemNumber;
    }

    // 获取属性函数
    public int getQuantity() {
        return this.quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public String getSupplier() {
        return supplier;
    }

    // 设置属性函数
    public void setSupplier(String supplier) {
        this.supplier = supplier;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

}

class getInventory {
    ArrayList goodsArray = new ArrayList(); // 用于存储从inventory.txt中读取的货物信息
    BufferedWriter errorWriter = new BufferedWriter(new FileWriter("D:\\JavaApp\\OCR\\Experiment2\\Error.txt",true));

    Goods good = null;

    public getInventory() throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("D:\\JavaApp\\OCR\\Experiment2\\Inventory.txt"));
        String line = null;
        while ((line = br.readLine()) != null) {
            String[] str = line.split("\\s+"); // 正则表达式，用于处理一个或者多个空格
            good = new Goods(str[0], str[1], str[2], str[3]);
            goodsArray.add(good);
        }
        br.close();

        // 以下部分将首先读取Transaction文件
        new getTransactions();

    }

    // O 出货，有四位，分别是o，货物编号，数量和客户 A在库存之中添加一种货物，分别是产品编号，供应商编号，描述。数量为零
    // R 到货，分别是产品编号和数量 D删除一种货物
    class getTransactions { // 此类用于从transactions.txt中读取数据并且处理

        ArrayList transInform = new ArrayList();
        ArrayList splitedArrayList = new ArrayList();
        ArrayList shippingBuffer = new ArrayList<>();
        String line = null;
        String[] revtal = null;

        // 在读取Transaction的时候要对Arraylist之中的元素进行排序
        public getTransactions() throws Exception {
            BufferedReader readTrans = new BufferedReader(
                    new FileReader("D:\\JavaApp\\OCR\\Experiment2\\transactions.txt"));
            while ((line = readTrans.readLine()) != null) { // LINE每次读取一行数据
                transInform.add(line);
            }

            readTrans.close();

            //将transInform进行排序
            Collections.sort(transInform,new Comparator() {

                @Override
                public int compare(String str, String str2) {
                    // TODO Auto-generated method stub
                    if (!(str.charAt(0)==str2.charAt(0))) {
                                            if (str.charAt(0) == 'O') {
                                                if (str2.charAt(0) == 'A') {
                                                    return 1;
                                                } else if (str2.charAt(0) == 'R') {
                                                    return -1;
                                                } else if (str2.charAt(0) == 'D') {
                                                    return -1;
                                                }
                                            } else if (str.charAt(0) == 'A') {
                                                return -1;
                                            } else if (str.charAt(0) == 'D') {
                                                return 2;
                                            } else if (str.charAt(0) == 'R') {
                                                if (str2.charAt(0) == 'O') {
                                                    return 1;
                                                } else if (str2.charAt(0) == 'D') {
                                                    return -1;
                                                } else if (str2.charAt(0) == 'A') {
                                                    return 1;
                                                }
                                            }
                                        } else {
                                            return (str.compareTo(str2)); // 如果相等，直接按字符串大小顺序进行比较即可
                                        }
            
                                    
                                return 0;
                            }
                
            });

            //将transInform按tab进行分割
            for(String temp:transInform){
                String []revtal2 = temp.split("\\s+");
                splitedArrayList.add(revtal2);
            }

            errorFileInfo();
            
            choose();

            WriteFile();
    }

    void errorFileInfo() throws IOException{
        errorWriter.write("库存不足信息以及删除货物信息:");
        errorWriter.newLine();
        errorWriter.write("数字分别代表：客户编号、货物编号及货物数量");
        errorWriter.newLine();
    }

    // 选择函数，判断究竟是出货、进货、还是添加货物、删除
    void choose() throws Exception {

    for(String[] temp1 :splitedArrayList){
        switch(temp1[0]){
            case "A":
                goodsAdd(temp1);
                break;
            case "O":
                goodsOutput(temp1);
                checkShipping();
                break;
            case "R":
                goodsReset(temp1);
                break;
            case "D":
                goodsDelete(temp1);
                break;
        }           

    }
}

    // 发货函数，需要将发货记录写到shipping.txt中
    void goodsOutput(String[] str) throws ShortageException, IOException {

        for (Goods good : goodsArray) { 

            if (str[1].equals(good.getItemNumber()) ) { 
                
                int num = Integer.parseInt(str[2]); 
                int qual = good.getQuantity();
                if (qual>num) {        //如果货物的数量大于发货的数量
                    good.setQuantity(qual - num);
                    String line = good.getSupplier() + "\t" + good.getItemNumber() + "\t"
                            + str[2];                     
                    shippingBuffer.add(line);
                }else {                   
                    String newLine1 = good.getSupplier() + "\t" + good.getItemNumber() + "\t"
                            + str[2];
                    errorWriter.write(newLine1);
                    errorWriter.flush();
                    errorWriter.newLine();
                }
            }
        }

    }

    // 添加货物函数
    void goodsAdd(String[] str) {
        Goods newGood = new Goods(str[1], 0, str[2], str[3]);
        goodsArray.add(newGood);
    }

    // 到货函数
    void goodsReset(String[] str) {
        for (Goods good : goodsArray) {
            if (str[1] == good.getItemNumber()) {
                good.setQuantity(good.getQuantity() + Integer.parseInt(str[2]));
            }
        }
    }

    // 删除货物
    void goodsDelete(String[] str) throws IOException {
        
        for (Goods good : goodsArray) {
            if (str[1] == good.getItemNumber()) {
                goodsArray.remove(good);
                boolean flag = goodsArray.remove(good);
                if((flag)&&good.getQuantity()>0){
                    String line = good.getSupplier() + "\t" + good.getItemNumber() + "\t" + Integer.toString(good.getQuantity());
                    errorWriter.write(line);
                    errorWriter.flush();
                    errorWriter.newLine();
                }
                
            }
        }
    }

    // 这是更新以后的库存记录，将其写道NewInventory.txt文件中
    void WriteFile() throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\JavaApp\\OCR\\Experiment2\\NewInventory.txt"));
        for (Goods newGood : goodsArray) {
            String line = newGood.getItemNumber() + "\t" + Integer.toString(newGood.getQuantity()) + "\t"
                    + newGood.getSupplier() + "\t" + newGood.getDescription();
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        bw.close();

    }

   
    void checkShipping() throws Exception {
        BufferedWriter shippingWriter = new BufferedWriter(
            new FileWriter("D:\\JavaApp\\OCR\\Experiment2\\shipping.txt")) ;
            for (int i = 0; i < shippingBuffer.size() - 1; i++) { 
                for (int j = i + 1; j < shippingBuffer.size(); j++) {

                    //判断条件为：客户数量编号相同，并且货物编号相同
                    if ((shippingBuffer.get(i).toString().split("\t")[0]
                            .equals(shippingBuffer.get(j).toString().split("\t")[0]))
                            && (shippingBuffer.get(i).toString().split("\t")[2]
                                    .equals(shippingBuffer.get(j).toString().split("\t")[2]))) {
                        int num1 = Integer.parseInt(shippingBuffer.get(i).toString().split("\t")[2]);
                        int num2 = Integer.parseInt(shippingBuffer.get(j).toString().split("\t")[2]);
                        int num = num1 + num2;
                        String line = shippingBuffer.get(i).toString().split("\t")[0] + "\t"
                                + shippingBuffer.get(i).toString().split("\t")[1] + "\t" + Integer.toString(num);
                        shippingBuffer.remove(i); //将i和j位置的元素删除
                        shippingBuffer.remove(j);
                        shippingBuffer.add(i, line); //将合并后的元素添加到i位置
                        i--;
                    }

                }
            }
            //最后，将其写入文件中
            for (String sb : shippingBuffer) {
                shippingWriter.write(sb);
                shippingWriter.newLine();
                shippingWriter.flush();
            }

            shippingWriter.close();
        }
    }
}



class ShortageException extends Exception {
    public ShortageException() {
        super("库存不足");
    }
}

class CheckOutput {
    public static void checkOutput(int num) throws ShortageException {
        if (num > 0) {
            System.out.println("数据无误");
        } else {
            throw new ShortageException();
        }
    }
}

源代码如上。

主要设计思路：

1. 首先设计出货物类，其中包括Item、Quantity、Supplier以及Description等属性，以及构造方法、传递属性和修改属性等方法。
2. 实现读取库存信息类，这一点主要是利用BufferReader从文件中读取信息，并且根据读取出来的信息实例化对象，存入到ArrayList数组之中，等待后续操作。
3. 实现读取发货单类，同在，再读取了信息以后首先利用Collection提供的sort()方法自定义排序，之后使用String的split()方法，将成行的发货信息截取为单独的Item、Quantity等信息，之后，根据发货、删除等要求对对象数组进行操作，与此同时写入shipping.txt和error.txt
4. 等发货信息单读取结束以后，最后遍历对象数组将其写入到新库存单之中。

如上。欢迎借鉴。