Java实现两户电梯运行（半成品）
作者：互联网
目的与结果：
居住的楼层是一层二户电梯，每次上下电梯我就在思量这电梯的具体运行逻辑，以及两台电梯如何交互实现运行的。就想着闲了没事稍微写出来一个类似的，就趁着最近项目上线前主要是测试bug，修改bug,挺清闲的就开始着手设计，果然设想是独立别墅，成品是茅草土屋，开始还干劲十足，后面因为停了一个星期，再看自己写的代码，纵然都有注释，还是食之无味，没了开始的干劲，最后模拟电梯运行也是草草结束。
这个示例就是一个控制台的小demo，虽然自己报着有始有终的态度粗糙完成，但是选择了指定电梯，电梯上行到达指定的楼层与电梯下行还是有待优化。比如：当前4层要下楼，6层也要下楼，9层也要下楼，电梯该如何进行，这些在设计实体类的时候我是有考虑的，也涉及了，但是自己实在是懒得操作了，有待有兴趣的小伙伴可以完善。
需求讲解
- 两步电梯，共用上行，下行按钮。
- 电梯运行基本原则是同等条件下右侧电梯优先运行。
- 两步电梯具体的运行的可能组合由于随便写在A4纸上，也丢掉了，具体的大家可以观察生活中的二步电梯组合的楼层，自己分析一下。
- 通过分析可得 每步电梯都要有：运行方向，运行状态，内部开关，目标楼层，当前楼层，且都是全局共享的；每层用户都有：上行按钮，下行按钮，所在楼层数。（ps: 本人懒省事定义到一个实体中）
- 电梯每到一层目标楼层，会有短暂的“休息”时间，门关上后一秒进入“运行”状态，此时再点击上行，下行按钮则无法开门。
- 每步电梯有最高层，最低层原则，即当一步电梯运行的方向相同时，更高层，或更底层有需求，则优先到达最高层，或最底层。（ps: 坐过电梯观察过得都懂吧）
- 电梯内居民选择指定楼层要开门，电梯外用户点击上行或下行按钮若与正在运行电梯方向一致，也应开门。（疑问：有过进了电梯要上行，结果先到了负一层的经历吧）
- 有兴趣的再思考思考。
附带自己的半成品
自己只写了三个类：
RunLift.java 是实体类，定义了上述分析的参数字段；RunLiftMethod.java 是方法类，封装了所有编写的方法；
Running.java 是运行类，负责调用方法运行。
有兴趣的小伙伴来完善这个可怜的半成品QAQ。
RunLift.class
package com.soft.TwoOfLift;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
public class RunLift {
private int floorMy; //自己所在楼层
private static HashMap<Integer,Integer> downOrUp = new HashMap<>(); //上或下 参数一楼层数，参数二，上下楼梯按钮 1上 2 下
private static List<Integer> floorTargetLift; //准备到几楼 左
private static List<Integer> floorTargetRight; // 到几楼， 右
private static int floorNumRight; //当前右侧电梯所在楼层
private static int floorNumLeft; //当前左侧电梯所在楼层
private static int switchLeft; //电梯内部开关左 1 开 2 关
private static int switchRight; //电梯内部开关右 1 开 2 关
private static int runFlagRight; // 0 未运行 1 运行
private static int runFlagLeft; // 0 未运行 1 运行
private static int runLeftDirection ; //当前左侧电梯运行方向 1上 2 下
private static int runRightDirection; //当前右侧电梯运行方向 1上 2下
//对各楼层按钮赋初值，默认20层
{
for (int i = 0; i < 20; i++) {
downOrUp.put(i+1,0);
}
floorNumLeft = 1;
floorNumRight = 1;
}
public int getFloorMy() {
return floorMy;
}
public void setFloorMy(int floorMy) {
this.floorMy = floorMy;
}
public static HashMap<Integer, Integer> getDownOrUp() {
return downOrUp;
}
public static void setDownOrUp(HashMap<Integer, Integer> downOrUp) {
RunLift.downOrUp = downOrUp;
}
public static List<Integer> getFloorTargetLift() {
return floorTargetLift;
}
public static void setFloorTargetLift(List<Integer> floorTargetLift) {
RunLift.floorTargetLift = floorTargetLift;
}
public static List<Integer> getFloorTargetRight() {
return floorTargetRight;
}
public static void setFloorTargetRight(List<Integer> floorTargetRight) {
RunLift.floorTargetRight = floorTargetRight;
}
public static int getFloorNumRight() {
return floorNumRight;
}
public static void setFloorNumRight(int floorNumRight) {
RunLift.floorNumRight = floorNumRight;
}
public static int getFloorNumLeft() {
return floorNumLeft;
}
public static void setFloorNumLeft(int floorNumLeft) {
RunLift.floorNumLeft = floorNumLeft;
}
public static int getSwitchLeft() {
return switchLeft;
}
public static void setSwitchLeft(int switchLeft) {
RunLift.switchLeft = switchLeft;
}
public static int getSwitchRight() {
return switchRight;
}
public static void setSwitchRight(int switchRight) {
RunLift.switchRight = switchRight;
}
public static int getRunFlagRight() {
return runFlagRight;
}
public static void setRunFlagRight(int runFlagRight) {
RunLift.runFlagRight = runFlagRight;
}
public static int getRunFlagLeft() {
return runFlagLeft;
}
public static void setRunFlagLeft(int runFlagLeft) {
RunLift.runFlagLeft = runFlagLeft;
}
public static int getRunLeftDirection() {
return runLeftDirection;
}
public static void setRunLeftDirection(int runLeftDirection) {
RunLift.runLeftDirection = runLeftDirection;
}
public static int getRunRightDirection() {
return runRightDirection;
}
public static void setRunRightDirection(int runRightDirection) {
RunLift.runRightDirection = runRightDirection;
}
}
RunLiftMethod.java
package com.soft.TwoOfLift;
import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;
import org.junit.runner.notification.RunListener;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
public class RunLiftMethod {
private Scanner scanner = new Scanner(System.in) ;
/**
* 上下楼层选择
*/
public void InputNum(RunLift runLift){
int num = 0;
boolean flag = true;
while (flag){
try{
System.out.println("请选择:1上 ，2下");
num = scanner.nextInt();
if (num == 1 || num == 2){
flag = false;
//设置要到达的楼层数
RunLift.getDownOrUp().put(runLift.getFloorMy(),num);
System.out.println("当前电梯所在层数："+"左侧："+RunLift.getFloorNumLeft() + "层 右侧："+RunLift.getFloorNumRight()+"层");
System.out.println("当前所在楼层为："+ runLift.getFloorMy()+"层");
}else {
System.out.println("请输入 1 或者 2 ");
continue;
}
}catch (Exception e){
System.out.println("请输入整数！");
scanner.next();
}
}
}
//输入到达的楼层
public int scannerTargetFloor(RunLift runLift,int target) {
int num = 0;
boolean flag = true;
while (flag){
try{
System.out.println("请选择要到达的楼层号：");
num = scanner.nextInt();
if (num >= 1 || num <= 20){
flag = false;
if (target == 1){ //1 为左侧 ，否则为右侧
RunLift.getFloorTargetLift().add(num);
if (num > runLift.getFloorMy()){
RunLift.setRunLeftDirection(1);
}else {
RunLift.setRunLeftDirection(2);
}
}else {
RunLift.getFloorTargetRight().add(num);
if (num > runLift.getFloorMy()){
RunLift.setRunRightDirection(1);
}else {
RunLift.setRunRightDirection(2);
}
}
System.out.println("当前电梯所在层数："+"左侧："+RunLift.getFloorNumLeft() + "层 右侧："+RunLift.getFloorNumRight()+"层");
System.out.println("当前所在楼层为："+ runLift.getFloorMy()+"层");
return num;
}else {
System.out.println("请输入 1--20的整数！ ");
continue;
}
}catch (Exception e){
System.out.println("请输入整数！");
scanner.next();
}
}
return 0;
}
/**
* 到达指定楼层
* @param runLift
*/
public void toTargetFloor(RunLift runLift,int target) throws InterruptedException {
//目标楼层
int targetLift = 0;
//获得各层电梯距离目标楼层的高度，
int[] arr = this.toTargetNum(runLift.getFloorMy());
int num = 0;
//当前所在楼层
int floorMy = runLift.getFloorMy();
if (target == 1 ){//调用左侧电梯
int targetNum = RunLift.getFloorTargetLift().get(0);
if (RunLift.getRunLeftDirection()==2){//若为下楼
num = arr[0];
for (int i = floorMy; i >= targetNum; i--) {
RunLift.setFloorNumLeft(i);
if (targetNum == i) {
System.out.println("左侧电梯已到达：" + targetNum + "层。");
RunLift.setSwitchLeft(1);
System.out.println(targetNum + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagLeft(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(targetNum, 0); //声明该层上下楼参数为0，
} else {
System.out.println("左侧电梯正在运行，当前位置为：" + RunLift.getFloorNumLeft() + "层。");
RunLift.setSwitchLeft(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,1);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,1);
}
}else{
num = arr[0];
for (int i = floorMy; i <= targetNum; i++) {
RunLift.setFloorNumLeft(i);
if (targetNum == i) {
System.out.println("左侧电梯已到达：" + targetNum + "层。");
RunLift.setSwitchLeft(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagLeft(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(targetNum, 0); //声明该层上下楼参数为0，
} else {
System.out.println("右侧电梯正在运行，当前位置为：" + RunLift.getFloorNumRight() + "层。");
RunLift.setSwitchRight(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,1);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,1);
}
}
}else { //调用右侧电梯
int targetNum = RunLift.getFloorTargetRight().get(0);
if (RunLift.getRunRightDirection()==2){//若为下楼
num = arr[1];
for (int i = floorMy; i >= targetNum; i--) {
RunLift.setFloorNumRight(i);
if (targetNum == i) {
System.out.println("右侧电梯已到达：" + targetNum + "层。");
RunLift.setSwitchRight(1);
System.out.println(targetNum + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagRight(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(targetNum, 0); //声明该层上下楼参数为0，
} else {
System.out.println("右侧电梯正在运行，当前位置为：" + RunLift.getFloorNumRight() + "层。");
RunLift.setSwitchRight(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,1);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,1);
}
}else{
num = arr[1];
for (int i = floorMy; i <= targetNum; i++) {
RunLift.setFloorNumRight(i);
if (targetNum == i) {
System.out.println("右侧电梯已到达：" + targetNum + "层。");
RunLift.setSwitchRight(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagRight(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(num, 0); //声明该层上下楼参数为0，
} else {
System.out.println("右侧电梯正在运行，当前位置为：" + RunLift.getFloorNumRight() + "层。");
RunLift.setSwitchRight(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,1);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,1);
}
}
}
}
/**
* 选择运行的电梯与到达指定楼层
* @param runLift
* @return
*/
public int openAndWait(RunLift runLift) throws InterruptedException {
//判断电梯所在楼层数与用户所在楼层的位置判断电梯启动 1 左侧 2 右侧
int checkfar = checkFar(runLift);
int floorMy = runLift.getFloorMy();
int floorNumLeft = RunLift.getFloorNumLeft();
int floorNumRight = RunLift.getFloorNumRight();
if (checkfar == 1 ) {
//用户高于左侧电梯楼层
if (floorMy > floorNumLeft) {
//设置电梯为上行
RunLift.setRunLeftDirection(1);
//声明电梯为运行中
RunLift.setRunFlagLeft(1);
for (int num = floorNumLeft; num <= floorMy; num++) {
RunLift.setFloorNumLeft(num);
if (num == floorMy) {
System.out.println("左侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchLeft(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagLeft(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(num, 0); //声明该层上下楼参数为0，
} else {
System.out.println("左侧电梯正在运行，当前位置为：" + RunLift.getFloorNumLeft() + "层。");
RunLift.setSwitchLeft(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,checkfar);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,checkfar);
}
} //当前用户楼层小于电梯所在楼层
else if (floorMy < floorNumLeft) {
//设置电梯为下行
RunLift.setRunLeftDirection(2);
//声明电梯为运行中
RunLift.setRunFlagLeft(1);
for (int num = floorNumLeft; num >= floorMy; num--) {
RunLift.setFloorNumLeft(num);
if (num == floorMy) {
System.out.println("左侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchLeft(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagLeft(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(num, 0); //声明该层上下楼参数为0，
} else {
System.out.println("左侧电梯正在运行，当前位置为：" + RunLift.getFloorNumLeft() + "层。");
RunLift.setSwitchLeft(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,checkfar);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,checkfar);
}
}else{
System.out.println("左侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchLeft(1);
System.out.println(floorMy + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagLeft(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(floorMy, 0); //声明该层上下楼参数为0，
}
}else if(checkfar == 2){
//用户高于右侧电梯楼层
if (floorMy > floorNumRight) {
//设置电梯为上行
RunLift.setRunRightDirection(1);
//声明电梯为运行中
RunLift.setRunFlagRight(1);
for (int num = floorNumRight; num <= floorMy; num++) {
RunLift.setFloorNumRight(num);
if (num == floorMy) {
System.out.println("右侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchRight(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagRight(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(num, 0); //声明该层上下楼参数为0，
} else {
System.out.println("右侧电梯正在运行，当前位置为：" + RunLift.getFloorNumRight() + "层。");
RunLift.setSwitchRight(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,checkfar);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,checkfar);
}
} //当前用户楼层小于电梯所在楼层
else if (floorMy < floorNumRight) {
//设置电梯为下行
RunLift.setRunRightDirection(2);
//声明电梯为运行中
RunLift.setRunFlagRight(1);
for (int num = floorNumRight; num >= floorMy; num--) {
RunLift.setFloorNumRight(num);
if (num == floorMy) {
System.out.println("右侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchRight(1);
System.out.println(num + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagRight(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(num, 0); //声明该层上下楼参数为0，
} else {
System.out.println("右侧电梯正在运行，当前位置为：" + RunLift.getFloorNumRight() + "层。");
RunLift.setSwitchRight(2);
}
//有其他人本来在电梯中且要下到自己的楼层
innerUerCheck(num, runLift,checkfar);
//其他楼层人同样点击上或下,判断操作。
outUserCheck(num, runLift,checkfar);
}
}else{
System.out.println("右侧电梯已到达您的楼层：" + floorMy + "层。");
RunLift.setSwitchRight(1);
System.out.println(floorMy + "层已经到了，电梯门打开。");
Thread.sleep(2000);
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭");
RunLift.setRunFlagRight(0);//声明电梯为运行结束
RunLift.getDownOrUp().put(floorMy, 0); //声明该层上下楼参数为0，
}
}
return checkfar;
}
/**
* 判断优先指派哪个电梯，1左侧， 2 右侧
* @param runLift
* @return
*/
public int checkFar(RunLift runLift) {
int liftNum = 0;
int floorMy = runLift.getFloorMy();
int downOrUp = runLift.getDownOrUp().get(runLift.getFloorMy());
//两个电梯都闲置
if (RunLift.getRunFlagLeft() == 0 && RunLift.getRunFlagRight() == 0){
liftNum = allFree(floorMy, downOrUp);
}
//左侧运行，右侧闲置
if (RunLift.getRunFlagLeft() == 1 && RunLift.getRunFlagRight() == 0){
liftNum = LeftRun(floorMy, downOrUp);
}
//右侧运行， 左侧闲置
if (RunLift.getRunFlagLeft() == 1 && RunLift.getRunFlagRight() == 0){
liftNum = RightRun(floorMy, downOrUp);
}
return liftNum;
}
/**
* 左侧闲置，右侧运行
* @param floorMy
* @param downOrUp
* @return
*/
public int RightRun(int floorMy, int downOrUp) {
//获取楼层差
int[] floorHigh = floorNum(floorMy);
//电梯方向 与 用户方向一致 上
if (RunLift.getRunRightDirection() == 1 && downOrUp == 1 ){
//右侧电梯楼层高于用户楼层
if (RunLift.getFloorNumRight() >floorMy){
return 1;
} //左侧电梯楼层低于用户楼层
else{
//右侧楼层差高于左侧
if (floorHigh[0] < floorHigh[1]){
return 1;
}else {
return 2;
}
}
//方向一致都是下
}else if (RunLift.getRunRightDirection() == 2 && downOrUp == 2 ){
//右侧电梯楼层高于用户楼层
if (RunLift.getFloorNumLeft() >floorMy){
return 1;
} //左侧电梯楼层低于用户楼层
else{
//右侧楼层差高于左侧
if (floorHigh[0] < floorHigh[1]){
return 1;
}else {
return 2;
}
}
//方向不一致 右侧上 用户下
}else if(RunLift.getRunRightDirection() == 1 && downOrUp == 2 ){
return 1;
//左侧下 用户上
}else if (RunLift.getRunRightDirection() == 2 && downOrUp == 1 ){
return 1;
}
return 1;
}
/**
* 左侧运行，右侧闲置
* @param floorMy
* @param downOrUp
* @return
*/
public int LeftRun(int floorMy, int downOrUp) {
//获取楼层差
int[] floorHigh = floorNum(floorMy);
//电梯方向 与 用户方向一致 上
if (RunLift.getRunLeftDirection() == 1 && downOrUp == 1 ){
//左侧电梯楼层高于用户楼层
if (RunLift.getFloorNumLeft() >floorMy){
return 2;
} //左侧电梯楼层低于用户楼层
else{
//左侧楼层差高于右侧
if (floorHigh[0] > floorHigh[1]){
return 2;
}else {
return 1;
}
}
//方向一致都是下
}else if (RunLift.getRunLeftDirection() == 2 && downOrUp == 2 ){
//左侧电梯楼层高于用户楼层
if (RunLift.getFloorNumLeft() >floorMy){
return 2;
} //左侧电梯楼层低于用户楼层
else{
//左侧楼层差高于右侧
if (floorHigh[0] > floorHigh[1]){
return 2;
}else {
return 1;
}
}
//方向不一致 左侧上 用户下
}else if(RunLift.getRunLeftDirection() == 1 && downOrUp == 2 ){
return 2;
//左侧下 用户上
}else if (RunLift.getRunLeftDirection() == 2 && downOrUp == 1 ){
return 2;
}
return 2;
}
/**
* 两台全修改的情况
* @param floorMy
* @param downOrUp
* @return 2 右侧 1 左侧
*/
public int allFree(int floorMy, int downOrUp){
int[] floorHigh = floorNum(floorMy);
if (RunLift.getRunFlagRight() == RunLift.getRunFlagLeft()){
return 2;
}
if (floorHigh[1] >floorHigh[0]){
return 1;
}else{
return 2;
}
}
/**
* 两个电梯与用户楼层 的楼层差
* @param floorMy
* @return
*/
public int[] floorNum(int floorMy){
int floorNumRight = RunLift.getFloorNumRight();
int floorNumLeft = RunLift.getFloorNumLeft();
//右侧距离目标层数
int rightNum = Math.abs(floorNumRight - floorMy);
//左侧...........
int leftNum = Math.abs(floorNumLeft - floorMy);
int[] arr = new int[2];
arr[0] = leftNum;
arr[1] = rightNum;
return arr;
}
/**
* 两个电梯与目标楼层 的楼层差
* @param floorMy
* @return
*/
public int[] toTargetNum(int floorMy){
Integer targetLift = 0;
Integer targetRight = 0;
if (RunLift.getFloorTargetLift().size()!=0){
targetLift = RunLift.getFloorTargetLift().get(0);
}
if (RunLift.getFloorTargetRight().size()!=0){
targetRight = RunLift.getFloorTargetRight().get(0);
}
//右侧
int rightNum = Math.abs(targetRight - floorMy);
//左侧...........
int leftNum = Math.abs(targetLift - floorMy);
int[] arr = new int[2];
arr[0] = leftNum;
arr[1] = rightNum;
return arr;
}
/**
* 电梯外用户按上下按钮开门，关门操作
* @param num
*/
public void outUserCheck(int num, RunLift runLift,int checkFar) throws InterruptedException {
if (checkFar == 1){
//其他楼层人同样点击上或下。
Set<Integer> keys = RunLift.getDownOrUp().keySet();
Iterator<Integer> iterator = keys.iterator();
while (iterator.hasNext()){
//楼层在范围之内，且状态不为0
Integer next = iterator.next();
if (num ==next && RunLift.getDownOrUp().get(next)!=0){
//如果自己，其他楼层，楼层内用户，目的楼层一致，跳过操作
if (runLift.getFloorMy() == num){
continue;
}
//如果其他楼层，楼层内用户，目的楼层一致，跳过操作
for (int i = 0; i <RunLift.getFloorTargetLift().size(); i++) {
if (RunLift.getFloorTargetLift().get(i) == num){
continue;
}
}
//开门
RunLift.setSwitchLeft(1);
System.out.println(num +"层已经到了，电梯门打开。");
Thread.sleep(2000);
//关门并清楚上下楼按钮
RunLift.setSwitchLeft(2);
System.out.println("电梯门关闭。");
RunLift.getDownOrUp().put(iterator.next(),0);
}
}
}else {
//其他楼层人同样点击上或下。
Set<Integer> keys = RunLift.getDownOrUp().keySet();
Iterator<Integer> iterator = keys.iterator();
while (iterator.hasNext()){
//楼层在范围之内，且状态不为0
Integer next = iterator.next();
if (num ==next && RunLift.getDownOrUp().get(next)!=0){
//如果自己，其他楼层，楼层内用户，目的楼层一致，跳过操作
if (runLift.getFloorMy() == num){
continue;
}
//如果其他楼层，楼层内用户，目的楼层一致，跳过操作
for (int i = 0; i <RunLift.getFloorTargetRight().size(); i++) {
if (RunLift.getFloorTargetRight().get(i) == num){
continue;
}
}
//开门
RunLift.setSwitchRight(1);
System.out.println(num +"层已经到了，电梯门打开。");
Thread.sleep(2000);
//关门并清楚上下楼按钮
RunLift.setSwitchRight(2);
System.out.println("电梯门关闭。");
RunLift.getDownOrUp().put(iterator.next(),0);
}
}
}
}
/**
* 电梯内用户到指定楼层的操作
* @param num
* @throws InterruptedException
*/
public void innerUerCheck(int num,RunLift runLift,int checkFar) throws InterruptedException {
if (checkFar == 1){
for (int i = 0; i <RunLift.getFloorTargetLift().size(); i++) {
if (RunLift.getFloorTargetLift().get(i) ==num){
//如果自己，其他楼层，楼层内用户，目的楼层一致，跳过操作
if (runLift.getFloorMy() == num){
continue;
}
//开门
RunLift.setSwitchLeft(1);
System.out.println(num +"层已经到了，电梯门打开。");
Thread.sleep(2000);
//关门并从列表移除楼层
RunLift.setSwitchLeft(2);
RunLift.getFloorTargetLift().remove(i);
System.out.println("电梯门关闭");
}
}
}else {
for (int i = 0; i <RunLift.getFloorTargetRight().size(); i++) {
if (RunLift.getFloorTargetRight().get(i) == num){
//如果自己，其他楼层，楼层内用户，目的楼层一致，跳过操作
if (runLift.getFloorMy() == num){
continue;
}
//开门
RunLift.setSwitchRight(1);
System.out.println(num +"层已经到了，电梯门打开。");
Thread.sleep(2000);
//关门并从列表移除楼层
RunLift.setSwitchRight(2);
RunLift.getFloorTargetRight().remove(i);
System.out.println("电梯门关闭");
}
}
}
}
/**
* 判断是否重新来过
* @return
*/
public int checkNew() {
int num = 0;
boolean flag = true;
while (flag){
try{
System.out.println("是否继续兜风？请选择:1是 ，2否");
num = scanner.nextInt();
if (num == 1 || num == 2){
flag = false;
return num;
}else {
System.out.println("请输入 1 或者 2 ");
continue;
}
}catch (Exception e){
System.out.println("请输入整数！");
scanner.next();
}
}
return 1;
}
}
Running.java
package com.soft.TwoOfLift;
import java.util.ArrayList;
import java.util.List;
public class Running {
public static void main(String[] args) throws InterruptedException {
while (true){
//数据初始化
RunLiftMethod runLiftMethod = new RunLiftMethod();
RunLift runLift = new RunLift();
//左侧目标层
List<Integer> listLeft =new ArrayList<Integer>();
//右侧目标层
List<Integer> listRight =new ArrayList<Integer>();
//选择自己所在的楼层
runLift.setFloorMy(5);
//初始化
RunLift.setFloorTargetLift(listLeft);
RunLift.setFloorTargetRight(listRight);
//选择上下楼
runLiftMethod.InputNum(runLift);
//等待电梯到达,返回哪侧电梯到达
int target = runLiftMethod.openAndWait(runLift);
//输入到达的楼层
runLiftMethod.scannerTargetFloor(runLift,target);
//到达指定的楼层,待优化：当前4层要下楼，6层也要下楼，在测方法中优化，未判断floorTargetLift或者floorTargetRight
//getDownOrUp字段优化
runLiftMethod.toTargetFloor(runLift,target);
//循环判断
if (runLiftMethod.checkNew() == 1){
continue;
}else {
break;
}
}
}
}
标签：Java,半成品,return,int,电梯,RunLift,楼层,两户,floorMy 来源： https://blog.csdn.net/m0_54423474/article/details/121288468