用JAVA怎么编写停车场管理系统源代码？

import java.text.SimpleDateFormat;

创新互联成立于2013年，先为大通等服务建站，大通等地企业，进行企业商务咨询服务。为大通企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

import java.util.Date;

import java.util.Scanner;

/*********************************

* 停车场管理

* author zhang

*2013-12-13

********************************/

public class CarStopManager {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请入车牌号:");

String carno = sc.next();

CarStopManager carStopManager = new CarStopManager();

carStopManager.setCarNo(carno);//设置车牌号

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String sdate = format.format(new Date());

System.out.println("当前时间（入场时间）是: "+sdate);

System.out.println("需要开出车场吗？yes/no:");

String yesno = sc.next();

if(yesno.equals("yes")){

String edate = format.format(new Date());

System.out.println("出场时间是: "+edate);

//计算方法

carManager(2, sdate, edate,carStopManager);

}

}

/**

* 计算方法

*/

public static void carManager(int type,String starTime,

String endTime,CarStopManager carStopManager){

if(type==1){//按月收费

System.out.println("如若没有缴纳月费请缴纳800元，如若缴纳将不再提示!");

}else{

/**

* 一般不会有停车几个月的吧？先不考虑停车几年或者几个月的

*/

String sDay = starTime.substring(8,10);//入场日期（天）

String sHour = starTime.substring(11, 13);//入场小时

String sMM = starTime.substring(14,16);//入场分钟

String eDay = starTime.substring(8,10);//出场日期（天）

String eHour = endTime.substring(11, 13);//出厂小时

String eMM = endTime.substring(14,16);//出厂分钟

float money = 0;//需缴纳的费用

int shour = Integer.parseInt(sHour);

int ehour = Integer.parseInt(eHour);

int smm = Integer.parseInt(sMM);

int emm = Integer.parseInt(eMM);

int rehour = 0;//停车几个小时

if(sDay.equals(eDay)){//同一天

//当天6点到20点之间

if((shour=6 shour=20)){

if(ehour - shour=6){//6个小时之内

rehour = (ehour - shour)*60+(emm - smm);//停车多少分钟

//需要缴纳的费用 前15分钟免费 以后每15分钟1.5元

money = (rehour/15-15)*1.5f;

}else{

int hour = ehour - shour -6;//6小时除外剩余小时数

rehour = 6*60+(emm - smm);//停车多少分钟

//前15分钟免费 以后每15分钟1.5元 超过6小时15分钟2元

money = ((rehour/15-15)*1.5f)+(hour*60/2);

}

}

}else{//跨天 20点到 6点之间

//todo

}

System.out.println("您的车牌号是:"+carStopManager.getCarNo()+";\n" +

"您此次停车花费的费用是: "+money+"元");

}

}

/**

* bean属性

*/

private String carNo;//车牌号

private String startTime;//入场时间

private String endTime;//出场时间

/**

* 无参构造

*/

public CarStopManager(){

super();

}

/**

* 有参数构造

* @param carNo

* @param startTime

* @param endTime

*/

public CarStopManager(String carNo, String startTime, String endTime) {

super();

this.carNo = carNo;

this.startTime = startTime;

this.endTime = endTime;

}

/**

* 设置get方法

* @return

*/

public String getCarNo() {

return carNo;

}

/**

* 设置set方法

* @param carNo

*/

public void setCarNo(String carNo) {

this.carNo = carNo;

}

public String getStartTime() {

return startTime;

}

public void setStartTime(String startTime) {

this.startTime = startTime;

}

public String getEndTime() {

return endTime;

}

public void setEndTime(String endTime) {

this.endTime = endTime;

}

}

数据结构 停车场管理 JAVA（急！！！）

import java.util.Arrays;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Scanner;

import java.util.Stack;

import java.util.Vector;

import java.util.regex.MatchResult;

