快递管理训练（IO）

任务概述：

采用二维数组存储快递，使用IO技术将快递数据存储到文件中，可以在每次启动应用时读取文件中的内容。

1、管理员

        - 快递录入

                - 柜子位置（系统产生，不能重复）

                - 快递单号（输入）

                - 快递公司（输入）

                - 6位取件码（系统 产生，不能重复）

- 根据单号删除快递

- 根据单号修改快递

- 查看所有快递（遍历）

2、普通用户

- 快递取出

        - 输入取件码：显示快递的信息和在哪个柜子中，从柜子中移除这个快递信息

代码部分：

目录结构：

bean => Express

package pers.h.express.bean;

import java.io.Serializable;
import java.util.Objects;

/**
 * @author s
 * @version 1.0
 * @date 2022-02-07
 */
public class Express implements Serializable {
    // 快递单号
    private String number;
    // 快递公司
    private String company;
    // 取件码
    private int code;
    // 快递位置
    public int posX;
    public int posY;
    // 无参构造函数
    public Express() {
    }
    // 全参构造函数
    public Express(String number, String company, int code) {
        this.number = number;
        this.company = company;
        this.code = code;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "Express{" +
                "number='" + number + '\'' +
                ", company='" + company + '\'' +
                ", code=" + code +
                '}';
    }

    @Override
    // 重写equals方法，快递单号相同，则快递相同
    public boolean equals(Object o) {
        if(this == o) return true;
        if(o == null || getClass() != o.getClass()) return false;
        Express express = (Express) o;
        return Objects.equals(number,express);
    }

    @Override
    public int hashCode() {
        return Objects.hash(code);
    }
}

dao => ExpressDao

package pers.h.express.dao;

import pers.h.express.bean.Express;

import java.util.Collection;
import java.util.HashMap;
import java.util.Random;

/**
 * @author s
 * @version 1.0
 * @date 2022-02-07
 */
public class ExpressDao {
    // 生产随机数
    private Random random = new Random();
    //存快递
    public boolean add(Express e, boolean[][] cabinet, HashMap<Integer,Express> data){
        int size = data.size();
        // 判断快递是否存满
        if(size >= 100){
            return false;
        }
        // 生产随机下标
        int x = -1, y = -1;
        while (true){
            x = random.nextInt(10);
            y = random.nextInt(10);
            if(cabinet[x][y] == false){
                break; // 此位置为空，跳出循环
            }
        }
        int code = randomCode(data.values());//获得未重复的取件码
        e.setCode(code);
        e.posX = x;
        e.posY = y;
        size++;
        cabinet[x][y] = true;
        data.put(code,e);
        return true;
    }
    /**
     * @Description 遍历所有对象，生产取件码
     * @param expresses
     * @return int
     */
    private int randomCode(Collection<Express> expresses){
        while (true){
            int code = random.nextInt(900000) + 100000;
            Express e = findByCode(code,expresses);
            if(e == null){
                return code;
            }
        }
    }

    public Express findByCode(int code,Collection<Express> expresses){
        for(Express e: expresses){
            if(e.getCode() == code){
                return e;
            }
        }
        return null;
    }

    public Express findByNumber(String number,Collection<Express> expresses){
        for(Express e: expresses){
            if(e.getNumber().equals(number)){
                return e;
            }
        }
        return null;
    }

    public void update(Express oldExpress, Express newExpress, boolean[][] cabinet, HashMap<Integer,Express> data){
        delete(oldExpress,cabinet,data);
        add(newExpress,cabinet,data);
    }

    public void delete(Express e,boolean[][] cabinet,HashMap<Integer,Express> data){
        data.remove(e.getCode());
        cabinet[e.posX][e.posY] = false;
    }
}

main => Main

package pers.h.express.main;

import pers.h.express.bean.Express;
import pers.h.express.dao.ExpressDao;
import pers.h.express.view.Views;

import java.io.*;
import java.util.Collection;
import java.util.HashMap;

/**
 * @author s
 * @version 1.0
 * @date 2022-02-07
 */
