精华内容
下载资源
问答
  • 最新精选优秀文档值得下载 java停车场管理系统 本程序为word格式下载后可修改编辑 版面已排好可直接下载使用 最新精选优秀文档值得下载 import java.io; public class Method { private int intinput) throws ...
  • Java 停车场管理系统

    2018-08-11 09:02:36
    Java 停车场管理系统 简单的java项目,内有数据库脚本,能完美的运行,网页比较漂亮
  • java智能停车场收费管理系统

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

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

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

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

    展开全文
  • 智能停车场收费系统设计源码

    热门讨论 2013-04-21 20:45:06
    java语言实现的智能停车场收费系统,该设计获得优秀毕业论文,论文可以参考我的资源“智能停车场收费系统设计”,该系统是一个图形化的界面系统,数据存储用的是SQLserver2005数据库,可以直接在界面上操作,界面...
  • 停车场收费管理系统是伴随着公用收费停车场这一新生事物而诞生的。 目前的多数停车场存在着以下几个问题,管理漏洞、系统的可靠性、独立性强、收费 过程比较繁琐、劳动强度高、停车场利用率低下、票款易流失等。针对...
  • 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实现停车场管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 停车场收费管理系统

    2019-01-22 15:09:32
    停车场收费管理系统便于停车场对车辆进行管理,本系统主要包括会员注册,车辆出入库管理,会员查询等,采用序列化方式无需数据库。 注意事项: 1.开发环境为Visual Studio 2012,无数据库,使用.net 3.5开发
  • 内容描述 设有一个可停放 N 辆汽车的狭长停车场 , 只有一个大门供车辆出入 。车辆按到达先后顺序依次从最里面...停在便道上的车辆不收费 ,在便道上某辆汽车进入停车场或离去后 ,其余车辆仍然保持原来次序。 输入 汽

    内容描述

    设有一个可停放 N 辆汽车的狭长停车场 , 只有一个大门供车辆出入 。车辆按到达先后顺序依次从最里面向大门口停放 。如果已放满 N 辆车 , 再来的车辆只能在大门外的便道上等待 一旦有车辆从停车场离开排在便道上的车辆可依次进入停车场 。
    停车场中某辆车离开时 ,在它之后进入停车场的车辆必须为它让路退出停车场 ,等该车辆离开后其后车辆依原次序进入停车场 ,每辆汽车在离开时 ,都要依据停留时间交费 ;停在便道上的车辆不收费 ,在便道上某辆汽车进入停车场或离去后 ,其余车辆仍然保持原来次序。

    输入

    汽车的模拟输入信息格式可以是 : ( 到达 / 离去的标识 , 汽车牌照号码 , 到达 / 离去的时刻) 。 例如 , ( ‘A’,1,5 ) 表示 1 号牌照汽车在时刻 5 到达 , 而 ( ‘D’,5,20 ) 表示 5 号牌照汽车在时刻 20 离去 。 整个程序在输入信息 (‘E’,0,0 ) 时结束 。

    输出

    要求程序输出每辆车到达后的 停车位置( 停车场或便道上 ) , 以及某辆车离开停车场时应交纳的费用和在停车场内停留的时间

    运行结果

    在这里插入图片描述

    思路

    1. 首先我们先阅读一下内容要求,重点是一个狭窄的停车场,而且按照进来顺序停放,车辆离开的时候需要后面的车让路离开停车场再停进来,我们显然可以判断这是一个链式存储结构,我们可以用单链表来表示停车场。
    2. 我们再看便道,重点是一头进另一头出,我们可以想到便道则是顺序结构——队列。
    3. 要求中还说了记录时间,我们可以用hashmap,用键值对的形式记录对应的车牌号跟时间。
    4. 还要考虑以下几种情况
      当停车场没停满时: 到达的车直接开进停车场;离开的车直接退出停车场。
      当停车场停满时:
      ①便道有车,到达的车停进便道队尾;离开的车离开停车场,便道在队首的车开进停车场。
      ②便道无车,到达的车直接停到便道队首;离开的车直接退出停车场。

    定义我们要使用的数据结构

    定义单链表

    需要用到的函数

    添加:add(int data)

    遍历:traverseList()
    删除:deleteNode(int data)
    长度:size()
    是否为空:isEmpty()

    class LinkedList {
        private Node first;//定义头节点
        private int nItems;//定义单链表中实际的数据的数目
    
    
        /**
         * 初始化
         */
        public LinkedList() {
            this.first = null;
            this.nItems = 0;
        }
    
        /**
         * 添加头节点
         * @param data
         */
        public void addFirst(int data) {
            //新建节点
            Node newNode = new Node(data);
            //将新节点的下一个节点指向旧的头节点
            newNode.next = first;
            //将新节点设为头节点
            first = newNode;
    
            nItems ++;
        }
    
    
        /**
         * 删除头结点
         * @return
         */
        public boolean deleteFirst() {
            //判断链表是否为空
            if(isEmpty()) {
                System.out.println("链表为空!");
                return false;
            }
            first = first.next;
            nItems --;
            return true;
        }
    
    
        /**
         * 插入
         * @param data
         */
        public void add(int data) {
            //创建新节点
            Node newNode = new Node(data);
            //创建要插入节点的位置上原来的节点
            Node current = first;
            //原来位置为新插入节点
            first = newNode;
            //新插入节点的下一个为原节点
            newNode.next = current;
            nItems ++;
        }
    
        /**
         * 有序链表的插入,这样简单排序就可以用链表来实现,复杂度为O(N)
         * @param data
         */
        public void add2(int data) {
            //创建新节点
            Node newNode = new Node(data);
            //创建要插入节点之前的节点
            Node previous = null;
            //创建要插入节点的位置上原来的节点
            Node current = first;
            //按从小到大的顺序排序
            while(current != null && data > current.data) {
                previous = current;
                current = current.next;
            }
             if(previous == null) {
            first = newNode;
            }else {
                previous.next = newNode;
            }
            newNode.next = current;
            nItems ++;
        }
    
        /**
         * 查询某个特定值的节点
         * @param data
         * @return
         */
        public Node findNode(int data) {
            //定义一个新节点用于查询
            Node current = first;
            while(current != null && current.data != data) {
                if(current.next == null) {
                    System.out.println("该节点不存在");
                    return null;
                }
                current = current.next;
            }
            return current;
        }
    
    
        /**
         * 删除某个特定值的节点,并返回该节点
         * @param data
         * @return 删除的节点
         */
        public Node deleteNode(int data) {
            //定义被删除节点之前的节点
            Node previous = null;
            //定义被删除的节点
            Node current = first;
            while(current != null && current.data != data) {
                if(current.next == null) {
                    System.out.println("该节点不存在");
                    return null;
                }
                previous = current;
                current = current.next;
            }
            if(previous == null) {
                first = first.next;
            }else {
                previous.next = current.next;
            }
            nItems --;
            return current;
        }
    
    
        /**
         * 遍历链表
         */
        public void traverseList() {
            //定义一个节点用于遍历
            Node current = first;
            //判断链表是否为空
            if(current == null) {
                System.out.println("链表为空!");
                return;
            }
            while(current != null) {
                System.out.println(current.data);
                current = current.next;
            }
        }
    
        /**
         *
         * @return 链表的长度
         */
        public int size() {
            return nItems;
        }
    
    
        /**
         * 判断链表是否为空
         * @return
         */
        public boolean isEmpty() {
            return first == null;
        }
    
    }
    

    定义节点

    class Node{
    
        //指向下一个节点
        public Node next;
        //数据域
        public int data;
    
        public Node(int data) {
            this.data = data;
        }
    }
    

    定义队列

    需要用到的函数

    添加:insert(int g)
    删除:remove()

    class Queue {
    
        private int[] queArray;
        private int maxSize;
        private int front;  //队头
        private int rear;	//队尾
        private int nItems;
        /**
         * 初始化
         */
        public Queue(int maxSize) {
            this.maxSize = maxSize;
            queArray = new int[maxSize];
            front = 0;
            rear = 0;
            nItems = 0;
        }
    
    
    
        /**
         * 在队尾插入
         * @param g
         */
        public void insert(int g) {
            if (rear == maxSize-1) {
                rear = -1;
            }//
    
            queArray[++rear] = g;
            nItems++;
        }
    
    
        /**
         * 从队头删除
         */
        public void remove() {
            int temp = queArray[front++];
            if (front==maxSize) {
                front = 0;
            }
            nItems--;
    
        }
    
    
        /**
         * 查看
         * @return 查看的元素
         */
        public int peekFront() {
           // System.out.println(queArray[front]);
            return queArray[front];
        }
    
    
        /**
         * 判断是否为空
         * @return
         */
        public boolean isEmpty() {
            return nItems == 0;
        }
    
    
        /**
         * 判断是否已经满了
         * @return
         */
        public boolean isFull() {
            return nItems == maxSize;
        }
    
    
        /**
         *
         * @return 队列的大小
         */
        public int size() {
            return nItems;
        }
    
    }
    

    代码实现

    public static void main(String[] args) {
            //用队列创建便道,设置能停放9999辆车
            Queue queue=new Queue(99999999);
            //用单链表创建停车场
            LinkedList linkedList=new LinkedList();
            //用hashmap记录时间
            HashMap<Integer,Integer> hashMap=new HashMap<>();
            Scanner scanner=new Scanner(System.in);
            while (true){
              System.out.println("请输入操作A或者D(到达或离开),再输入车牌号,再输入时间");
              String s= scanner.next();
              if (s.equals("end")){
                 break;
              }
                /**
                 * 车到达
                 */
              if (s.equals("A")) {
                  //当停车场没停满时
                  if (linkedList.size() < 2) {
                        //车牌号
                        int n = scanner.nextInt();
                        //时间
                        int t = scanner.nextInt();
                        //进入停车场
                        linkedList.add(n);
                        //记录时间
                        hashMap.put(n, t);
                        System.out.println("车牌号为"+n+"已到达停车场");
                        continue;
                  }
                  //停车场满了,需要停便道上
                  else {
                        //车牌号
                        int n = scanner.nextInt();
                        //时间
                        int t = scanner.nextInt();
                        //停进便道
                        queue.insert(n);
                        System.out.println("车牌号为"+n+"已到达便道");
                        //这里不需要记录时间
                    }
                  }
                /**
                 * 车离开
                 */
              if (s.equals("D")) {
                  //停车场没满
                    if (linkedList.size() < 2) {
                        //车牌号
                        int n = scanner.nextInt();
                        //离开时间
                        int t = scanner.nextInt();
                        //这辆车的开始时间
                        int starttime = hashMap.get(n);
                        //开走
                        linkedList.deleteNode(n);
                        System.out.println("车牌号为" + n + "的停车时间" + (  t-starttime));
    
                    }
                    //停车场满了
                    else {
                        //车牌号
                        int n = scanner.nextInt();
                        //离开时间
                        int t = scanner.nextInt();
                        //这辆车的开始时间
                        int starttime = hashMap.get(n);
                        //开走
                        linkedList.deleteNode(n);
                        //停车场车开走
                        System.out.println("车牌号为" + n + "的停车时间" + (  t-starttime));
                        //如果便道空了,就没有车从便道开进停车场
                        if (!queue.isEmpty()){
                        //便道车开走
                        queue.remove();
                        //获得车牌号
                        int car=queue.peekFront();
                        System.out.println(car+"从便道开进停车场");
                        //进停车场
                        linkedList.add(car);
                        //记录进停车场时间
                        hashMap.put(car,t);
                    }}
                }
            }}
      }
    
    展开全文
  • 某酒店拟对自己停车场内的车辆进行管理,请编程实现“酒店停车场车辆管理系统”,具体要求: 1)基本信息管理:统计停车场内车位数量,每进入停车场一辆汽车,空车位数量减一;每离开一辆车辆,空车位数量加一。当空...

    某酒店拟对自己停车场内的车辆进行管理,请编程实现“酒店停车场车辆管理系统”,具体要求:
    1)基本信息管理:统计停车场内车位数量,每进入停车场一辆汽车,空车位数量减一;每离开一辆车辆,空车位数量加一。当空车位数量为0时,不允许车辆进入该停车场;车辆信息管理,主要包括车牌号,进入时间,状态(停车中,已离开),离开时间,停车费用。实现这些信息的增加和查询操作。
    2)收费管理:
    白天收费时间及收费标准:7:00am----6:00pm,每小时停车费2元,不足一小时按照一小时收费。
    夜间收费时间及收费标准:6:00pm----7:00am,每小时停车费2元;如果车主打算停车至第二天7:00am,则一共收费5元。

    题目要求如上,简单实现就好,不需要复杂代码。代价可私

    展开全文
  • 停车场收费系统 一个基于ssm框架的小系统 后端:使用了spring、springMVC、Mybatis 前端:使用了Bootstrap、jQuery、UmEditer 使用mysql数据库,IntellJ idea编辑器 前端页面全部为自己设计的,使用了一些H5的元素,...
  • JAVA项目中正号需要一个停车收费系统,就整理出来java实现的一个简单的停车收费系统给大家分享一下,希望对大家有所帮助
  • java写的停车场管理系统,只要运用swing 初始化停车场(确定停车区个数n,每个停车区的停车位,且初始时,停车场为空),说明:使用一个共享数组(临界资源)存储每个停车区中空闲停车位的个数,每一个停车区使用...
  • 停车场管理 1.一个停车场,内有多个车位,可停入各种车辆 2.只有具备车牌并高度低于3米的车辆可停入 3.停入时开始计费,按每小时2元 4.查询全部停车位的状态 5.按车牌及停车位号取车,取车时收停车费 6.查询统计全部...
  • 系统带文档lw万字以上+答辩PPT+查重 如果这个题目不合适,可以去我上传的...停车场收费管理系统的结构图4-1所示: 图4-1 系统结构 登录系统结构图,如图4-2所示: 图4-2 登录结构图 管理员结构图,如图4-3所示。
  • 停车场管理系统_java

    热门讨论 2011-09-09 22:51:24
    运用java语言编写 模仿停车场的日常运作 包括停车时间 存放时间 离开时间 收费 全天统计信息 全天的收益
  • 采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析,得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
  • 停车场管理系统的设计与实现是通过停车场的对于固定车主、临时车辆的停车需求而设计的。系统采用Java开发语言,MySQL数据库来实现对系统信息化的设计与实现。停车场管理系统主要包括了管理员登录、车位信息管理、IC...
  • 停车场管理 1).有一个两层的停车场, 每层有6个车位, 当第一层车停满后才允许使用第二层. ( 停车场可用一个二维数组实现, 每个数组元素存放一个车牌号 ) 每辆车的信息包括车牌号, 层号, 车位号, 停车时间共4项. 其中...
  • 车辆越来越多的今天,停车场只靠人工管理显然难度已经是提高很多,所以应该开发出便于管理记录的停车场管理系统来帮助对停车场进行管理。 1.2 软件定义 一款帮助停车场管理员对车辆进出进行管理的软件。 1.3 开发...
  • 学习基于腾讯人工智能(AI)的车牌识别技术,使用车牌识别技术实现一个完整的停车场管理系统,项目包括网页调用摄像头拍照,车牌拍照识别,上传车牌图片识别,用户管理,车辆管理(临时车与包月车),车辆出场,入场...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 641
精华内容 256
关键字:

java停车场收费系统

java 订阅