java 简要讲解 货物进销管理系统

实验描述：

编写一个Inventory.java完成以下功能（没有学过Java文件处理之前，各位同学可以使用硬编码将数据放进两个Vector变量里。等学过Java文件处理之后，再补充数据文件读取部分）：

1．程序首先打开并读取Inventory.txt中记录的所有库存记录，然后读取Transactions.txt，处理这个文件中包含的事务，记录发货记录到Shipping.txt，并记录错误信息到Errors.txt中。最后，根据事务更新库存到另外一个文件NewInventory.txt中。

2．文件Inventory.txt和NewInventory.txt的每行包含一个存货记录，每条记录包含下面一些字段息，这些字段之间用一个tab分开（见后面的文件格式）：

 

字段	格式和含义
Item number	字符串型，货物编号
Quantity	整型，货物数量
Supplier	字符串型，供应商编号
Description	字符串型，货物描述

3．字段Items按照从小到大的顺序写入文件的。注意Item号不必连续，如Item号为752的后面可能是800。

4．文件Transactions.txt包含几个不同的处理记录（每行一条记录）。每条记录前面以一个大写字母开头，表示这条记录是什么类型的事务。在不同的大写字母后面是不同的信息格式。所有的字段也是以tab键分开的（见Transactions.txt文件格式）。

5．以'O'开头的事务表示这是一个发货订单，即某一种货物应该发给特定的客户。Item number和Quantity的格式如上面表格定义。Custom编号和上面的Supplier编号一致。处理一条定单记录（以'O'开头的事务）意味着减少库存记录中相应货物的数量（减少的数量=发货单中的数量），记录发货信息到Shipping.txt中。注意：Inventory.txt中的quantity不应该小于0，如果对于某一种货物，库存的数量小于发货单的数量的话，系统应该停止处理发货单，并记录出错信息到Errors.txt。如果对于某一种货物有多个发货单，而且库存总量小于这些发货单的总和的话，系统应该按照发货单中的数量从小到大的有限原则满足客户。也就是说，对于某一种货物如果一个数量Quantity少的发货单没有处理之前，数量Quantity多的发货单永远不会被处理。（这种处理原则不受发货单记录在Transactions.txt的先后顺序影响）

6．以'R'开头的事务表示这是一个到货单记录，在'R'后面是Item number和它的数量Quanlity。处理一条到货单意味着增加库存中相应货物的数量（增加的数量=到货单中的数量）。注意：如果在Transactions.txt文件中，到货单出现在发货单之后，到货单中的货物数量可以用来填补发货单中的数量（可以理解成在Transactions.txt中，优先处理到货单）。

7．以'A'开头的事务表示向库存中增加一种新的货物（即这种货物以前库存中没有），在'A'后面是Item number，供应商supplier以及货物的描述description。处理一个新增货物记录意味着向库存中增加一个数量Quantity为0的新的Item。你可以假设在一个Transactions.txt中，新增货物记录总是出现在第一个到货单之前。

8．以'D'开头的事务表示从库存中删除一种货物，在'D'后面是Item号。删除操作总是在所有的事物处理之后才被处理，以保证对于可能出现的同一种货物的发货单的操作能在删除之前被正确处理。如果要删除的某种货物的库存量Quantity不为0的话，系统应该向Errors.txt记录出错信息。

9．文件Shipping.txt中的每一行代表给某一客户的发货信息。Shipping.txt中的每一行分别是客户编号、Item号、货物数量，它们之间用tab键分隔。如果发货单中有两条客户编号和Item编号一样的记录，在Shipping.txt中应该将这两条发货信息合并（即将它们的数量相加）。

10．Errors.txt文件包含未发送的发货记录和库存量大于0的删除记录。Errors.txt每一行包含Custom编号、Item编号以及发货单上的数量Quantity。对于删除操作，Custom编号为0，数量Quntity为库存中的Quantity.

11．实验测试数据:

Inventory.txt

17           42          6          widget,blue

1234        0           4          whatsit

123123    999999   98      Doohicky

Transactions.txt

O          123123         1000         9

O          17                 36             8

O          17                 12             4

R          123123         1

D          1234

A           5                   4              Thingy

根据老师的讲解写的代码~

package std;