public class Test {

private CarStop carStop = new CarStop(3);

private CarTunnel tunnel = new CarTunnel();

public void test(){

//存放车辆信息，因为不是顺序输入的，所以放到Map中

HashMapInteger, Car carMap = new HashMapInteger, Car();

//最早进入车库的时间和最晚出车库的时间

int startTime, endTime;

startTime = Integer.MAX_VALUE;

endTime = Integer.MIN_VALUE;

Scanner scanner = new Scanner(System.in);

//("A"或者"D"或者"E", int, int)

while(scanner.hasNext("\\((A|D|E),(\\d+),(\\d+)\\)")){

scanner.next("\\((A|D|E),(\\d+),(\\d+)\\)");

MatchResult r = scanner.match();

Car car;

//如果输入A

if (r.group(1).equalsIgnoreCase("A")){

// 该车已经记录过

if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){

// 取出来设置到达时间

car = carMap.get(Integer.parseInt(r.group(2)));

car.arrive = Integer.parseInt(r.group(3));

}else{

// 否则就记录该车

car = new Car(Integer.parseInt(r.group(2)), Integer.parseInt(r.group(3)));

carMap.put(car.no, car);

}

if (car.arrive startTime) startTime = car.arrive;

if (car.leave endTime) endTime = car.leave;

// 出库时间和到达时间同样处理

}else if (r.group(1).equalsIgnoreCase("D")){

if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){

car = carMap.get(Integer.parseInt(r.group(2)));

car.leave = Integer.parseInt(r.group(3));

}else{

car = new Car(Integer.parseInt(r.group(2)), 0, Integer.parseInt(r.group(3)));

carMap.put(car.no, car);

}

if (car.arrive startTime) startTime = car.arrive;

if (car.leave endTime) endTime = car.leave;

}else if (r.group(1).equalsIgnoreCase("E")){

break;

}

}

// 把记录过的车做成数组并且排序

Car[] cars = new Car[carMap.size()];

cars = carMap.values().toArray(cars);

Arrays.sort(cars, new ComparatorCar(){

// 排序顺序是到达时间出库时间车牌

public int compare(Car c1, Car c2) {

if (c1.arrive!=c2.arrive) return c1.arrive - c2.arrive;

if (c1.leave!=c2.leave) return c1.leave - c2.leave;

return c1.no - c2.no;

}

});

for (int time=startTime; time=endTime; time++){

System.out.println("TIME:" + time);

for (int k=0;kcars.length;k++){

Car car = cars[k];

//如果有车在没有进入停车场的时候就已经到了出库时间

if (car.leave == time carStop.isFull() !carStop.contains(car)){

for (int i=tunnel.size()-1;i=0;i--){

Car c = tunnel.get(i);

if (c.equals(car)){

for (int j=i+1;jtunnel.size();j++){

System.out.println(car + "为" + car + "让路，重新进入等待区");

}

tunnel.remove(car);

System.out.println(car + "没进入过停车场就离开了");

}else{

System.out.println(car + "为" + car + "让路");

}

}

}else{

// 如果有车子现在到达

if (car.arrive == time){

// 停车场不满

if (!carStop.isFull()) {

// 进入停车场

carStop.push(car);

// 开始计费

car.chargeStart = time;

System.out.println(car + "进入停车场并且开始计费");

}else{

// 停车场满，等待

System.out.println(car + "到达，在等待区等待");

tunnel.push(car);

}

}

}

}

//deal with cars in stop

//the case cars leave at same time is not included

// 按照后进先出的顺序看有没有车要离开

for (int k=carStop.size() - 1; k=0; k--){

Car car = carStop.elementAt(k);

//准备离开

if (car.leave == time){

Car otherCar;

// 所有在他后面进来的车准备让路

while ((otherCar = carStop.pop())!=car){

// 进入等待区的最前面

tunnel.unshift(otherCar);

System.out.println(otherCar + "准备为" + car + "让路");

}

for (int m=tunnel.size()-1;m=0;m--){

System.out.println(tunnel.elementAt(m) + "为" + car + "让路");

}

System.out.println(otherCar + "离开，停车时间:" + (otherCar.leave - otherCar.chargeStart));

for (int m=0; mtunnel.size(); m++){

System.out.println(tunnel.elementAt(m) + "让路完毕，重新进入等待区");

}

Car waitingCar;

//停车场有空位，等待序列最前面的车入库

while ( !carStop.isFull() (waitingCar = tunnel.shift())!=null ){

carStop.push(waitingCar);

// 停车计时开始

if (waitingCar.chargeStart == -1) {

System.out.println(waitingCar + "停车计时时间改为:" + time);

waitingCar.chargeStart = time;

}

System.out.println(waitingCar + "进入停车场");

}

}

}

}

}

