电影院座位连坐实现

时间:2019-08-19
本文章向大家介绍电影院座位连坐实现，主要包括电影院座位连坐实现使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

**一、实现在线选座位功能
怎么实现连坐，
实际分析
1、同一排构成连坐
2、座位可用
3、大于一形成 连坐
实现思路：**
前端传入一个座位的坐标的一个String的集合，前端可以传入混乱的坐标。后台来进行筛选，排序、分割数组，可以使用Arrays.sort()方法来进行排序。排完序的数组按照同一排进行拆分，不是同一排构不成连坐，所以先根据同一排来进行拆分数组。先定义好拆分数组的起始位置与结束位置，定义start与end，然后在循环里判断如果不再同一排了，就使用 list.add(Arrays.copyOfRange(arrs, start, end + 1));生成一个新的数组放入list集合中。但是呢，拆分到最后一个数组是，因为if成立所以不执行else，需要手动维护进去最后一个数组。这样数组基本拆分完成，会拆分成按照同一排生成的所对应的数组。
拆分完成之后，就可以根据每一个同一排的数组来进行判断是否可以构成连坐。先写一个for循环，循环长度为list的长度。进去直接判断集合里的数组长度是否可以大于一，大于一形成连坐。如果不成立就退出循环。for (int j = 0; j < list.get(i).length - 1; j++) {//判断几次 排数相等 length -1这里需要长度 - 1，要不然会出现数组下标越界。然后判断横坐标是否相同if (list.get(i)[j].split("-")[0] .equals(list.get(i)[j + 1].split("-")[0])) {//同一排形成连坐，然后再写一个循环来测试判断了几次y坐标，因为后面确定连坐的起始位置要使用。
下一步判断y坐标if (Integer.parseInt(list.get(i)[m].split("-")[1]) + 1 ==
Integer.parseInt(list.get(i)[m + 1].split("-")[1])) {
如果坐标相加1两个相等的话，则说明为连坐。这里必须写座位的真实坐标，不可以写座位的编号，因为编号每个地方不统一，有的是双号连坐，有的单号，每家都不一样，所以为了复用性，需要使用座位的真实坐标 。
最核心的部分属于if (re == m + 1) {

System.out.println("可以成为" + (m + 2 - no) + "连坐!!!\n" + "连坐数为");
// System.out.println("次数" + (m + 2 - no));
// System.out.println(no);
for (int n = no; n < (m + 3 - no); n++) {
System.out.print(list.get(i)[n] + "\t");

}
//
}


为什么要写no呢，因为要判断连坐的起始位置，与之对应的结束位置。(m + 2 - no) 的意思是连坐至少需要两位，减去前面执行的次数，就是可以构成的连坐数。然后在底下的循环里打印形成连坐的座位的具体坐标。几连坐显示几个，如果 n < (m + 3 - no);这里写成m+2会出现多遍历出一个的问题，所以得要加3。
至此，连坐的核心的代码就已经完毕了，还有一些小问题，等待后续更新！！！

具体代码如下：

package cn.pn.dao;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ConSeat {

public static Object isConSeat(String[] arrs){
int conSeatNum = 4; //连坐数
//新建一个集合来保存分割后的同一排的数组
List<String[]> list = new ArrayList<>();

int start = 0;
int end = 0;

System.out.println("之前的数组" + Arrays.toString(arrs));
//利用sort进行排序
Arrays.sort(arrs);
System.out.println("排序之后的数组" + Arrays.toString(arrs));

//按照同一排进行拆分
for (int i = start; i < arrs.length - 1; i++) {
if (arrs[i].split("-")[0].
equals(arrs[i + 1].split("-")[0])) {
end++;
} else {
// start = end;
// System.out.println("start" + start);
// System.out.println("end" + end);
//Arrays.copyOfRange(arrs,5,10)复制数组从 5 开始到 10
list.add(Arrays.copyOfRange(arrs, start, end + 1));
end++;
//开始等于结束，下次遍历开始的位置
start = end;
}
//走到最后一块不执行else ，手动维护一个
// System.out.println(i);
}
//手动增加最后一个数组，只执行if，所以得要自己增加
list.add(Arrays.copyOfRange(arrs, start, arrs.length));

System.out.println("-------------");

//Arrays.copyOfRange(arrs,5,10)复制数组从 5 开始到 10
// list.add(Arrays.copyOfRange(arrs,5,10));
// list.add(Arrays.copyOfRange(arrs,5,10));
// list.add(Arrays.copyOfRange(arrs,5,10));

for (String[] strings : list) {
System.out.println(Arrays.toString(strings));
}

// System.out.println(num);
// System.out.println(arrs.length);

// String[] coordinate = {("21-2"), ("22-3"), ("21-4"), ("21-5")}; // 坐标

//截取排
// System.out.println(coordinate[1].split("-")[0]);
//截取列
// System.out.println(coordinate[1].split("-")[1]);

int rs = 0; //判断的结果
// int re = 0; //判断是否构成连坐的次数
// int no = 0;//失败的次数

// System.out.println("coordinate.length" + coordinate.length);
// System.out.println(coordinate[0].split("-")[0].
// equals(coordinate[1].split("-")[0]));

//删除集合
// list.remove(0);
// for (int i = 0; i < 7; i++) {
// list.remove(1);
// }
// System.out.println(list.size());



for (int i = 0; i < list.size(); i++) {

if (list.get(i).length > 1) {//大于一形成连坐
rs = 0;
System.out.println("数组" + Arrays.toString(list.get(i)));
// System.out.println(i);
// System.out.println("list.get(i).length " + (list.get(i).length - 1));
// System.out.println("需要的连坐数是" + i);

for (int j = 0; j < list.get(i).length - 1; j++) {//判断几次 排数相等 length -1
// System.out.println("---" + list.get(i)[j].split("-")[0].
// equals(list.get(i)[j + 1].split("-")[0]));
if (list.get(i)[j].split("-")[0].
equals(list.get(i)[j + 1].split("-")[0])) {//同一排形成连坐

rs++; //成功 + 1
}
// System.out.println("rs1" + rs);
}
// System.out.println("rs" + rs);
// System.out.println("rssssss" + (rs == list.get(i).length - 1));

int re = 0;
int no = 0;
if (rs == list.get(i).length - 1) {
for (int m = 0; m < list.get(i).length - 1; m++) {//判断几次

// System.out.println("执行了没有" + (Integer.parseInt(list.get(i)[m].split("-")[1]) + 1 ==
// Integer.parseInt(list.get(i)[m + 1].split("-")[1])));
if (Integer.parseInt(list.get(i)[m].split("-")[1]) + 1 ==
Integer.parseInt(list.get(i)[m + 1].split("-")[1])) {

re++;
// if (re == m + 1) {
// System.out.println("可以成为" + (m + 2) + "连坐!!!\n" + "连坐数为");
//
// for (int n = 0; n < (m + 2); n++) {
// System.out.print(list.get(i)[n] + "\t");
// }
// }
}else {
re ++;
System.out.println("走了");
no ++;
continue;
}
// System.out.println("re" + (re == m + 1));
// System.out.println("re" + (re));
// System.out.println("m" + (m + 1));
if (re == m + 1){
System.out.println("可以成为" + (m + 2 - no) + "连坐!!!\n" + "连坐数为");
// System.out.println("次数" + (m + 2 - no));
// System.out.println(no);
for (int n = no; n < (m + 3 - no); n++) {
System.out.print(list.get(i)[n] + "\t");

}
//
}
// System.out.println("需要判断" + (i + 1) + "次");
}
} else {
System.out.println("不是同一排哦");
continue;
}
} else {
System.out.println("只有一个座位构不成连坐哦！");
}
}
// System.out.println(list.get(1)[3].split("-")[0]);
// System.out.println(Arrays.toString(list.get(1)));
// System.out.println(list.get(1)[1]);
return null;
}


public static void main(String[] args) {

String[] arrs = {
("21-6"), ("22-3"), ("11-1"), ("21-5"),("11-8"),("11-7"),
("11-6"), ("24-5"), ("21-1"), ("31-5"),
("21-8"), ("23-3"), ("6-5"), ("35-5"), ("21-7"),
("11-5"), ("6-8"), ("31-1"), ("21-9"),
("8-5"), ("8-8"), ("8-1"), ("8-6")};

ConSeat.isConSeat(arrs);
}
}

输出结果：省略了很多测试时的注释代码。

之前的数组[21-6, 22-3, 11-1, 21-5, 11-8, 11-7, 11-6, 24-5, 21-1, 31-5, 21-8, 23-3, 6-5, 35-5, 21-7, 11-5, 6-8, 31-1, 21-9, 8-5, 8-8, 8-1, 8-6]
排序之后的数组[11-1, 11-5, 11-6, 11-7, 11-8, 21-1, 21-5, 21-6, 21-7, 21-8, 21-9, 22-3, 23-3, 24-5, 31-1, 31-5, 35-5, 6-5, 6-8, 8-1, 8-5, 8-6, 8-8]
-------------
[11-1, 11-5, 11-6, 11-7, 11-8]
[21-1, 21-5, 21-6, 21-7, 21-8, 21-9]
[22-3]
[23-3]
[24-5]
[31-1, 31-5]
[35-5]
[6-5, 6-8]
[8-1, 8-5, 8-6, 8-8]
数组[11-1, 11-5, 11-6, 11-7, 11-8]
走了
可以成为2连坐!!!
连坐数为
11-5 11-6 可以成为3连坐!!!
连坐数为
11-5 11-6 11-7 可以成为4连坐!!!
连坐数为
11-5 11-6 11-7 11-8 数组[21-1, 21-5, 21-6, 21-7, 21-8, 21-9]
走了
可以成为2连坐!!!
连坐数为
21-5 21-6 可以成为3连坐!!!
连坐数为
21-5 21-6 21-7 可以成为4连坐!!!
连坐数为
21-5 21-6 21-7 21-8 可以成为5连坐!!!
连坐数为
21-5 21-6 21-7 21-8 21-9 只有一个座位构不成连坐哦！
只有一个座位构不成连坐哦！
只有一个座位构不成连坐哦！
数组[31-1, 31-5]
走了
只有一个座位构不成连坐哦！
数组[6-5, 6-8]
走了
数组[8-1, 8-5, 8-6, 8-8]
走了
可以成为2连坐!!!
连坐数为
8-5 8-6 走了

Process finished with exit code 0

原文地址：https://www.cnblogs.com/xwd2366846227/p/11379526.html

随机文章
本站知识点必读
最近更新