public class Inve {
	String itemnum;
	int quan;
	String supplier;
	String desc;

	public Inve(String itemnum, int quan, String supplier, String desc) {
		super();
		this.itemnum = itemnum;
		this.quan = quan;
		this.supplier = supplier;
		this.desc = desc;
	}

	Inve(Add tmp) {
		itemnum = tmp.itemnum;
		quan = 0;
		supplier = tmp.supplier;
		desc = tmp.desc;
	}

	public void plus(int q) {
		quan += q;
	}

	public void cut(int q) {
		quan -= q;
	}
}

package std;

public class Transaction {
	String type;
	String itemnum;
    public Transaction() {}
	public Transaction(String type, String itemnum) {
		// TODO Auto-generated constructor stub
		super();
		this.type = type;
		this.itemnum = itemnum;
	}
}

// 发货记录
class Order extends Transaction {

	int quan;
	String supplier;
    
	public Order() {
		super();
	}
	public Order(String type, String itemnum, int quan, String supplier) {
		super("O", itemnum);
		// TODO Auto-generated constructor stub
		this.quan = quan;
		this.supplier = supplier;
	}
	public void copy(Order o) {
		this.itemnum=o.itemnum;
		this.type="O";
		this.quan = o.quan;
		this.supplier = o.supplier;
	}
	
}

// 收货记录
class Recv extends Transaction {
	int quan;

	public Recv(String type, String itemnum, int quan) {
		super("R", itemnum);
		// TODO Auto-generated constructor stub
		this.quan = quan;
	}
}

// 添货记录
class Add extends Transaction {
	String supplier;
	String desc;

	public Add(String type, String itemnum, String supplier, String desc) {
		super("A", itemnum);
		// TODO Auto-generated constructor stub
		this.supplier = supplier;
		this.desc = desc;
	}
}

// 删货记录
class Delete extends Transaction {
	public Delete(String type, String itemnum) {
		super("D", itemnum);
		// TODO Auto-generated constructor stub
	}
}

// 错误记录
class Err {
	String itemnum;
	int quan;
	String supplier;

	Err(String c, int i, String q) {
		itemnum = c;
		quan = i;
		supplier = q;
	}

	Err(Order o) {
		supplier = o.supplier;
		itemnum = o.itemnum;
		quan = o.quan;
	}
}

package std;

import java.io.*;
import java.util.*;

public class Test {

	static Vector vecinve = new Vector();
	static Vector vecorder = new Vector();
	static Vector shipping = new Vector();
	static Vector vecrecv = new Vector();
	static Vector vecadd = new Vector();
	static Vector vecdelete = new Vector();
	static Vector vecerr = new Vector();

	public static void main(String[] args) throws Exception {
		readinve("D:\\Inventory.txt");
		readTra("D:\\Transactions.txt");
		doAdd();
		doReceive();
		arrOrder();
		doOrder();
		doDelete();
		arrshipping();
		write("D:\\NewInventory.txt D:\\shipping.txt D:\\Errors.txt");
	}

