java停车场代码 停车场系统java
用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://pwwzsj.com/article/hpcjho.html