public static void main(String[] args){

new Test().test();

}

}

@SuppressWarnings("serial")

class CarTunnel extends VectorCar{

public CarTunnel(){

super();

}

public Car shift(){

if (size() == 0) return null;

return remove(0);

}

public void unshift(Car car){

super.add(0, car);

}

public void push(Car car){

super.add(car);

}

public Car pop(){

if (size() == 0) return null;

return remove(size()-1);

}

}

@SuppressWarnings("serial")

class CarStop extends StackCar{

private int size;

public CarStop(int size){

this.size = size;

}

public boolean isFull(){

return size() == size;

}

public Car pop(){

return super.pop();

}

public Car push(Car car){

if (size() = size){

return super.push(car);

}else{

return null;

}

}

}

class Car{

public int no;

public int arrive;

public int leave;

public int chargeStart = -1;

public Car(int no, int timeIn, int timeOut){

this.no = no;

this.arrive = timeIn;

this.leave = timeOut;

}

public Car(int no, int timeIn){

this(no, timeIn, -1);

}

public String toString(){

return String.format("Car(%d)", no);

}

}

结果：

(A,6,31)

(A,5,30)

(A,4,20)

(A,3,16)

(A,2,15)

(A,1,10)

(D,1,50)

(D,2,30)

(D,3,31)

(D,4,25)

(D,5,32)

(D,6,40)

(E,0,0)

TIME:10

Car(1)进入停车场并且开始计费

TIME:11

TIME:12

TIME:13

TIME:14

TIME:15

Car(2)进入停车场并且开始计费

TIME:16

Car(3)进入停车场并且开始计费

TIME:17

TIME:18

TIME:19

TIME:20

Car(4)到达，在等待区等待

TIME:21

TIME:22

TIME:23

TIME:24

TIME:25

Car(4)没进入过停车场就离开了

TIME:26

TIME:27

TIME:28

TIME:29

TIME:30

Car(5)到达，在等待区等待

Car(3)准备为Car(2)让路

Car(5)为Car(2)让路

Car(3)为Car(2)让路

Car(2)离开，停车时间:15

Car(3)让路完毕，重新进入等待区

Car(5)让路完毕，重新进入等待区

Car(3)进入停车场

Car(5)停车计时时间改为:30

Car(5)进入停车场

TIME:31

Car(6)到达，在等待区等待

Car(5)准备为Car(3)让路

Car(6)为Car(3)让路

Car(5)为Car(3)让路

Car(3)离开，停车时间:15

Car(5)让路完毕，重新进入等待区

Car(6)让路完毕，重新进入等待区

Car(5)进入停车场

Car(6)停车计时时间改为:31

Car(6)进入停车场

TIME:32

Car(6)准备为Car(5)让路

Car(6)为Car(5)让路

Car(5)离开，停车时间:2

Car(6)让路完毕，重新进入等待区

Car(6)进入停车场

TIME:33

TIME:34

TIME:35

TIME:36

TIME:37

TIME:38

TIME:39

TIME:40

Car(6)离开，停车时间:9

TIME:41

TIME:42

TIME:43

TIME:44

TIME:45

TIME:46

TIME:47

TIME:48

TIME:49

TIME:50

Car(1)离开，停车时间:40

我想要一个停车场管理系统的JAVA源程序

#includestdio.h

#includestdlib.h

#includestring.h

#define MAX 3 // 停车场最大容量

#define price 5 //每小时5元

typedef struct time {

int hour;

int min;

} Time;// 定义时间结构体

typedef struct node {

char num[10];

Time reach;

Time leave;

} CarNode;// 定义车辆信息结构体

typedef struct NODE {

CarNode * stack[MAX + 1];

int top;

} SeqStackCar;

typedef struct car {

CarNode *data;

struct car *next;

} QueueNode;

typedef struct Node {

QueueNode *head;

QueueNode *rear;

} LinkQueueCar;

void InitStack(SeqStackCar *s) {

int i;

s-top = 0;

for (i = 0; i = MAX; i++)

s-stack[s-top] = NULL;

}// 栈的初始化