	private static void readTra(String filename) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader(filename));
		String line = "";
		while ((line = br.readLine()) != null) {
			String[] tmp = line.split("\t");
			if (tmp[0].equals("O")) {
				int quan = Integer.parseInt(tmp[2]);
				vecorder.add(new Order("O", tmp[1], quan, tmp[3]));
			} else if (tmp[0].equals("R")) {
				int quan = Integer.parseInt(tmp[2]);
				vecrecv.add(new Recv("R", tmp[1], quan));
			} else if (tmp[0].equals("A")) {
				vecadd.add(new Add("R", tmp[1], tmp[2], tmp[3]));
			} else if (tmp[0].equals("D")) {
				vecdelete.add(new Delete("D", tmp[1]));
			}
		}
		br.close();
	}

	private static void readinve(String filename) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader(filename));
		String line = "";
		while ((line = br.readLine()) != null) {
			String tmp[] = line.split("\t");
			int quan = Integer.parseInt(tmp[1]);
			vecinve.add(new Inve(tmp[0], quan, tmp[2], tmp[3]));
		}
		br.close();
	}

	public static void doAdd() {
		for (int i = 0; i < vecadd.size(); i++) {
			Inve tmp = new Inve(vecadd.get(i));
			vecinve.add(tmp);
		}
	}

	public static void doReceive() {

		for (int i = 0; i < vecrecv.size(); i++) {
			for (int j = 0; j < vecinve.size(); j++) {
				String s1, s2;
				s1 = new String(vecrecv.get(i).itemnum);
				s2 = new String(vecinve.get(j).itemnum);
				if (s1.equals(s2)) {
					(vecinve.get(j)).plus((vecrecv.get(i)).quan);
				}
			}
		}
	}

	public static void doOrder() {
		for (int i = 0; i < vecorder.size(); i++)
			for (int j = 0; j < vecinve.size(); j++) {
				String s1, s2;
				s1 = new String(vecorder.get(i).itemnum);
				s2 = new String(vecinve.get(j).itemnum);
				if (s1.equals(s2)) {
					if ((vecinve.get(j)).quan >= (vecorder.get(i)).quan) {
						(vecinve.get(j)).cut((vecorder.get(i)).quan);
						shipping.add(vecorder.get(i));
					} else {
						Err tmp = new Err(vecorder.get(i));
						vecerr.add(tmp);
					}
				}
			}
	}

	public static void doDelete() {
		for (int i = 0; i < vecdelete.size(); i++) {
			for (int j = 0; j < vecinve.size(); j++) {
				String s1, s2;
				s1 = new String(vecdelete.get(i).itemnum);
				s2 = new String(vecinve.get(j).itemnum);
				if (s1.equals(s2)) {
					if ((vecinve.get(j)).quan == 0) {
						vecinve.remove(j);
						break;
					} else {
						vecerr.add(new Err((vecinve.get(j)).itemnum, (vecinve.get(j)).quan, (vecinve.get(j)).supplier));
						break;
					}
				}
			}
		}

	}
    
	//排序
	public static void arrOrder() {
		for (int i = 0; i < vecorder.size(); i++)
			for (int j = i + 1; j < vecorder.size(); j++) {
				if ((vecorder.get(i)).quan > (vecorder.get(j)).quan) {
					Order tmp = vecorder.get(i);
					vecorder.set(i, vecorder.get(j)); // set操作：如v.set(i,p)，将索引为i的元素置为p。
					vecorder.set(j, tmp);
				}
			}
	}
    
	//合并重复的记录
	public static void arrshipping() {
		for (int i = 0; i < shipping.size(); i++)
			for (int j = i + 1; j < shipping.size(); j++) {
				String s1, s2, t1, t2;
				s1 = new String(shipping.get(i).itemnum);
				s2 = new String(shipping.get(j).itemnum);
				t1 = new String(shipping.get(i).supplier);
				t2 = new String(shipping.get(j).supplier);
				if (s1.equals(s2) && t1.equals(t2)) {
					Order tmp = new Order();
					tmp.copy(shipping.get(i));
					shipping.set(i, tmp);
					shipping.remove(j);
					j--;
				}
			}
	}

	public static void write(String filenames) throws Exception {
		String[] filename = filenames.split(" ");
		BufferedWriter ibw = new BufferedWriter(new FileWriter(filename[0]));
		BufferedWriter sbw = new BufferedWriter(new FileWriter(filename[1]));
		BufferedWriter ebw = new BufferedWriter(new FileWriter(filename[2]));

		for (int i = 0; i < vecinve.size(); i++) {
			Inve tmp = vecinve.get(i);
			String s = tmp.itemnum + "\t" + tmp.quan + "\t" + tmp.supplier + "\t" + tmp.desc;
			ibw.write(s);
			ibw.newLine(); // 换下一行
		}

		for (int i = 0; i < shipping.size(); i++) {
			Order tmp = shipping.get(i);
			String s = tmp.supplier + "\t" + tmp.itemnum + "\t" + tmp.quan;
			sbw.write(s);
			sbw.newLine();
		}

		for (int i = 0; i < vecerr.size(); i++) {
			Err tmp = vecerr.get(i);
			String s = tmp.itemnum + "\t" + tmp.supplier + "\t" + tmp.quan;
			ebw.write(s);
			ebw.newLine();
		}
		ibw.close();
		sbw.close();
		ebw.close();
	}
}