**
java版停车场管理系统
**
项目要求:需要使用栈和队列两种数据结构。其中栈用于停车场和中转区，队列用于便道，对应的类名分别为：CarStack和CarQueue。CarStack为顺序栈，CarQueue为链队列，队列中的结点为CarNode类。Car类为车辆信息类，记录了车辆的车牌，到达时间和离开时间等信息。
这个系统,为了方便测试,写了一个随机随机四辆车进入系统[因为停车场只能停3辆车]
- 实现CarStack
public class CarStack<T> {
//链表实现栈的操作
//创建top节点
CarNode<T> top;
int count=0;
//进栈
public void push(T data) {
CarNode<T> carNode =new CarNode<>(data);
if (top != null) {
carNode.next = top;
}
top= carNode;
count++;
}
//判断是否为空栈
public boolean isEmpty() {
return top==null;
}
//看栈顶
public T getTop() {
if (!isEmpty()) {
return top.data;
}
return null;
}
//取栈顶
public T pop() {
if (isEmpty()) {
throw new RuntimeException("此栈为空!");
}
T data= top.data;
top=top.next;
count--;
return data;
}
//判满
public boolean isFull(){
// 最大容量为3辆，便于观察
int MAXSIZE = 3;
return count == MAXSIZE;
}
public int getCount(){
return count;
}
}
- 实现CarQueue
public class CarQueue<T> {
public CarNode<T> head=new CarNode<>();
public CarNode<T> tail=head;
public int size=0;
/**
* 链尾入队
* @param data
*/
public void enQueue(T data){
CarNode<T> newNode = new CarNode<>(data);
tail.setNext(newNode);
tail=newNode;
size++;
}
/**
* 链头出队
* @return
*/
public T outQueue(){
if (size!=0){
CarNode<T> outQueueNode = head.getNext();
T data=outQueueNode.getData();
head.setNext(outQueueNode.getNext());
size--;
if (size==0){
tail=head;
}
return data;
}
else {
return null;
}
}
public boolean isEmpty(){
return size==0;
}
//遍历队列并输出
public<T> void Cir(){
CarNode<T> p= (CarNode<T>) head.next;
while (p!=null){
System.out.print(p.data+",");
p=p.next;
}
}
}
- CarNode(实现上述两个数据结构所需要的节点)
public class CarNode<T>{
public T data;
public CarNode<T> next = null;
public CarNode(T data) {
this.data = data;
}
public CarNode() {
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public CarNode<T> getNext() {
return next;
}
public void setNext(CarNode<T> next) {
this.next = next;
}
}
- 实现Car类(车辆的属性)
//汽车类
public class Car<T> extends CarNode {
public String carNo; // 车牌号
public String arrive; // 到达
public String leave; // 离开
public long arriveTime; //到达时间
public long leaveTime; //离开时间
//停车进来
public Car(long arriveTime,String carNo)
{
this.arriveTime=arriveTime;
arrive= timeUtils.getTimeStamp(arriveTime); //通过时间戳获取时间
this.carNo=carNo;
}
public int getTime(){
return (int)(leaveTime-arriveTime)/60000;
}
public void setLeaveTime(long leaveTime){
this.leaveTime=leaveTime;
leave= timeUtils.getTimeStamp(leaveTime);
}
public String getCarNo() {
return carNo;
}
public String getArrive() {
return arrive;
}
public String getLeave() {
return leave;
}
@Override
public String toString() {
return "Car{" +
"carNo='" + carNo + '\'' +
", arrive='" + arrive + '\'' +
", leave='" + leave + '\'' +
'}';
}
}
- 计时器(用来计费)
public class timeUtils {
/**
* date转String
* @param time 日期对象
* @return String日期
*/
public static String getTimeStamp(long time){ //时间戳
Date date = new Date(time);
return getDateString(date);
}
public static String getDateString(Date date) { //格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(date);
}
}
- 输入车辆的方法
public class inputCar {
//获取车辆信息的,返回一个带有到达时间,跟车牌参数的对象
public static Car getCar(String carNo){
return new Car(System.currentTimeMillis(),carNo);
}
}
- 停车场的一些常用方法
public class CarPark<T> {
int maxPark=3; //最大停车为3
CarQueue<T> sideWalk=new CarQueue<>(); //便道
CarStack<T> transitArea=new CarStack<>(); //中转区
CarStack<T> parking=new CarStack<>(); //停车场
long price=20; //停车费
/**
* 功能： 将carNo车牌的汽车驶离停车场，设定离开时间，同时便道汽车进入停车场
* 参数：
* carNo -- 车牌信息
* 返回值：离开汽车
*/
public Car<T> leave(String carNo) {
// TODO Auto-generated method stub
Car<T> leaveCar = null; //用来指向我们想要离开的车辆
// 当停车场内某辆车要离开时，在它之后进入的车辆必须先退出停车场为它让路，待该辆车开出大门后，其他车辆再按原次序返回车场。
while (!parking.isEmpty()){
Car<T> topCar= (Car<T>) parking.pop();
if (carNo.equals(topCar.getCarNo())){
//判断是不是我们要离开的那辆车,是的话,就离开,不是就进去中转区
topCar.setLeaveTime(System.currentTimeMillis());
leaveCar=topCar;
}else {
//让离开停车场的车后面的车进入中转区
transitArea.push((T) topCar);
}
}
//把中转区的车停进去
transitAreaToParking();
parking.push(sideWalk.outQueue()); //把队列里面第一辆车停入
showWaiting();
System.out.println();
return leaveCar;
}
// 显示所有在便道上等待信息
public void showWaiting() {
// TODO Auto-generated method stub
if (sideWalk.isEmpty()) {
System.out.println("The sidewalk is empty");
}
else {
System.out.print("waiting:");
sideWalk.Cir();
}
}
// 显示所有入库车辆信息
public void showPark() {
// TODO Auto-generated method stub
if (parking.isEmpty()){
System.out.println("Parking is empty");
}
while (!parking.isEmpty()){
Car<T> topCar= (Car<T>) parking.pop();
System.out.println("Parking:"+topCar);
transitArea.push((T) topCar);
}
//把中转区的车停进去
transitAreaToParking();
}
/**
* 功能： 将carNo车牌的汽车驶入，如果停车场有车位则进入停车场，设定入场时间，否则在便道等待进入
* 参数：
* carNo -- 车牌信息
* 返回值：
*/
public void arrival(String carNo) {
// TODO Auto-generated method stub
Car car = inputCar.getCar(carNo); //获取车的信息
if (parking.getCount() < maxPark) { //如果停车场内没有满
if (sideWalk.isEmpty()) { //便道上没车在等候
parking.push((T) car); //就直接进入停车场
System.out.println("车辆"+car.getCarNo()+"已到达");
} else { //如果便道上有车等候
parking.push(sideWalk.outQueue()); //就把便道上等候的车停进去
sideWalk.enQueue((T) car); //然后把刚刚获取的车放入便道
}
}
else {
System.out.print("停车场满了，"+car.getCarNo()+"请在便道等候"+"\t");
sideWalk.enQueue((T) car); //如果停车场满了,就直接进入便道
}
}
/**
* 功能:查找车辆是否存在
* @param carNo
*/
public void searchCar(String carNo) {
int flagInParking = searchInParking(carNo);
int flagInSidewalk = searchInSidewalk(carNo);
if (flagInParking == 1) {
System.out.println("车牌为" + carNo + "在停车场内");
} else if (flagInSidewalk == 1) {
System.out.println("车牌为" + carNo + "在便道内");
} else {
System.out.println("查无此车");
}
}
//查找停车场
public int searchInParking(String carNo){
int flag=0; //哨子,查到了就变为1
while (!parking.isEmpty()){
Car<T> topCar= (Car<T>) parking.pop();
if (topCar.getCarNo().equals(carNo)){
flag=1;
}
transitArea.push((T) topCar); //把车辆一辆一辆拿出来,直到找到为止
}
//把中转区的车辆停进去
transitAreaToParking();
return flag;
}
//查找便道
public int searchInSidewalk(String carNo){
int flag=0; //哨子
CarQueue<T> searchQueue=new CarQueue<>(); //创建一个查询队列,类似中转区
while (!sideWalk.isEmpty()){
Car<T> topCar= (Car<T>) sideWalk.outQueue();
if (topCar.getCarNo().equals(carNo)){ //找到车辆,哨子变为1
flag=1;
}
searchQueue.enQueue((T) topCar); //把车拿出来后放进查询队列
}
// 把查询队列里的车放回去
while (!searchQueue.isEmpty()){
sideWalk.enQueue(searchQueue.outQueue());
}
return flag;
}
/**
* 功能： 根据车辆的出入时间，计算费用及停车时长
* 参数：
* car -- 车辆信息
* 返回值：停车费用
*/
public double charging(Car car) {
return car.getTime()*price;
}
//把中转区的车辆停进去
public void transitAreaToParking(){
while (!transitArea.isEmpty())
{
parking.push(transitArea.pop());
}
}
}
- 测试类
import java.text.DecimalFormat;
import java.util.Random;
import java.util.Scanner;
import tools.Car;
import tools.CarPark;
public class test {
// 操作菜单
public static void menu() {
System.out.println("\n §※§※§※§※§※§ Welcom Into The Parking System.§※§※§※§※§※§\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("\t※◎※◎※◎※◎ 5. 随机向停车场内停入三辆车,便道上也停一辆.※◎※◎※◎※◎\t");
System.out.println("\t※◎※◎※◎※◎ 6. 退出系统.※◎※◎※◎※◎\t");
System.out.println("\n\t请选择：\t");
}
//随机出现4辆车
public static String randomCarNo() {
int count=4;
Random ra=new Random();
int num = 0;
String carNoPre="粤";
char carNoChar = 0;
for(int i=0;i<26;i++) {
carNoChar=(char) (ra.nextInt(26)+65);
}
for(int i=0;i<=count;i++) {
num=ra.nextInt(99999)+10000;
}
String carNo=carNoPre+carNoChar+num;
return carNo;
}
//主函数
public static void main(String[] args) throws InterruptedException {
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 <7)
break;
System.out.println("\n 输入有误，请重新选择： 1~5: ");
}
switch(item) {
case 1:
System.out.println("请输入车牌号：");
carNo = scanner.next();
if (carPark.searchInParking(carNo)!=1){
carPark.arrival(carNo);
}else {
System.out.println("车辆已存在");
}
break;
case 2:
System.out.println("请输入车牌号：");
carNo = scanner.next();
if (carPark.searchInParking(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+"停车时长"+time+"分钟，共收费"+fee+"元。");
}
else {
System.out.println("停车场内没有车牌为" + carNo + "的车");
}
break;
case 3:
carPark.showPark();
carPark.showWaiting();
break;
case 4:
System.out.println("请输入车牌号：");
carNo = scanner.next();
carPark.searchCar(carNo);
break;
case 5:
for(int i=0;i<=4;i++) {
if (carPark.searchInParking(randomCarNo())!=1){
carPark.arrival(randomCarNo());
Thread.sleep(1000); //每隔1秒停入一辆车
}else {
System.out.println("车辆已存在");
}
}
break;
case 6:
System.exit(0);
}
}
}
}
写在最后:这个系统本来用c语言去写会方便一些,但java版的csdn上不常见.这个系统还是有一些不太完善的.有什么不懂的或者有什么建议,可以评论或私我询问.本人纯小白,欢迎各位大佬指正.
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