int InitQueue(LinkQueueCar *Q) {

Q-head = (QueueNode *) malloc(sizeof (QueueNode));

if (Q-head != NULL) {

Q-head-next = NULL;

Q-rear = Q-head;

return (1);

} else return (-1);

}// 队列的初始化

void PRINT(CarNode *p, int room) { // 车辆收费

int A1, A2, B1, B2;

printf("\n车辆离开的时间:");

scanf("%d:%d", (p-leave.hour), (p-leave.min));

printf("\n离开车辆的车牌号为:");

puts(p-num);

printf("\n其到达时间为: %d:%d", p-reach.hour, p-reach.min);

printf("\n离开时间为: %d:%d", p-leave.hour, p-leave.min);

A1 = p-reach.hour;

A2 = p-reach.min;

B1 = p-leave.hour;

B2 = p-leave.min;

printf("\n应交费用为: %2.1f元", ((B1 - A1)*60 + (B2 - A2)) * price);

free(p);

}

int Arrival(SeqStackCar *Enter, LinkQueueCar *W) {

CarNode *p;

QueueNode *t;

p = (CarNode *) malloc(sizeof (CarNode));

printf("\n请输入车牌号(例:豫B1234):");

scanf("%d",p-num);

if (Enter-top MAX) {

Enter-top++;

printf("\n车辆在车场第%d位置.", Enter-top);

printf("\n车辆到达时间:");

scanf("%d:%d", (p-reach.hour), (p-reach.min));

Enter-stack[Enter-top] = p;

return (1);

} else {

printf("\n该车须在便道等待!有车位时进入车场");

t = (QueueNode *) malloc(sizeof (QueueNode));

t-data = p;

t-next = NULL;

W-rear-next = t;

W-rear = t;

return (1);

}

}// 车辆的到达登记

void Leave(SeqStackCar *Enter, SeqStackCar *Temp, LinkQueueCar *W) { //车辆的离开

int room;

CarNode *p, *t;

QueueNode *q;

if (Enter-top 0) // 判断车场是否为空

{

while (1) {

printf("\n请输入车在车场的位置/1--%d/：", Enter-top);

scanf("%d", room);

if (room = 1 room = Enter-top) break;

else printf("\n 输入有误,请重输: ");

}

while (Enter-top room) // 把要删除的车辆的前面的车开出来，进临时栈。

{

Temp-top++;

Temp-stack[Temp-top] = Enter-stack[Enter-top];

Enter-stack[Enter-top] = NULL;

Enter-top--;

}

p = Enter-stack[Enter-top]; // 把要删除的车辆节点赋给p。

Enter-stack[Enter-top] = NULL;

Enter-top--;

while (Temp-top = 1) // 再把临时栈里德车辆进停车场

{

Enter-top++;

Enter-stack[Enter-top] = Temp-stack[Temp-top];

Temp-stack[Temp-top] = NULL;

Temp-top--;

}

PRINT(p, room); // 调用计费函数计费

if ((W-head != W-rear) Enter-top MAX) //如果便道上有车，则再开进停车场。

{

q = W-head-next;

t = q-data;

Enter-top++;

printf("\n便道的%s号车进入车场第%d位置.", t-num, Enter-top);

printf("\n请输入%s号车进入车场的时间:", t-num);

scanf("%d:%d", (t-reach.hour), (t-reach.min));

W-head-next = q-next;

if (q == W-rear) W-rear = W-head;

Enter-stack[Enter-top] = t;

free(q);

} else printf("\n便道里没有车.\n");

} else printf("\n车场里没有车.");

}

void List1(SeqStackCar *S){ int i;

if (S-top 0) {

printf("\n车场:");

printf("\n 位置 到达时间 车牌号\n");

for (i = 1; i = S-top; i++) {

printf(" %d ", i);

printf(" %d:%d ", S-stack[i]-reach.hour, S-stack[i]-reach.min);

puts(S-stack[i]-num);

}

} else printf("\n车场里没有车");

}//显示车场里的车辆情况

void List2(LinkQueueCar *W) {

QueueNode *p;

int i;

p = W-head-next;

if (W-head != W-rear) {

printf("\n等待车辆的号码为:");

for (i = 1; (p != NULL); i++) {

printf("\n第 %d 车辆.", i);

puts(p-data-num);

p = p-next;

}

} else printf("\n便道里没有车.");

printf("\n");

}//显示便道上的车辆情况

