精华内容
下载资源
问答
  • java web 停车场信息管理系统

    千次阅读 2020-07-15 16:03:31
    系统管理 管理管理【查询、新增管理员、修改管理员、删除管理员】 用户管理【新增用户、修改用户、删除用户、充值、查询】 车位管理 车位管理【查询车位、新增车位、修改...

    关注微信公众号:回复<停车场信息管理系统>即可获取源码。

     

    基础jsp/servlet项目

    、基础功能简介

    1. 登录、退出

    2. 管理员

      1. 系统管理

        1. 管理员管理【查询、新增管理员、修改管理员、删除管理员】

        2. 用户管理【新增用户、修改用户、删除用户、充值、查询】

      2. 车位管理

        1. 车位管理【查询车位、新增车位、修改车位、删除车位】

        2. 车费标准【修改】

        3. 停车缴费【查询、缴费】

        4. 车位状态【查询】

        5. 停车记录查询【查询、导出】

    3. 用户 

      1. 个人信息管理

        1. 修改个人信息【提交、返回】

      2. 系统使用

        1. 车辆信息【修改、删除、图片上传】

        2. 卡余额【查看】

        3. 收费标准【查看】

        4. 车位信息【查询】

        5. 停车记录查看【查询】

     

    二、项目部分截图

    展开全文
  • 采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析,得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
  • 停车场管理系统_java

    热门讨论 2011-09-09 22:51:24
    运用java语言编写 模仿停车场的日常运作 包括停车时间 存放时间 离开时间 收费 全天统计信息 全天的收益
  • 主要为大家详细介绍了java实现停车场管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 停车场管理系统 Java语言

    千次阅读 多人点赞 2020-04-04 19:30:47
    停车场管理系统 数据结构 Java语言 题目: 设停车场是一个可停放n辆汽车的狭长死胡同,南边封口,汽车只能从北边进出(这样的停车场基本没有哈哈)。汽车在停车场内按车辆到达时间的先后顺序,最先到达的第一辆车...

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

    题目

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

    示意图

    示意图

    设计思路

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

    类设计

    Car类:汽车的实体类

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

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

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

    如下图所示:
    类布局

    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();
            }
        }
    }
    

    程序运行效果

    运行截图

    展开全文
  • 主要为大家详细介绍了基于java实现停车场管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 基于Web停车场管理系统主要用于实现停车场相关信息管理,基本功能包括:系统信息管理模块、车位信息管理模块、IC卡信息管理模块、固定车主停车管理模块、临时车辆信息管理模块、系统功能操模块等。
  • java写的停车场管理系统,只要运用swing 初始化停车场(确定停车区个数n,每个停车区的停车位,且初始时,停车场为空),说明:使用一个共享数组(临界资源)存储每个停车区中空闲停车位的个数,每一个停车区使用...
  • java停车场管理系统

    2021-04-21 19:20:56
    停车场管理系统 •问题描述 –设停车场是一个可停放n辆车的狭长通道,且只有一个大门可供汽车进出。在停车场内,汽车按到达的先后次序,由北向南依次排列(假设大门在最南端)。若停车场内已停满n辆车,则后来的...

    停车场管理系统

    问题描述

    停车场是一个可停放n辆车的狭长通道,且只有一个大门可供汽车进出。在停车场内,汽车按到达的先后次序,由北向南依次排列(假设大门在最南端)。若停车场内已停满n辆车,则后来的汽车需在门外的便道上等候,当有车开走时,便道上的第一辆车即可开入。当停车场内某辆车要离开时,在它之后进入的车辆必须先退出停车场为它让路,待该辆车开出大门后,其他车辆再按原次序返回车场。每辆车离开停车场时,应按其停留时间的长短交费(在便道上停留的时间不收费)。 

     问题分析

    停车场
    1)停车场是一个可停放n辆车的狭长通道;

                              线性结构

    2)只有一个大门可供汽车进出;

                      受限的线性结构——

    3)当停车场内某辆车要离开时,在它之后进入的车辆必须先退出停车场为它让道,待该辆车开出大门后,其他车辆再按原次序返回车场。
     

                      另一个栈,大小?

    便道

    便道是一个狭长通道,且等待车辆数不确定;

                          线性结构

    便道中的车辆以排队方式先进先出

                              队列

    当有车到达时,若停车场已满或便道上有等待车辆,则进入便道排队等待;

                               (入队

    当停车场有车出场时,便道中排在最前的车辆先进入停车场。

                          出队,并进栈

    收费

    1)车辆离开按在停车场停留时间的长短交费
    2)在便道上停留的时间不收费

      实现代码

    package 实验2;
    
    //登记车辆信息
    public class Car
    {
    	public String CarNum;//车牌号码
    	public String Arrive;//存放车辆到达时间
    	public String Leave;//存放车辆离开时间
    	public long ArriveTime;//获取车辆到达时间
    	public long LeaveTime;//获取车辆离开时间
    	
    	//设置车牌号码
    	public void setCarNum(String CarNum)
    	{
    		this.CarNum=CarNum;
    		Arrive=Timeset.getTimeStamp(ArriveTime);//通过时间戳获取时间
    	}
    	//设置车辆到达时间和车辆到达状态
    	public void setArriveTime(long ArriveTime)
    	{
    		this.ArriveTime=ArriveTime;//设置车辆到达的时间
    //		Arrive=Timeset.getTimeStamp(ArriveTime);//通过时间戳获取时间
    	}
    	//设置车辆离开时间和车辆离开状态
    	public void setLeaveTime(long LeaveTime)
    	{
    		this.LeaveTime=LeaveTime;//设置车辆离开的时间
    		Leave=Timeset.getTimeStamp(LeaveTime);//通过时间戳获取时间
    	}
    
    	//返回车牌号码
    	public String getCarNum()
    	{
    		return CarNum;
    	}
    	public int getTime(){
    		return (int)((LeaveTime-ArriveTime)*10)/60000;
    	}
    	public String toString() 
    	{				
    		return "Car{" +
    				"carNo='" + CarNum + '\'' +
    				", arrive='" + Arrive + '\'' +
    				", leave='" + Leave + '\'' +
    				'}';
    	}
    }
    
    package 实验2;
    //汽车节点类,用于链队列中
    public class CarNode {
        public Car car;// 汽车
        public CarNode next;// 下一个节点
        public CarNode()
        {
        	this(null,null);
        }
        public CarNode(Car car)
        {
        	this(car,null);
        }
        public CarNode(Car car,CarNode next)
        {
        	this.car=car;
        	this.next=next;
        }
    }
    
    package 实验2;
    
    //1,2,3,分别代表查询的位置,0是没问题
    public class CarPark 
    {
    	CarQueue pavement=new CarQueue();//便道(链式队列)
    	CarStack transitstation=new CarStack();//中转区(顺序栈)
    	CarStack parking=new CarStack();//停车场(顺序栈)
    	double price=3;//停车的单位时间费用为3元
    
    //停车场业务
    /**
    * 功能:汽车驶入。 将carNo车牌的汽车驶入,如果停车场有车位则进入停车场,设定入场时间,否则在便道等待进入
    * 参数:
    * 	carNo -- 车牌信息
    * 返回值:成功与否
    */
    	//当有车到达时,若停车场已满或便道上有等待车辆,则进入便道排队等待(入队)
    	public boolean arrival(String CarNum)
    	{
    		//创建一个对象代表刚进来的车
    		Car car=new Car();
    		//设置进来车辆的车牌号
    		car.setCarNum(CarNum);
    		
    		//先看看停车场有没有空位置,如果停车场没有位置了,那么这个车直接进入便道等候
    		if(parking.isFull())
    		{
    			pavement.offer(car);//刚来的车进去便道,要提示已经去了便道。
    			System.out.println("由于停车场已经满了,车牌号为"+CarNum+"的车辆已经进入便道等待。");
    		}
    		//如果还有停车位,还要再看看便道上有没有车在等待
    		else
    		{
    			//如果便道上还有其他车已经在等待,那么就便道上的车先进去停车,刚到的这个车要到便道上面等候
    			if(!pavement.isEmpty())
    			{
    				parking.push((Car) pavement.poll());//便道上的车进入停车场
    				pavement.offer(car);//刚来的车进入便道等候
    			}
    			//如果便道上是空的,那么这个车就可以直接进去停车场了
    			else
    			{
    			    car.setArriveTime(System.currentTimeMillis());//目标车辆进车库,需要记下它的时间
    			}
    		}
    		return parking.push(car);//刚来的车进去停车场,返回一个布尔型,验证它有没有成功进入车库
    	}
    /**
     * 功能: 骑车驶离。将carNo车牌的汽车驶离停车场,设定离开时间,同时便道汽车进入停车场
     * 参数:
    * 	carNo -- 车牌信息
     * 返回值:离开汽车
     */
    	//当停车场有车出场时,便道中排在最前的车辆先进入停车场(出队,并进栈)
    	public Car leave(String CarNum)
    	{
    		if(parking.isEmpty()) //如果车库是空的,就返回空值
    		{
    			return null;
    		}
    		//创建一个对象代表要出去的车,为空,最后赋值
    		Car leaveCar=null;
    
    		//先看看停车场是不是只有它自己一辆车,如果不止一辆车,在它之后进入的车辆必须先退出停车场为它让路,进入中转区
    		//如果停车场里面只有它自己一辆车,它就可以直接自己出来,并记录出来的时间
    		while(parking.length()>=1)
    		{
    			//创建对象代表退出停车场进入中转区的车
    			Car carTransform=(Car) parking.pop();
    			//用TransformNum来代表进去中转区的车的车牌号码
    			String TransformNum=carTransform.getCarNum();		    
                //判断正从停车场出来的车的车牌号是不是和要离开的车的车牌号一样,如果一样,这辆车就是目标出来车辆,要记录它离开的时间
    			if(TransformNum.equals(CarNum))
    			{
    				carTransform.setLeaveTime(System.currentTimeMillis());
    				leaveCar=carTransform;
    			}
    			//如果不一样,这个车不是目标车辆,不必记录时间,直接移到中转区就好
    			else
    			{
    				transitstation.push(carTransform);//从停车场出来的车进去中转区
    			}
    
    		}
    		//待目标辆车开出大门后,其他车辆再按原次序返回车场
    		while(!transitstation.isEmpty())
    		{
    			parking.push(transitstation.pop());//从中转区出来的车进去停车场
    		}
    	    return leaveCar;
    	}
    /**
     * 功能: 费用计算。根据车辆的出入时间,计算费用及停车时长
    * 参数:
    * 	car -- 车辆信息
    * 返回值:停车费用
     * @return 
     */
    	//车辆离开后,要计算它的停车费用
    	public double charging(Car car)
    	{	
    		return car.getTime()*price;
    	}
    	
    	// 显示所有入库车辆信息 
    	public void showPark()
    	{
    		if(parking.isEmpty())
    		{
    			//当停车场没有车辆在等的时候,就提示没有车子在停车场
    			System.out.println("停车场暂时没有停放车辆!");
    		}
    		//当停车场有车辆的时候,就输出它们的信息
    		else 
    		{
    			System.out.println("入场车辆的信息为:");
    			parking.display();
    		}
    	}
    
    	// 显示所有在便道上等待信息
        public void showWaiting()
        {
        	if(pavement.isEmpty())
        	{
           	 	//当便道上没有车辆在等的时候,就提示没有车子在等待
        		 	System.out.println("便道上暂时没有车辆在等待!");
        	}
        	else 
        	{
        		//当便道上有车辆在等待的时候,就输出它们的信息
    			System.out.println("正在便道上等待的车辆有:");
    			pavement.display();
        	}
        }
    	
    	//查找车辆是否在场
    	public void searchCar(String carNo)
    	{
    		int flagInParking = searchParking(carNo);//查找车在不在停车场
    		int flagInpavement = searchPavement(carNo);//查找车在不在便道
    		if (flagInParking == 1) 
    		{
    			System.out.println("车牌为" + carNo + "在停车场内。");
    		} 
    		else if (flagInpavement == 1) 
    		{
    			System.out.println("车牌为" + carNo + "在便道内。");
    		} 
    		else 
    		{
    			System.out.println("不好意思!找不到此车!");
    		}
    	}
    	
        //查找便道上的车辆
        public int searchPavement(String CarNum){
    		//停车场查找不到,就查找便道,查到了就提示该车辆在便道,并退出查找
    		CarQueue tmpQueue=new CarQueue();//中间队列,存放取出来的车
    		int flag=0;
    		while(!pavement.isEmpty())
    		{
    			//用searchPavement存放便道的车辆车牌号码
    			Car searchPavement=((Car) pavement.poll());
    			if(searchPavement.getCarNum().equals(CarNum))
    			{//在便道上查找到车辆
    				flag=1;
    			}
    			tmpQueue.offer(searchPavement);	//停进中间队列
    		}
    		while (!tmpQueue.isEmpty())//当中间队列不为空的时候,要把取出来的车子都放回去
    		{
    			pavement.offer((Car) tmpQueue.poll());
    		}
    		return flag;
    	}
       //查找停车场上的车辆
    	public int searchParking(String CarNum)
    	{
    		int flag=0;
    		//从停车场开始查找,查到了就提示该车辆在停车场,并退出查找
    		while(!parking.isEmpty())
    		{
    			//用searchPark存放刚刚从停车场中取出来的车辆
    			Car searchPark=parking.pop();
    			if(searchPark.getCarNum().equals(CarNum))
    			{
    				//车牌号是CarNum的车辆现在在停车场!
    				flag=1;
    			}
    			//取出来的车辆不是目标车辆,就把它先放进中转区里面
    			transitstation.push(searchPark);
    		}
    		while (!transitstation.isEmpty())
    		{//查找完毕,当中转区非空的时候,要把里面的车辆全都放回去停车场
    			parking.push(transitstation.pop());
    		}
    		return flag;
    	}
    
    	//离开便道,这个跟查询便道的方法一样,要先确定有没有这辆车
    	public Car leavepavement(String carNo)
    	{
    		Car leaveCar = null;	//用来指向我们想要离开的车辆
    		CarQueue searchQueue=new CarQueue();//建一个新的队列作为中间队列
    		while(!pavement.isEmpty())//如果便道不为空
    		{
    			Car pavementTopCar=(Car) pavement.poll();//便道上第一个车给取出来
    			if(carNo.equals(pavementTopCar.getCarNum()))//看看是不是目标车辆
    			{//如果是,就取出,并且提示已经离开了便道
    				leaveCar=pavementTopCar;
    				System.out.println("便道上车牌号为"+leaveCar.getCarNum()+"车辆已离开!");
    			}
    			else //如果不是目标车辆,就把它放进去中间队列里面
    			{
    				searchQueue.offer( pavementTopCar);
    			}
    
    		}
           //最后查找完毕,要把取出来放在中间队列里的车放回去便道
    		while (!searchQueue.isEmpty()){
    			pavement.offer((Car) searchQueue.poll());
    		}
    		return leaveCar;
    	}
    
    }
    
    package 实验2;
    
    
    //设计链队数据结构及其基本操作
    public class CarQueue {
    	private CarNode front;//队首指针
    	private CarNode rear;//队尾指针
    	//链队列类的构造函数
    	public CarQueue()
    	{
    		front=rear=null;
    	}
    	//队列置空
    	public void clear()
    	{
    		front=rear=null;
    	}
    	//车辆队列判空
    	public boolean isEmpty()
    	{
    		return front==null;
    	}
    	//求队列长度
    	public int length()
    	{
    		CarNode p=front;
    		int length=0;
    		while(p!=null)
    		{
    			p=p.next;//指针下移
    			++length;//计数器+1
    		}
    		return length;
    	}
    	//取出队首元素
    	public Object peek()
    	{
    		if(front!=null)//队列非空
    			return front.car;//返回队首结点的数据域值
    		else 
    			return null;
    	}
    	//车辆入队
    	public boolean offer(Car car)
    	{
    		CarNode p=new CarNode(car);//初始化新结点
    		if(front!=null)//队列非空
    		{
    			rear.next=p;
    			rear=p;//改变队尾位置
    		}
    		else
    		{
    			front=rear=p;
    		}
    	    return true;
    	}
    	//车辆出队
    	public Object poll()
    	{
    		if(front!=null)//队列非空
    		{
    			CarNode p=front;//p指向队首结点
    			front=front.next;//队首结点出列
    			if(p==rear)//被删除的结点是队尾结点时
    				rear=null;
    			return p.car;//返回队首结点的数据域值
    		}
    		else
    			return null;
    	}
    	//输出队列中的所有数据元素(从头到尾)
    	public void display()
    	{
    		CarNode p=front;
    		while(p!=null)
    		{
    			System.out.println(p.car+",");
    			p=p.next;
    		}
    	}
    }
    
    
    package 实验2;
    
    //设计顺序栈数据结构及其基本操作
    public class CarStack {
    	private Car[] Carstack;//对象数组
    	private int top;//在非空栈中,top始终指向栈顶元素的下一个存储位置栈
    	private static int MAXSIZE=3;
        //栈的构造函数,构造一个存储空间为MAXSIZE的空
    	public CarStack()
    	{
    		top=0;
    		Carstack = new Car[MAXSIZE];
    	}
    	//栈置空
    	public void clear()
    	{
    		top=0;
    	}
    	//判空
    	public boolean isEmpty()
    	{
    		return top==0;
    	}
    	//判满
    	public boolean isFull()
    	{
    		return top==MAXSIZE;
    	}
    	//求栈中元素的个数
    	public int length()
    	{
    		return top;
    	}
    	//取栈顶元素
    	public Object peek()
    	{
    		if(!isEmpty())
    			return Carstack[top-1];
    		else
    			return null;
    	}
    	//车辆进栈
    	public boolean push(Car car)
    	{
    		if(top >= MAXSIZE) 
    			return false;//车子没有成功停进停车场,返回false
    		else
    			Carstack[top++] = car;
    			return true;//车子成功停进停车场,返回true
    	}
    	//车辆出栈
    	public Car pop()
    	{
    		if(isEmpty())
    			return null;
    		else
    			return Carstack[--top];
    	}
    	//输出栈中的所有元素
        public void display()
        {
        	if(isEmpty())
        	{
        		System.out.println("停车场暂时没有车!");
        	}
        	else
        	{
        	for(int i=top-1;i>=0;i--)
        		System.out.println(Carstack[i].toString()+"  ");
        	}
        }
    }
    package 实验2;
    
    import java.text.DecimalFormat;
    import java.util.Scanner;
    
    public class Test 
    {
    	// 操作菜单
    	public static void menu()
    	{		
    		System.out.println("\n    §※§※§※§※§※§ 欢迎使用停车场系统.§※§※§※§※§※§\t\n");
    		System.out.println("\t※◎※◎※◎※◎  1. 车辆到达登记.※◎※◎※◎※◎\t");
    		System.out.println("\t※◎※◎※◎※◎  2. 车辆离开登记.※◎※◎※◎※◎\t");
    		System.out.println("\t※◎※◎※◎※◎  3. 显示车辆信息.※◎※◎※◎※◎\t");
    		System.out.println("\t※◎※◎※◎※◎  4. 退出系统※◎※◎※◎※◎\t");
    		System.out.println("\n\t请选择:\t");
    	}
    
    	
    	public static void main(String[] args)
    	{
    		CarPark carPark = new CarPark();
    		Scanner scanner = new Scanner(System.in);
    		String carNo;
    		while(true) {
    			menu();
    			int item = -1;
    			while (true) {
    				item = scanner.nextInt();
    				if(item>0 && item <5)
    					break;
    				System.out.println("\n 输入有误,请重新选择: 1~4: ");
    			}
    			switch(item)
    			{
    		    	//代号为1,//车辆到达登记,提示并输入车牌号并进场
    		    	case 1:
    		    		System.out.println("请输入车牌号码:");
    		    		carNo=scanner.next();//要先查找是不是已经有这辆车了,车牌号码不能重复
    					if (carPark.searchParking(carNo)!=1 && carPark.searchPavement(carNo)!=1)
    					{
    						if (carPark.arrival(carNo))
    						{
    							System.out.println("车牌号为"+carNo+"的车辆停车成功,现在已经进入停车场!");
    						}
    					}
    					else 
    					{
    						System.out.println("抱歉!该车辆已经存在了,请重新输入车牌号。");
    					}
    		    		break;
    		    	//代号为2,车辆离开登记,提示输入车牌号、输出停车时长以及费用
    		    	case 2:
    		    		System.out.println("请输入车牌号码:");
        				carNo=scanner.next();
        				if (carPark.searchParking(carNo)==1)//出来之前,要先看看车子有没有在停车场里面,如果在
        				{
    						Car car=carPark.leave(carNo);//接受返回值
    						long time = car.getTime();
    						DecimalFormat df = new DecimalFormat("#.00");
    						String fee = df.format(carPark.charging(car));
    						System.out.println("离开车辆的车牌号为:"+carNo);
    						System.out.println("该车到达时间为:"+car.Arrive+"  离开时间为:"+car.Leave+"  停车时长为:"+time+"  分钟,停车费用共计:"+fee+"元。");
    					}
        				else if (carPark.searchPavement(carNo)==1)//如果停车场上没有,就在便道上找,如果找到了这辆车
        				{//那么就把这辆车从便道上取出来,使它直接从便道上离开
    						Car car = carPark.leavepavement(carNo);
    					}
        				else //否则提示便道上也没有这辆车,那就提示没车
    					{
    						System.out.println("抱歉!停车场和便道内都没有找到车牌为" + carNo + "的车。");
    					}
    		    		break;
    		    	//代号为3,显示车辆信息
    		    	case 3:
    		    		carPark.showPark();
    		    		carPark.showWaiting();
    		    		break;
    		        //代号为4,退出系统
    		        case 4:
    		        	System.exit(0);
    		        //代号为5,查找车辆
    		        case 5:
    		        	System.out.println("请输入车牌号码:");
    		    		Scanner scanner3 = new Scanner(System.in);
    		    		carNo=scanner3.next();
    		        	carPark.searchCar(carNo);	
    		        	break;
    			}
    		}
    	}
    }
    
    
    package 实验2;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    //计时不会写,去CSDN找到了对应的写法,网址为:https://blog.csdn.net/ccyyll1/article/details/82775956
    public class Timeset 
    {
    	//获取时间戳
    	public static String getTimeStamp(long times) 
    	{
    	    Date date = new Date();
    	    times = date.getTime();
    	    return getFormatDate();
    	}
    	//获取格式化的时间
    	public static String getFormatDate()
    	{
    	    Date date = new Date();
    	    long times = date.getTime();//时间戳
    	    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	    String dateString = formatter.format(date);
    	    return dateString;
    	  }
    }
    

     

     运行结果:

    一枚平平无奇的初级小白!~

    欢迎互相交流学习!~

    展开全文
  • Java 停车场管理系统源码 + 数据库。 数据库:MySQL 语言:Java 功能:会员模块、查看咨询信息、违规车辆模块、查看车位信息、停车支付信息、退出系统 JAVA 毕业设计 管理系统 数据库
  • java智能停车场收费管理系统

    千次阅读 2020-10-13 14:53:58
    随着城市建设与经济的不断发展,城市车辆的数量也不断增涨,为解决停车问题修建停车场。基于经营、安全、管理等多角度的考虑,希望在目前传统的大型车库管理系统中有机地结合车牌识别技术,以求得日后在停车库运营时更...

    随着城市建设与经济的不断发展,城市车辆的数量也不断增涨,为解决停车问题修建停车场。基于经营、安全、管理等多角度的考虑,希望在目前传统的大型车库管理系统中有机地结合车牌识别技术,以求得日后在停车库运营时更安全、管理上更细致、经营中更灵活高效。本系统选用Windows作为服务器端的操作系统,开发语言选用java,数据库选用mysql,使用JDBC数据库连接技术,使用myeclipse作为系统应用程序的开发工具,Web服务器选用Tomcat7.0版本。

    1.用户管理模块:
    该模块包括车主管理和系统用户管理,系统用户主要是普通管理员,对用户信息进行管理,只有车主才可在该系统上进行相应的操作。用户对个人信息可进行修改;管理员可对自己的个人信息进行维护,同时可对用户的密码信息进行修改,也可删除系统中的用户。
    2.车辆驶入管理模块
    管理员选中某个车辆,点击添加驶入,填写驶入数据,点击添加按钮,完成车辆驶入操作,每次驶入,列表将生成新的驶入信息,供管理员管理。
    3.车辆驶出管理模块
    管理员选中某个已驶入的车辆,点击添加驶出,填写驶出数据,点击添加按钮,完成车辆驶出操作,每次驶出,列表将生成新的驶出信息,供管理员管理。
    4.车位信息管理模块
    车位信息管理模块主要实现了管理员可以在系统中添加车位信息,也可以修改系统中已有的车位信息,同时可查看车位信息和搜索车位信息;而用户只能查看车位信息和搜索车位信息。
    5.预约车位模块
    用户查询车位信息,选择车位进入该车位的详细页面,点击预约按钮,填写预约表单,添加预约记录。
    6.预约管理模块
    用户预约车位模块主要实现的是对车位的预约功能,同时可查看自己的预约记录,并对预约可进行取消预约操作。管理员登录系统后,可查看用户的预约信息,也可搜索预约信息,同时可对预约信息进行确认或删除的操作。
    7.系统管理模块
    系统管理模块供管理员使用,只要是一些系统信息的管理

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 停车场管理系统主要包括了管理员登录、车位信息管理、IC卡信息管理、固定车主信息管理、临时车辆管理、修改密码等功能模块组成。其中IC卡信息会用固定车主的信息进行绑定,临时车辆进入时需要领取临时的IC卡,来完成...
  • Java课程设计:停车场管理系统

    千次阅读 多人点赞 2020-02-26 22:35:49
    采用java技术和SQL Server 2017数据库开发出一个简单的基于Java技术的停车场管理系统,该系统有登录模块、车场管理模块、信息查询模块、信息维护模块、系统管理模块五大功能模块,每个模块实现不同功能。 SQL Server...
  • 停车场管理 1).有一个两层的停车场, 每层有6个车位, 当第一层车停满后才允许使用第二层. ( 停车场可用一个二维数组实现, 每个数组元素存放一个车牌号 ) 每辆车的信息包括车牌号, 层号, 车位号, 停车时间共4项. 其中...
  • 车辆越来越多的今天,停车场只靠人工管理显然难度已经是提高很多,所以应该开发出便于管理记录的停车场管理系统来帮助对停车场进行管理。 1.2 软件定义 一款帮助停车场管理员对车辆进出进行管理的软件。 1.3 开发...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,689
精华内容 675
关键字:

停车场信息管理系统java

java 订阅