public class Main {
    private static Views v = new Views();
    private static ExpressDao dao = new ExpressDao();
    // 程序入口
    public  static void main(String[] args) throws IOException,ClassNotFoundException {
        // 初始化数据结构
        boolean[][] cabinet = new boolean[10][]; //二维数组表示快递柜
        HashMap<Integer, Express> data; // HashMap代替二维数组表示快递柜
        Collection<Express> expresses; // 存放所有快递信息
        for(int i = 0; i < 10; i++){
            cabinet[i] = new boolean[10];
        }
        int size = 0; //当前快递的存储数目（便于判断快递柜是否还有空位置）
        // 反序列化获得快递柜中存储的对象HashMap<Integer,Express> data
        try(FileInputStream fis = new FileInputStream("Expresses.txt")){
            ObjectInputStream ois = new ObjectInputStream(fis);
            data = (HashMap<Integer, Express>) ois.readObject();
            ois.close();
        }catch (IOException e){
            data = new HashMap<>();
        }
        expresses = data.values();
        for(Express e:expresses){
            cabinet[e.posX][e.posY] = true;
        }
        m:
        while(true){
            int menu = v.menuMain();
            switch (menu){
                case 0:
                    break m;
                case 1:
                    gClient(data.size(),cabinet,data);
                    break;
                case 2:
                    uClinet(data.size(),cabinet,data);
                    break;
            }
        }
        FileOutputStream fos = new FileOutputStream("Expresses.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(data);
        oos.close();
    }
    private static void uClinet(int size, boolean[][] cabinet,HashMap<Integer,Express> data){
        Collection<Express> expresses = data.values(); // 获得所有快递对象，便于遍历查找
        // 1.获取取件码
        int code = v.uMenu();
        // 2.根据取件码取出快递
        Express e = dao.findByCode(code,expresses);
        if(e == null){
            v.printNull();
        }else {
            v.success();
            v.printExpress(e);
            dao.delete(e, cabinet, data);
        }
    }
    private static void gClient(int size, boolean[][] cabinet, HashMap<Integer, Express> data){
        while (true){
            int menu = v.menuDeliveryMan();
            switch (menu){
                case 0:
                    return;
                case 1:{
                    // 1、提示输入快递信息
                    Express e = v.insert();
                    // 2、此快递是否已经存储过
                    Express e2 = dao.findByNumber(e.getNumber(),data.values());
                    // 3、存储快递
                    if(e2 == null){ // 未存储过
                        dao.add(e,cabinet,data);
//                        v.printCode(e);
                    }else{
                        v.expressExist();
                    }
                    break;
                }
                case 2:{ //修改快递
                    // 1、提示输入快递信息
                    String number = v.findByNumber();
                    // 2、查找数据
                    Express e1 = dao.findByNumber(number, data.values());
                    // 3、打印快递信息
                    if(e1 == null){
                        v.printNull();
                    }else{
                        v.printExpress(e1);
                        // 4、提示修改
                        v.update(e1);
                        dao.update(e1,e1,cabinet,data);
                        v.printExpress(e1);
                    }
                    break;
                }
                case 3: {// 删除
                    // 1、输入快递单号
                    String number = v.findByNumber();
                    // 2、查找快递对象
                    Express e = dao.findByNumber(number,data.values());
                    if(e == null){
                        v.printNull();
                    }else{
                        v.printExpress(e);
                        int type = v.delete();
                        if(type == 1){
                            dao.delete(e,cabinet,data);
                        }else{
                            v.success();
                        }
                    }
                    break;
                }
                case 4:{ //查看所有
                    v.printAll(data.values());
                    break;
                }
            }
        }
    }
}

view => views

package pers.h.express.view;

import pers.h.express.bean.Express;

import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Scanner;

/**
 * @author s
 * @version 1.0
 * @date 2022-02-07
 */
public class Views {
    private Scanner sc = new Scanner(System.in);

    public void welcome(){
        System.out.println("=========欢迎使用新职课快递柜=========");
    }

