停车场管理系统 Java语言

清疚 2023-07-22 05:56 27阅读 0赞

## **停车场管理系统 数据结构 Java语言** ##

## 题目 ##

设停车场是一个可停放n辆汽车的狭长死胡同，南边封口，汽车只能从北边进出。汽车在停车场内按车辆到达时间的先后顺序，最先到达的第一辆车停放在车场的最南端，依次向北排开。若车场内已停满n辆汽车，则后来的汽车只能在门外的过道上等候，一旦有车开走，则排在过道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路（假定停车场内设有供车辆进出的便道，所有的司机也必须在车内随时待命），待该辆车开出大门外，其他车辆再按原次序进入车场。每辆停放在车场的车在它离开停车场时，要按停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。

## 示意图 ##

![示意图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70]

## 设计思路 ##

根据题目分析我采用的是链队列和栈。分析可知：需要两个栈和一个队列。两个栈分别是停车栈和缓冲栈。队列是候车场。  
(1)停车栈：南边封口，汽车只能从北边进出。满足栈的特性，需要使用栈数据结构。  
(2)缓存栈：停车场的车要离开时，在该车后面的车辆要先退出车场为它让路，车离开后，在按原次序进入车场。根据分析，使用栈的数据结构。  
(3)候车场：停车场停满时，后来的汽车只能在过道上等候，有车开走，则排在过道上的第一辆车即可开入。可以看出候车场是先进先出，满足队列的特性，需要使用队列的数据结构。  
(4)车离开停车场时，要按停留的实际长短交纳费用，需要记录车进入停车场的时间。  
(5)写出一个菜单界面，用于操作和显示。  
下面开始实现一个有5个停车位的停车场

## 类设计 ##

Car类：汽车的实体类

MyStack接口：栈的接口  
OutStack类：停车场栈  
InStack类：汽车离开停车场的缓冲栈

QueueNode类：链队列的结点  
Queue类：候车场队列

Parking类：运行类，菜单  
InOutCar类：实现各种进入出入停车场方法

如下图所示：  
![类布局][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70 1]

Car实体类

import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * 汽车类
     */
    public class Car {
        
    
        private String number;  //车牌号
        private Date inTime;    //汽车进入停车场的时间
        private Date outTime;   //汽车退出停车场的时间
    
        public Car(){
        
            this.number="";
            inTime=null;
            outTime=null;
        }
    
        public Car(String num){
        
            this.number=num;
            inTime=null;
            outTime=null;
        }
    
        public String getNumber() {
        
            return number;
        }
    
        public void setNumber(String number) {
        
            this.number = number;
        }
    
        public String getInTime() {
        
            SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            return f.format(inTime);
        }
    
        public void setInTime(Date inTime) {
        
            this.inTime = inTime;
        }
    
        public String getOutTime() {
        
            SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            return f.format(outTime);
        }
    
        public void setOutTime(Date outTime) {
        
            this.outTime = outTime;
        }
    }

MyStack接口

public interface MyStack {
        
        void push(Car car);     //入栈
        Car pop();              //出栈
        boolean isFull();       //判断是否满了
        boolean empty();        //判断是否为空
        int getLength();        //当前栈的元素数量
    }

InStack类