void List(SeqStackCar S, LinkQueueCar W) {

int flag, tag;

flag = 1;

while (flag) {

printf(" 查看车辆列表显示: ");

printf("\n 1.车场列表\n 2.便道列表\n 3.返回主菜单\n");

printf("\n请选择 1~3:");

while (1) {

scanf("%d", tag);

if (tag = 1 tag = 3) break;

else printf("\n 输入有误,请重新选择 1~3:");

}

switch (tag) {

case 1:List1(S);

break;

case 2:List2(W);

break;

case 3:flag = 0;

system("cls");

break;

default: break;

}

}

}//显示,遍历

int main() {

SeqStackCar Enter, Temp;

LinkQueueCar Wait;

int ch;

InitStack(Enter);

InitStack(Temp);

InitQueue(Wait);

while (1) {

printf("\n ############ 欢迎使用停车场系统.############\t\n\n");

printf("\n\t * 1. 车辆到达登记.\t\n");

printf("\n\t * 2. 车辆离开登记.\t\n");

printf("\n\t * 3. 车辆列表显示.\t\n");

printf("\n\t * 4. 退出系统.\t\n\n");

while (1) {

printf(" 请选择: ");

scanf("%d", ch);

if (ch = 1 ch = 4)break;

else printf("\n 输入有误，请重新选择： 1~4: ");

}

switch (ch) {

case 1:Arrival(Enter, Wait);

break;

case 2:Leave(Enter, Temp, Wait);

break;

case 3:List(Enter, Wait);

break;

case 4:exit(0);

default: break;

}

}

}// 自定义函数

java 编程，停车收费简易系统

代码如下,仅实现功能,未考虑安全等情况.

//ParkingTest.java

/**

* 停车程序入口.本示例为考虑数据安全等.仅作为示例,未经调试.

* @author menglg

*

*/

public class ParkingTest {

public static void main(String[] args) {

// 程序入口,可以安排停车出车

for (int i = 0; i  100; i++) {

if (ParkingManage.hasPosition()) {

ParkingManage.enterParking(i + "");

continue;

}

break;

}

for (int i = 0; i  100; i++) {

ParkingManage.outParking(i + "");

}

System.out.println(ParkingManage.totalCost());

}

}

//ParkingManage.java

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

public class ParkingManage {

private static ListParking parkings = new ArrayList();

private static final int maxNumber = 100;

private static int currentNumber;

public static void enterParking(String lpn) {

if (lpn == null || lpn.length() == 0) {

return;

}

Parking p = new Parking(lpn);

p.setEnterDate(new Date());

parkings.add(p);

}

public static void outParking(String lpn) {

if (lpn == null || lpn.length() == 0) {

return;

}

for (Parking p : parkings) {

if (!lpn.equals(p.getLpn()))

continue;

Date now = new Date();

p.setOutDate(now);

parkings.remove(p);

currentNumber += p.getCost();

break;

}

}

public static int totalCost() {

return currentNumber;

}

public static boolean hasPosition() {

return parkings.size()  maxNumber;

}

}

//Parking.java

import java.util.Date;

public class Parking {

private String lpn;

private Date enterDate;

private Date outDate;

private int cost;

public Parking(String lpn) {

this.lpn = lpn;

}

public String getLpn() {

return lpn;

}

public Date getEnterDate() {

return enterDate;

}

public Date getOutDate() {

return outDate;

}

public int getCost() {

if(outDate == null || enterDate == null){

return 0;

}

//停车时间,单位毫秒

long time = outDate.getTime() - enterDate.getTime();

long hour = 60*60*1000;

if(time  hour){

cost = 3;

}else if(time%hour == 0){

cost = (int)(time/hour * 2);

}else{

cost = (int)((time/hour+1) * 2);

}

return cost;

}

public void setLpn(String lpn) {

this.lpn = lpn;

}

public void setEnterDate(Date enterDate) {

this.enterDate = enterDate;

}

public void setOutDate(Date outDate) {

this.outDate = outDate;

}

public void setCost(int cost) {

this.cost = cost;

}

}

新闻标题：java停车场代码 停车场系统java
文章链接：http://scpingwu.com/article/hpcjho.html