    public void exit(){
        System.out.println("==========欢迎下次使用！==========");
    }

    /**
     * 选择身份界面
     * @return
     * */
    public int menuMain(){
        System.out.println("请输入您的身份：1-快递员；2-用户；0-退出");
        String inp = sc.nextLine();
        int num = -1;
        // 判断用户输入是否正确
        try {
            num = Integer.parseInt(inp);
        }catch (NumberFormatException e){

        }
        if(num < 0 || num > 2){
            System.out.println("您的输入有误，请重新输入！");
            return menuMain();
        }
        return num;
    }

    /**
     * 快递员功能界面
     * @return
     * */
    public int menuDeliveryMan(){
        System.out.println("请输入：1-快递录入；2-快递修改；3-快递删除；4-查看所有快递；0-返回上级目录");
        String inp = sc.nextLine();
        int num = -1;
        try {
            num = Integer.parseInt(inp);
        }catch (NumberFormatException e){

        }
        if(num < 0 || num > 5){
            System.out.println("输入有误，请重新输入！");
            return menuDeliveryMan();
        }
        return num;
    }

    /**
     * 快递员录入快递
     * @return
     * */
    public Express insert(){
        System.out.println("请输入快递单号：");
        String number = sc.nextLine();
        System.out.println("请输入快递公司：");
        String company = sc.nextLine();
        Express express = new Express();
        express.setNumber(number);
        express.setCompany(company);
        return express;
    }

    /**
     * 修改快递信息
     * @param e
     * */
    public void update(Express e){
        System.out.println("请输入新的快递单号：");
        String number = sc.nextLine();
        System.out.println("请输入新的快递公司：");
        String company = sc.nextLine();
        e.setNumber(number);
        e.setCompany(company);
    }

    /**
     * 询问是否删除
     * @return 1-确认删除；2-取消并退出
     * */
    public int delete(){
        System.out.println("确认删除么？1-确认删除；2-取消；0-退出");
        String inp = sc.nextLine();
        int num = -1;
        try {
            num = Integer.parseInt(inp);
        }catch (NumberFormatException e){
            return delete();
        }
        if(num < 0 || num > 2){
            return delete();
        }
        return num;
    }

    /**
     * 显示所有快递信息
     * @param expresses
     * */
    public void printAll(Collection<Express> expresses){
        int count = 0;
        for(Express e : expresses){
            count++;
            System.out.println("第"+(e.posX)+"行，第"+(e.posY+1)+"列，"+e);
        }
    }

    /**
     * 打印快递信息
     * @param express
     * */
    public void printExpress(Express express){
        System.out.println(express.toString());
    }

    /**
     *输入快递单号，用于查找快递
     * @return number
     * */
    public String findByNumber(){
        System.out.println("请输入快递单号：");
        String number = sc.nextLine();
        return number;
    }

    /**
     * 用户菜单界面
     * @return
     * */
    public int uMenu(){
        System.out.println("请输入取件码");
        String code = sc.nextLine();
        int num = -1;
        try {
            num = Integer.parseInt(code);
        }catch (NumberFormatException e){
            System.out.println("您的输入有误，请重新输入！");
            return uMenu();
        }
        if(num < 100000 || num > 999999){
            System.out.println("输入有误，请重新输入！");
            return uMenu();
        }
        return num;
    }

    /**
     * 快递已存在
     * */
    public void expressExist(){
        System.out.println("此单号在快递柜中已存在，请检查是否正确！");
    }

    /**
     * 获取新的取件码
     * @param e
     */
    public void printCode(Express e){
        System.out.println("新的快递取件码为："+e.getCode());
    }

    /**
     * 操作成功提示
     * */
    public void success(){
        System.out.println("操作成功！");
    }


    /**
     * 提示快递柜不存在
     * */
    public void printNull(){
        System.out.println("快递不存在，请检查输入是否正确！");
    }

    /**
     * 操作失败
     * */

    public void printFail(){
        System.out.println("操作失败！");
    }
    public void isNull(){
        System.out.println("无快递信息！");
    }
}