import java.util.Date;
    
    /**
     * 停车场
     */
    public class InStack implements MyStack {
        
        private int maxsize;
        private int top;
        private Car[] inCar;
    
        public InStack(){
        
            maxsize = 5;
            inCar = new Car[maxsize];
            top = -1;
        }
    
        //入栈 同时将系统时间压入
        public void push(Car car) {
        
            Date time = new Date(); //时间类
            car.setInTime(time);
            inCar[++top] = car;
        }
    
        @Override
        public Car pop() {
        
            Car item = null;
            if (!empty()){
        
                item=inCar[top--];
                item.setOutTime(new Date());
            }
            return item;
        }
    
        @Override
        public boolean isFull(){
        
            if (top == maxsize - 1){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        @Override
        public boolean empty(){
        
            if (top == -1){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        public int getLength() {
        
            return top + 1;
        }
    
        public Car getTop() {
        
            return inCar[top];
        }
    
        public void print(){
        
            for (int i = 0;i < getLength();i++){
        
                System.out.printf("%3d %12s %21s",(i+1),inCar[i].getNumber(),inCar[i].getInTime());
                System.out.println();
            }
        }
    }

OutStack类

/**
     * 停车场栈
     */
    public class OutStack implements MyStack {
        
        private int maxsize;
        private int top;
        private Car[] outCar;
    
        public OutStack(){
        
            maxsize = 5;
            outCar = new Car[maxsize];
            top = -1;
        }
    
        //判断是否满了
        public boolean isFull(){
        
            if (top == maxsize - 1){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        //入栈
        public void push(Car car) {
        
            if (!isFull()){
        
                outCar[++top] = car;
            }
        }
    
        //出栈
        public Car pop(){
        
            Car item = null;
            if (!empty()){
        
                item=outCar[top--];
            }
            return item;
        }
    
        //判断是否为空
        public boolean empty(){
        
            if (top == -1){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        public int getLength() {
        
            return top + 1;
        }
    }

QueueNode类

/**
     * 链队列的结点
     */
    public class QueueNode {
        
        private Car data;
        private QueueNode next;
    
        QueueNode(){
        }
    
        public QueueNode(Car item) {
        
            data = item;
        }
    
        public Car getData() {
        
            return data;
        }
    
        public void setData(Car data) {
        
            this.data = data;
        }
    
        public QueueNode getNext() {
        
            return next;
        }
    
        public void setNext(QueueNode next) {
        
            this.next = next;
        }
    }

Queue类

/**
     * 候车场队列
     */
    public class Queue {
        
        private QueueNode front; //队列头指示器
        private QueueNode rear;  //队列尾指示器
        private int maxsize;        //队列的容量，假如为0，不限容量
        private int size;           //队列数据元素个数
    
        //初始化链队列
        public Queue(){
        
            front = rear = null;
            size = 0;
            maxsize = 0;
        }
    
        public Queue(int maxsize){
        
            super();
            this.maxsize = maxsize;
        }
    
        public boolean isEmpty(){
        
            if ((front == rear) && (size == 0)){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        public boolean isFull(){
        
            if (maxsize != 0 && size == maxsize){
        
                return true;
            }else{
        
                return false;
            }
        }
    
        public boolean enqueue(Car car){
        
            QueueNode newnode = new QueueNode(car);
            if (!isFull()){
        
                if (isEmpty()){
        
                    front = newnode;
                    rear = newnode;
                }else{
        
                    rear.setNext(newnode);
                    rear = newnode;
                }
                ++size;
                return true;
            }else
            {
        
                return false;
            }
        }
    
        public Car dequeue(){
        
            if (isEmpty()) return null;
            QueueNode node = front;
            front = front.getNext();
            if (front == null){
        
                rear = null;
            }
            --size;
            return node.getData();
        }
    
        public Car peek(){
        
            if (!isEmpty()){
        
                return front.getData();
            }else
                return null;
        }
    
        public Integer getSize(){
        
            return size;
        }
    
        public void print() {
        
            QueueNode queue = front;
            for (int i = 0;i < size;i++){
        
                System.out.printf("%2d %9s",(i+1),queue.getData().getNumber());
                System.out.println();
                queue = queue.getNext();
            }
        }
    }

Parking类

import java.util.Scanner;
    
    /**
     * 运行类，菜单
     */
    public class Parking {
        
    
        public InOutCar inOutCar;
        private static Integer price = 1;
    
        //构造方法
        public  Parking(){
        
            inOutCar = new InOutCar();
        }
    
        public void menu(){
        
            System.out.println("    停车场管理系统     ");
            System.out.println("---------主菜单---------");
            System.out.println("    (1)车辆到达");
            System.out.println("    (2)车辆离开");
            System.out.println("    (3)显示停车场信息");
            System.out.println("    (4)显示等待车辆信息");
            System.out.println("    (5)修改单价");
            System.out.println("    (0)退出系统");
            Scanner scanner = new Scanner(System.in);
    
            while (true){
        
                System.out.println();
                System.out.print("请选择(1,2,3,4,0)：");
                Integer menuIndex = scanner.nextInt();
                String number;
                switch (menuIndex){
        
                    case 1:
                        System.out.print("请输入到达的车牌号：");
                        number = scanner.next();
                        inOutCar.inCar(number);
                        break;
                    case 2:
                        System.out.print("请输入离开的车牌号：");
                        number = scanner.next();
                        inOutCar.outCar(number);
                        break;
                    case 3:
                        inOutCar.parkPrint();
                        break;
                    case 4:
                        inOutCar.waitPrint();
                        break;
                    case 5:
                        System.out.println("现在的价格为："+getPrice()+"/秒");
                        System.out.print("请输入要修改为的价格：");
                        Integer newPrice = scanner.nextInt();
                        setPrice(newPrice);
                        System.out.println("修改成功");
                        break;
                    case 0:
                        System.out.println("系统已退出");
                        return;
                }
            }
        }
    
        public static Integer getPrice() {
        
            return price;
        }
    
        public void setPrice(Integer price) {
        
            this.price = price;
        }
    
        public static void main(String[] args) {
        
            Parking parking = new Parking();
            parking.menu();
        }
    }

InOutCar类

import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * 实现各种进入出入停车场方法
     */
    public class InOutCar {
        
        private InStack inCar;          //停车场
        private OutStack outCar;        //临时栈
        private Queue waitCar;          //候车区
    
        public InOutCar(){
        
            inCar = new InStack();
            outCar = new OutStack();
            waitCar = new Queue();
        }
    
        //停车到停车场
        public void inCar(String number){
        
            Car car = new Car(number);
            //判断停车场是否满了
            if (!inCar.isFull()){
        
                //没满，停车到停车场
                inCar.push(car);
                System.out.println("*********************");
                System.out.println("您的车牌号:"+inCar.getTop().getNumber());
                System.out.println("进入停车场时间:"+inCar.getTop().getInTime());
                System.out.println("*********************");
            }else{
        
                //满了，停车到候车区
                waitCar.enqueue(car);
                System.out.println("*********************");
                System.out.println("您的车牌号:" + car.getNumber());
                System.out.println("停车场已满，您现在在等待中，您的位置是第" + waitCar.getSize() + "个");
                System.out.println("*********************");
            }
        }
    
        //打印停车场信息
        public void parkPrint() {
        
            System.out.println("停车位     车牌号     到达时间");
            System.out.println("------------------------------");
            inCar.print();
        }
    
        //打印候车区信息
        public void waitPrint() {
        
            System.out.println("位置     车牌号");
            System.out.println("------------------------------");
            waitCar.print();
        }
    
        //退出停车场
        public void outCar(String number){
        
            try {
        
                while (!inCar.getTop().getNumber().equals(number)){
        
                    //把之后进入的车辆先退出停车场
                    outCar.push(inCar.pop());
                }
                Car oCar = inCar.pop();
                DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date inTime = df.parse(oCar.getInTime());
                Date outTime = df.parse(oCar.getOutTime());
    
                long time = outTime.getTime() - inTime.getTime();
    
                System.out.println("*********************");
                System.out.println("你的车牌号："+oCar.getNumber());
                System.out.println("进入停车场时间："+oCar.getInTime());
                System.out.println("离开停车场时间："+oCar.getOutTime());
                System.out.println("需要交纳的费用："+time/1000 * Parking.getPrice()+"元");
                System.out.println("*********************");
    
                //把退出停车场的车加回去
                int length = outCar.getLength();
                for (int i = 0;i < length;i++){
        
                    inCar.push(outCar.pop());
                }
    
                //如果候车场有车，就安排进停车场
                if (waitCar.getSize() != 0){
        
                    inCar.push(waitCar.dequeue());
                }
            } catch (ParseException e) {
        
                e.printStackTrace();
            }
        }
    }

## 程序运行效果 ##

![运行截图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70]: /images/20230528/cee66493d1c34753ad721a5ec57dfb02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70 1]: /images/20230528/b72a3e3717ab4cd6b1a179b62c770cdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MjY1MA_size_16_color_FFFFFF_t_70 2]: /images/20230528/77f911f323bd42178a4342b48d2025de.png