第三次博客作业
前言：
题目集六：
电信计费系列一，难度较前几次的数学计算有所下降，但是更为繁琐。
题目集七：
电信计费系列二在系列一上面添加了手机计费规则，规则更加灵活，但是整体难度仍然不大，由于系列一搭好了框架，繁琐程度大大的降低了。
题目集八：
电信计费系列三添加了短信的计费规则，更加灵活了，尤其是对手机号和短信内容的处理。
设计与分析：
7-1 电信计费系列1-座机计费：
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
输入格式:
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。
输出格式:
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
建议类图：
参见图1、2、3，可根据理解自行调整：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
短信的格式：m-主叫号码，接收号码，短信内容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you
输入样例:
在这里给出一组输入。例如：
u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end输出样例:
在这里给出相应的输出。例如：
079186300001 3.0 77.0其余参考样例详见附件，未尽事宜以附件样例为准：
代码
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class work {
ArrayList<String> strr = new ArrayList<>();
ArrayList<User> uesrs = new ArrayList<>();
ArrayList<CallRecord> callRecords = new ArrayList<>();
int usernum = 0;
public work() {
Scanner sc = new Scanner(System.in);
while (true) {
String str = sc.nextLine();
if (str.equals("end"))
return;
strr.add(str);
}
}
void tran() {
String uPattern = "^u-[0-9]{11,12} 0$";
String tPattern = "^t-\\d{10,12}\\s\\d{10,12}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
boolean lock = false;
// 11,12位只包含座机
for (String s : strr) {
if (Pattern.compile("[^-ut\\d: \\.]").matcher(s).find()) //出现的字符集合
continue;
if (s.matches(uPattern) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11,12}) (\\d)$");
User user = new User();
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
if (!user.number.startsWith("0791"))
continue;
user.chargeMode = new LandlinePhoneCharging();
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(
tPattern
// "^t-([0-9]{10,12}) ([0-9]{10,12}) \\d{4}+\\.\\d{1,2}+\\.\\d{1,2}+ ([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]) \\d{4}+\\.\\d{1,2}+\\.\\d{1,2}+ ([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$"
)) {
// ^t-[0-9]{11,13} [0-9]{11,13} [0-9]{4}.[0-9]{1,2}.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2} [0-9]{4}.[0-9]{1,2}.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}$
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("t-([0-9]{10,12}) ([0-9]{10,12}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
//^t-([0-9]{11,13}) ([0-9]{11,13}) \\d{4}+[\\.]\\d{1,2}+[\\.]\\d{1,2}+ ([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]) \\d{4}+[\\.]\\d{1,2}+[\\.]\\d{1,2}+ ([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
if (is_three_area_code(m.group(1))) {
if (m.group(1).length() == 10 || m.group(1).length() == 11)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 3);
else
continue;
} else {
if (m.group(1).length() == 11 || m.group(1).length() == 12)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
else
continue;
}
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
callRecord.answerNumber = m.group(2);
if (is_three_area_code(m.group(2))) {
if (m.group(2).length() == 10 || m.group(2).length() == 11)
callRecord.answerAddressAreaCode = m.group(2).substring(0, 3);
else
continue;
} else {
if (m.group(2).length() == 11 || m.group(2).length() == 12)
callRecord.answerAddressAreaCode = m.group(2).substring(0, 4);
else
continue;
}
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(3));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(3)) && dateStrIsValid(m.group(4))) {
callRecords.add(callRecord);
lock = true;
}
}
}
}
}
void start_work() {
for (CallRecord callRecord : callRecords) {
int num = user_num(callRecord.callingNumber);
if (num != -1) {
switch (code_num_where(callRecord.callingAddressAreaCode
, callRecord.answerAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.callingInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.callingInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.callingInLandRecords.add(callRecord);
break;
default:
break;
}
}
}
this.sort_users();
for (int i = 0; i < usernum; i++)
if (i != usernum - 1)
System.out.println(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
else
System.out.print(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
}
//判断时间是否合法
public boolean dateStrIsValid(String str) {
SimpleDateFormat sd = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");//括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
try {
sd.setLenient(false);//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
sd.parse(str);//从给定字符串的开始解析文本，以生成一个日期
} catch (Exception e) {
return false;
}
return true;
}
// 不足一分钟按一分钟计算时间
static long howlong(Date start, Date end) {
long sec = (end.getTime() - start.getTime()) / 1000;
if (sec % 60 == 0)
return sec / 60;
else return sec / 60 + 1;
}
// 返回用户组下标
int user_num(String num) {
if (this.uesrs.isEmpty())
return -1;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num))
return i;
}
return -1;
}
//是否重复用户判断
boolean is_in_users(String num) {
if (this.uesrs.isEmpty())
return false;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num))
return true;
}
return false;
}
// 两区号比较 市内0 省内长途1 国内长途2
int code_num_where(String code1, String code2) {
int[] code1_num = area(code1);
int[] code2_num = area(code2);
if (code1.equals(code2))
return 0;
else if ((code1_num[0] == code2_num[0] && code1_num[1] != code2_num[1]))
return 1;
else return 2;
}
// 返回是否为3位区号
boolean is_three_area_code(String num) {
String[] arecode = new String[]{"010", "021", "022", "023", "852", "853", "020", "028", "029"};
for (String code : arecode)
if (num.startsWith(code))
return true;
return false;
}
//返回地区号 地区号两位组成 第一位为省份号 第二为为地区号
int[] area(String code) {
int[] area_num = new int[2];
area_num[0] = 9;
area_num[1] = 9;
String[] area1 = {"0790", "0791", "0792", "0793", "0794", "0795", "0796", "0797", "0798", "0799", "0701"};
for (int i = 0; i < area1.length; i++) {
if (code.equals(area1[i])) {
area_num[0] = 1;
area_num[1] = i;
}
}
return area_num;
}
// 打印标准格式
static String Print(double a) {
if (Math.abs((int) a - a) < 1e-6) return (int) a + ".0";
else if ((Math.abs((int) a - a + 1) < 1e-6)) return (int) a + 1 + ".0";
else return new DecimalFormat("#.#").format(a);
}
// 用户按号码排序
void sort_users() {
long[] user_num = new long[usernum];
User[] Users = new User[usernum];
for (int i = 0; i < usernum; i++) {
user_num[i] = Long.parseLong(uesrs.get(i).number);
Users[i] = this.uesrs.get(i);
}
for (int i = 0; i < usernum - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < usernum; j++) {
if (user_num[j] < user_num[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
long tmp = user_num[min];
user_num[min] = user_num[i];
user_num[i] = tmp;
User temp = Users[min];
Users[min] = Users[i];
Users[i] = temp;
}
}
}
this.uesrs = new ArrayList<>(Arrays.asList(Users).subList(0, usernum));
}
}
//UserRecords是用户记录类，保存用户各种通话、短信的记录，
//各种计费规则将使用其中的部分或者全部记录。
//其属性从上到下依次是：
//以及发送短信、接收短信的记录。
class UserRecords {
//市内拨打电话
ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）拨打电话
ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
//省外拨打电话
ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//市内接听电话
ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）接听电话
ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
//省外接听电话的记录
ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//发送短信记录
ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
//接收短信的记录
ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
void CallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
void adddAnswerInCityRecords(CallRecord answerRecord) {
answerInCityRecords.add(answerRecord);
}
void addSendMessageRecords(MessageRecord sendMessageRecord) {
sendMessageRecords.add(sendMessageRecord);
}
void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
receiveMessageRecords.add(receiveMessageRecord);
}
ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
}
//User是用户类，包括属性：
//userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）
class User {
String number;
int model;//0为座机用户
double balance = 100;
ChargeMode chargeMode;//ChargeMode是计费方式的抽象类：
UserRecords userRecords = new UserRecords();//
//计算余额
public double calBalance() {
balance = balance - calCost() - chargeMode.getMonthlyRent();
return balance;
}
double calCost() {
LandPhoneIInlandRule lpi = new LandPhoneIInlandRule();
LandPhoneInCityRule lpc = new LandPhoneInCityRule();
LandPhoneInProvinceRule lpp = new LandPhoneInProvinceRule();
return lpi.callCost(userRecords.callingInLandRecords) + lpc.callCost(userRecords.callingInCityRecords)
+ lpp.callCost(userRecords.callingInProvinceRecords);
}
UserRecords getUserRecords() {
return userRecords;
}
void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
double getBalance() {
return balance;
}
ChargeMode getChargeMode() {
return chargeMode;
}
void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
String getNumber() {
return number;
}
void setNumber(String number) {
this.number = number;
}
}
// MessageRecord（短信记录）
class MessageRecord extends CommunicationRecord {
String message;
String getMessage() {
return message;
}
void setMessage(String message) {
this.message = message;
}
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
public class Main {
public static void main(String[] args) {
work work = new work();
work.tran();
work.start_work();
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneInCityRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords) cost += 0.1 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneIInlandRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords) cost += 0.6 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandlinePhoneCharging extends ChargeMode {
double monthlyRent = 20;
@Override
ArrayList<ChargeRule> getChargeRules() {
return null;
}
@Override
void setChargeRules(ArrayList<ChargeRule> chargeRules) {
}
@Override
double calCost(UserRecords userRecords) {
return 0.0;
}
@Override
double getMonthlyRent() {
return monthlyRent;
}
}
abstract class CommunicationRecord {
String callingNumber;//拨打号码
String answerNumber;//接听号码
abstract String getCallingNumber();
abstract void setCallingNumber(String callingNumber);
abstract String getAnswerNumber();
abstract void setAnswerNumber(String answerNumber);
}
abstract class ChargeRule {
}
//ChargeMode是计费方式的抽象类：
abstract class ChargeMode {
ArrayList<ChargeRule> chargeRules = new ArrayList<>();
abstract ArrayList<ChargeRule> getChargeRules();
abstract void setChargeRules(ArrayList<ChargeRule> chargeRules);
abstract double calCost(UserRecords userRecords);
abstract double getMonthlyRent();
}
abstract class CallChargeRule extends ChargeRule {
abstract double callCost(ArrayList<CallRecord> callRecords);
}
//CallRecord（通话记录类）包含属性：
//通话的起始、结束时间以及 拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
//区号用于记录在哪个地点拨打和接听的电话。对于座机，就是本机区号。
// 如果是手机号，则接打地点的区号和本机的开户地区会有差异。
class CallRecord extends CommunicationRecord {
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
Date getStartTime() {
return startTime;
}
void setStartTime(Date startTime) {
this.startTime = startTime;
}
Date getEndTime() {
return endTime;
}
void setEndTime(Date endTime) {
this.endTime = endTime;
}
String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}类图与分析
本次作业主要是针对类图结构写代码，十分繁琐。，看懂类图并用提供的类图写代码便成为这道题难点。题目算法不难，各项指标都处于一个较为合理的范围。
7-1 电信计费系列2-手机+座机计费
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。 （提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
输入样例:
在这里给出一组输入。例如：
u-13811111111 1
t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
end输出样例:
在这里给出相应的输出。例如：
13811111111 3.0 82.0更多内容详见附件：
代码
import javax.print.DocFlavor;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class work {
ArrayList<String> strr = new ArrayList<>();
ArrayList<User> uesrs = new ArrayList<>();
ArrayList<CallRecord> callRecords = new ArrayList<>();
int usernum = 0;
public work() {
Scanner sc = new Scanner(System.in);
while (true) {
String str = sc.nextLine();
if (str.equals("end"))
return;
strr.add(str);
}
}
void tran() {
String tPattern = "t-0\\d{9,11}\\s" + "0\\d{9,11}\\s"
+ "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String tPattern2 = "t-\\d{11}\\s\\d{3,4}\\s" + "\\d{11}\\s\\d{3,4}\\s"
+ "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String tPattern3 = "t-\\d{11}\\s\\d{3,4}\\s" + "\\d{10,12}\\s"
+ "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String tPattern1 = "t-\\d{10,12}\\s" + "1\\d{10}\\s\\d{3,4}\\s"
+ "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String uPattern = "^u-[0-9]{11,12} 0$";
String uPattern1 = "^u-[0-9]{11} 1$";
//座机呼叫座机
//String tPattern = "^t-\\d{10,12}\\s\\d{10,12}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
//座机打手机
// String tPattern1 = "^t-\\d{10,12}\\s\\d{11}\\s\\d{3,4}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
// 手机互打
// String tPattern2 = "^t-\\d{11}\\s\\d{3,4}\\s\\d{11}\\s\\d{3,4}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
//手机打座机
// String tPattern3 = "^t-\\d{11}\\s\\d{3,4}\\s\\d{10,12}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
boolean lock = false;
// 11,12位只包含座机
for (String s : strr) {
if (Pattern.compile("[^-ut\\d: \\.]").matcher(s).find()) //出现的字符集合
continue;
if (s.matches(uPattern) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11,12}) (\\d)$");
User user = new User(0);
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
where_is_me(user);
if (!user.number.startsWith("0791"))
continue;
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(uPattern1) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11}) (1)$");
User user = new User(1);
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
where_is_me(user);
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(tPattern)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("t-([0-9]{10,12}) ([0-9]{10,12}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
callRecord.callingAddressAreaCode = myCode(m.group(1));
callRecord.answerNumber = m.group(2);
callRecord.answerAddressAreaCode = myCode(m.group(2));
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(3));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(3)) && dateStrIsValid(m.group(4))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern1)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("^t-(\\d{10,12})\\s(\\d{11})\\s(\\d{3,4})\\s([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
if (is_three_area_code(m.group(1))) {
if (m.group(1).length() == 10 || m.group(1).length() == 11)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 3);
else
continue;
} else {
if (m.group(1).length() == 11 || m.group(1).length() == 12)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
else
continue;
}
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
callRecord.answerNumber = m.group(2);
callRecord.answerAddressAreaCode = m.group(3);
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(5));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(4)) && dateStrIsValid(m.group(5))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern2)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("^t-(\\d{11})\\s(\\d{3,4})\\s(\\d{11})\\s(\\d{3,4}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
callRecord.callingAddressAreaCode = m.group(2);
callRecord.answerNumber = m.group(3);
callRecord.answerAddressAreaCode = m.group(4);
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(5));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(6));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(5)) && dateStrIsValid(m.group(6))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern3)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("^t-(\\d{11})\\s(\\d{3,4})\\s(\\d{10,12}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
callRecord.callingAddressAreaCode = m.group(2);
callRecord.answerNumber = m.group(3);
callRecord.answerAddressAreaCode = myCode(callRecord.answerNumber);
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(5));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(4)) && dateStrIsValid(m.group(5))) {
callRecords.add(callRecord);
lock = true;
}
}
}
}
}
void start_work() {
for (CallRecord callRecord : callRecords) {
// 拨打电话记录
int num = user_num(callRecord.callingNumber);
if (num != -1) {
if (this.uesrs.get(num).model == 0)
switch (code_num_where(callRecord.callingAddressAreaCode
, callRecord.answerAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.callingInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.callingInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.callingInLandRecords.add(callRecord);
break;
default:
break;
}
else {
switch (work.is_(callRecord.callingAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.callingInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.callingInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.callingInLandRecords.add(callRecord);
break;
default:
break;
}
}
}
num = user_num(callRecord.answerNumber);
if (num != -1) {
switch (work.is_(callRecord.answerAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.answerInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.answerInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.answerInLandRecords.add(callRecord);
break;
default:
break;
}
}
}
this.sort_users();
for (int i = 0; i < usernum; i++)
if (i != usernum - 1)
System.out.println(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
else
System.out.print(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
}
//判断时间是否合法
public boolean dateStrIsValid(String str) {
SimpleDateFormat sd = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");//括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
try {
sd.setLenient(false);//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
sd.parse(str);//从给定字符串的开始解析文本，以生成一个日期
} catch (Exception e) {
return false;
}
return true;
}
// 不足一分钟按一分钟计算时间
static long howlong(Date start, Date end) {
long sec = (end.getTime() - start.getTime()) / 1000;
if (sec % 60 == 0)
return sec / 60;
else return sec / 60 + 1;
}
// 返回用户组下标
int user_num(String num) {
if (this.uesrs.isEmpty())
return -1;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num))
return i;
}
return -1;
}
//是否重复用户判断
boolean is_in_users(String num) {
if (this.uesrs.isEmpty())
return false;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num))
return true;
}
return false;
}
// 输入号码，返回用户区号和号码数组
void where_is_me(User user) {
if (user.model == 0) {
String number = user.number;
String[] cods = new String[2];
if (is_three_area_code(number)) {
user.code = number.substring(0, 3);
user.no = number.substring(3);
} else {
user.code = number.substring(0, 4);
user.no = number.substring(4);
}
} else user.no = user.number;
}
// 返回座机号码区号
String myCode(String number) {
if (is_three_area_code(number))
return number.substring(0, 3);
else {
return number.substring(0, 4);
}
}
// 两区号比较 市内0 省内长途1 国内长途2
int code_num_where(String code1, String code2) {
int[] code1_num = area(code1);
int[] code2_num = area(code2);
if (code1.equals(code2))
return 0;
else if ((code1_num[0] == code2_num[0] && code1_num[1] != code2_num[1]))
return 1;
else return 2;
}
// 市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，
// 省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
// int code_where(String code1, String code2) {
// if(work.is_(code1)==0&&work.is_(code2)==0)
// }
// 返回是否为3位区号
boolean is_three_area_code(String num) {
String[] arecode = new String[]{"010", "021", "022", "023", "852", "853", "020", "028", "029"};
for (String code : arecode)
if (num.startsWith(code))
return true;
return false;
}
//返回地区号 地区号两位组成 第一位为省份号 第二为为地区号
//00 为南昌 其他0开头的为江西省内其他
int[] area(String code) {
int[] area_num = new int[2];
area_num[0] = 9;
area_num[1] = 9;
String[] area1 = {"0790", "0791", "0792", "0793", "0794", "0795", "0796", "0797", "0798", "0799", "0701"};
for (int i = 0; i < area1.length; i++) {
if (code.equals(area1[i])) {
area_num[0] = 1;
area_num[1] = i;
}
}
return area_num;
}
//南昌 0 江西省内 1 外2
static int is_(String code) {
String[] codes = {"0790", "0791", "0792", "0793", "0794", "0795", "0796", "0797", "0798", "0799", "0701"};
if (code.equals("0791"))
return 0;
for (String codee : codes)
if (code.equals(codee))
return 1;
return 2;
}
// 打印标准格式
static String Print(double a) {
if (Math.abs((int) a - a) < 1e-6) return (int) a + ".0";
else if ((Math.abs((int) a - a + 1) < 1e-6)) return (int) a + 1 + ".0";
else return new DecimalFormat("#.#").format(a);
}
// 用户按号码排序
void sort_users() {
long[] user_num = new long[usernum];
User[] Users = new User[usernum];
for (int i = 0; i < usernum; i++) {
user_num[i] = Long.parseLong(uesrs.get(i).no);
Users[i] = this.uesrs.get(i);
}
for (int i = 0; i < usernum - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < usernum; j++) {
if (user_num[j] < user_num[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
long tmp = user_num[min];
user_num[min] = user_num[i];
user_num[i] = tmp;
User temp = Users[min];
Users[min] = Users[i];
Users[i] = temp;
}
}
this.uesrs = new ArrayList<>(Arrays.asList(Users).subList(0, usernum));
}
}
//UserRecords是用户记录类，保存用户各种通话、短信的记录，
//各种计费规则将使用其中的部分或者全部记录。
//其属性从上到下依次是：
//以及发送短信、接收短信的记录。
class UserRecords {
//市内拨打电话
ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）拨打电话
ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
//省外拨打电话
ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//市内接听电话
ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）接听电话
ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
//省外接听电话的记录
ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//发送短信记录
ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
//接收短信的记录
ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
void CallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
void adddAnswerInCityRecords(CallRecord answerRecord) {
answerInCityRecords.add(answerRecord);
}
void addSendMessageRecords(MessageRecord sendMessageRecord) {
sendMessageRecords.add(sendMessageRecord);
}
void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
receiveMessageRecords.add(receiveMessageRecord);
}
ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
}
//User是用户类，包括属性：
//userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）
class User {
String number, code, no;
int model;//0为座机用户 1为手机用户
double balance = 100;
ChargeMode chargeMode;//ChargeMode是计费方式的类：
UserRecords userRecords = new UserRecords();//
public User(int model) {
this.model = model;
this.chargeMode = new ChargeMode(model);
}
//计算余额
public double calBalance() {
balance = balance - calCost() - this.chargeMode.getMonthlyRent();
return balance;
}
double calCost() {
LandPhoneIInlandRule lpi = new LandPhoneIInlandRule();
LandPhoneInCityRule lpc = new LandPhoneInCityRule();
LandPhoneInProvinceRule lpp = new LandPhoneInProvinceRule();
double cost = 0;
if (model == 0)
return lpi.callCost(userRecords.callingInLandRecords) + lpc.callCost(userRecords.callingInCityRecords)
+ lpp.callCost(userRecords.callingInProvinceRecords);
else {
for (CallRecord callRecord : this.userRecords.callingInCityRecords) {
//市内拨打市内电话
if (callRecord.answerAddressAreaCode.equals("0791"))
cost += 0.1 * work.howlong(callRecord.startTime, callRecord.endTime);
//市内拨打省内电话
else if (work.is_(callRecord.answerAddressAreaCode) == 1)
cost += 0.2 * work.howlong(callRecord.startTime, callRecord.endTime);
//市内拨打省外电话
else if (work.is_(callRecord.answerAddressAreaCode) == 2)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
}
for (CallRecord callRecord : this.userRecords.callingInProvinceRecords)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);//省内漫游打电话0.3元/分钟
for (CallRecord callRecord : this.userRecords.callingInLandRecords)
cost += 0.6 * work.howlong(callRecord.startTime, callRecord.endTime);//省外漫游拨打0.6元/分钟
for (CallRecord callRecord : this.userRecords.answerInLandRecords)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);//省外漫游接听0.3元/分钟
return cost;
}
}
UserRecords getUserRecords() {
return userRecords;
}
void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
double getBalance() {
return balance;
}
ChargeMode getChargeMode() {
return chargeMode;
}
void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
String getNumber() {
return number;
}
void setNumber(String number) {
this.number = number;
}
}
// MessageRecord（短信记录）
class MessageRecord extends CommunicationRecord {
String message;
String getMessage() {
return message;
}
void setMessage(String message) {
this.message = message;
}
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
public class Main {
public static void main(String[] args) {
work work = new work();
work.tran();
work.start_work();
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneInCityRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.1 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneIInlandRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.6 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
abstract class CommunicationRecord {
String callingNumber;//拨打号码
String answerNumber;//接听号码
abstract String getCallingNumber();
abstract void setCallingNumber(String callingNumber);
abstract String getAnswerNumber();
abstract void setAnswerNumber(String answerNumber);
}
abstract class ChargeRule {
}
//ChargeMode是计费方式
class ChargeMode {
ArrayList<ChargeRule> chargeRules = new ArrayList<>();
double MonthlyRent;
double ccc, ccp, ccl;//市内拨打电话，省内长途，国内长途
double cp_, cl_;//省内漫游打电话,省外漫游拨打
double rp_;//省外漫游接听
public ChargeMode(int model) {
if (model == 0) {
MonthlyRent = 20;
rp_ = 0;
ccc = 0.1;
ccp = 0.3;
ccl = 0.6;
}
if (model == 1) {
MonthlyRent = 15;
ccc = 0.1;
ccp = 0.2;
ccl = 0.3;
cp_ = 0.3;
rp_ = 0.3;
cl_ = 0.6;
}
}
public ChargeMode() {
}
ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
double getMonthlyRent() {
return MonthlyRent;
}
}
abstract class CallChargeRule extends ChargeRule {
abstract double callCost(ArrayList<CallRecord> callRecords);
}
//CallRecord（通话记录类）包含属性：
//通话的起始、结束时间以及 拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
//区号用于记录在哪个地点拨打和接听的电话。对于座机，就是本机区号。
// 如果是手机号，则接打地点的区号和本机的开户地区会有差异。
class CallRecord extends CommunicationRecord {
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
Date getStartTime() {
return startTime;
}
void setStartTime(Date startTime) {
this.startTime = startTime;
}
Date getEndTime() {
return endTime;
}
void setEndTime(Date endTime) {
this.endTime = endTime;
}
String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}类图与分析
本次作业主要是加入了手机业务，数据处理更加复杂了。最大复杂度和深度超出了合理范围。还有非常大的改进空间。
7-1 电信计费系列3-短信计费
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。
输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容 （短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
本题只考虑短信计费，不考虑通信费用以及月租费。
建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
输入样例:
在这里给出一组输入。例如：
u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end输出样例:
在这里给出相应的输出。例如：
18907910010 0.3 99.7### 输入样例1:在这里给出一组输入。例如：
u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaa
m-18907910010 13305862264 aaaaaaa.
m-18907910010 13305862264 bb,bbbb
end输出样例1:
在这里给出相应的输出。例如：
18907910010 0.5 99.5代码（本题虽只需计算短信业务且PTA的提交系统允许大小太小，实际只提交了下面代码的短信部分，下方代码为这几次作业完整的电信系统）
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class work {
ArrayList<String> strr = new ArrayList<>();
ArrayList<User> uesrs = new ArrayList<>();
ArrayList<CallRecord> callRecords = new ArrayList<>();
ArrayList<MessageRecord> messageRecords = new ArrayList<>();
int usernum = 0;
public work() {
Scanner sc = new Scanner(System.in);
while (true) {
String str = sc.nextLine();
if (str.equals("end")) return;
strr.add(str);
}
}
void tran() {
// String tPattern0 = "t-0\\d{9,11}\\s" + "0\\d{9,11}\\s"
// + "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
// String tPattern1 = "t-\\d{11}\\s\\d{3,4}\\s" + "\\d{11}\\s\\d{3,4}\\s"
// + "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
// String tPattern2 = "t-\\d{11}\\s\\d{3,4}\\s" + "\\d{10,12}\\s"
// + "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
// String tPattern3 = "t-\\d{10,12}\\s" + "1\\d{10}\\s\\d{3,4}\\s"
// + "([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String uPattern = "^u-[0-9]{11,12} 0$";
String uPattern1 = "^u-[0-9]{11} 1$";
String uPattern2 = "^u-[0-9]{11} 3$";
//座机呼叫座机
String tPattern = "^t-\\d{10,12}\\s\\d{10,12}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
//座机打手机
String tPattern1 = "^t-\\d{10,12}\\s\\d{11}\\s\\d{3,4}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
// 手机互打
String tPattern2 = "^t-\\d{11}\\s\\d{3,4}\\s\\d{11}\\s\\d{3,4}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$";
String tPattern3 = "[m]-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "[0-9a-zA-Z\\s\\.,]+";
boolean lock = false;
// 11,12位只包含座机
for (String s : strr) {
// if (Pattern.compile("[^-ut\\d: \\.]").matcher(s).find()) //出现的字符集合
// continue;
if (s.matches(uPattern) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11,12}) (\\d)$");
User user = new User(0);
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
if (!user.number.startsWith("0791")) continue;
user.chargeMode = new LandlinePhoneCharging();
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(uPattern1) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11}) (1)$");
User user = new User(1);
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
user.chargeMode = new LandlinePhoneCharging();
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(uPattern2) && !lock) {
Pattern r = Pattern.compile("^u-([0-9]{11}) (3)$");
User user = new User(3);
Matcher m = r.matcher(s);
if (m.find()) {
user.model = Integer.parseInt(m.group(2));
user.number = m.group(1);
user.chargeMode = new LandlinePhoneCharging();
if (!is_in_users(user.number)) {
usernum++;
uesrs.add(user);
}
}
} else if (s.matches(tPattern)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("t-([0-9]{10,12}) ([0-9]{10,12}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
if (is_three_area_code(m.group(1))) {
if (m.group(1).length() == 10 || m.group(1).length() == 11)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 3);
else continue;
} else {
if (m.group(1).length() == 11 || m.group(1).length() == 12)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
else continue;
}
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
callRecord.answerNumber = m.group(2);
if (is_three_area_code(m.group(2))) {
if (m.group(2).length() == 10 || m.group(2).length() == 11)
callRecord.answerAddressAreaCode = m.group(2).substring(0, 3);
else continue;
} else {
if (m.group(2).length() == 11 || m.group(2).length() == 12)
callRecord.answerAddressAreaCode = m.group(2).substring(0, 4);
else continue;
}
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(3));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(3)) && dateStrIsValid(m.group(4))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern1)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("^t-(\\d{10,12})\\s(\\d{11})\\s(\\d{3,4})\\s([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
if (is_three_area_code(m.group(1))) {
if (m.group(1).length() == 10 || m.group(1).length() == 11)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 3);
else continue;
} else {
if (m.group(1).length() == 11 || m.group(1).length() == 12)
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
else continue;
}
callRecord.callingAddressAreaCode = m.group(1).substring(0, 4);
callRecord.answerNumber = m.group(2);
callRecord.answerAddressAreaCode = m.group(3);
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(4));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(5));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(3)) && dateStrIsValid(m.group(4))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern2)) {
CallRecord callRecord = new CallRecord();
Pattern r = Pattern.compile("^t-(\\d{11})\\s(\\d{3,4})\\s(\\d{11})\\s(\\d{3,4}) ([0-9]{4}\\.[0-9]{1,2}\\.[0-9]{1,2}) ([0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2})");
Matcher m = r.matcher(s);
if (m.find()) {
callRecord.callingNumber = m.group(1);
callRecord.callingAddressAreaCode = m.group(2);
callRecord.answerNumber = m.group(3);
callRecord.answerAddressAreaCode = m.group(4);
Date sd;
Date fd;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
sd = format.parse(m.group(5));
} catch (ParseException e) {
continue;
}
try {
fd = format.parse(m.group(6));
} catch (ParseException e) {
continue;
}
callRecord.startTime = sd;
callRecord.endTime = fd;
if (sd.getTime() < fd.getTime() && dateStrIsValid(m.group(3)) && dateStrIsValid(m.group(4))) {
callRecords.add(callRecord);
lock = true;
}
}
} else if (s.matches(tPattern3)) {
// String tPattern3 = "^m-\\d{11} \\d{11} .{1,}";
MessageRecord messageRecord = new MessageRecord();
Pattern r = Pattern.compile("^m-(\\d{11}) (\\d{11}) (.{1,})");
Matcher m = r.matcher(s);
if (m.find()) {
messageRecord.callingNumber = m.group(1);
messageRecord.answerNumber = m.group(2);
messageRecord.message = m.group(3);
messageRecords.add(messageRecord);
}
}
}
}
void start_work() {
for (CallRecord callRecord : callRecords) {
// 拨打电话记录
int num = user_num(callRecord.callingNumber);
if (num != -1) {
if (this.uesrs.get(num).model == 0)
switch (code_num_where(callRecord.callingAddressAreaCode, callRecord.answerAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.callingInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.callingInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.callingInLandRecords.add(callRecord);
break;
default:
break;
}
else {
switch (work.is_(callRecord.callingAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.callingInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.callingInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.callingInLandRecords.add(callRecord);
break;
default:
break;
}
}
num = user_num(callRecord.answerNumber);
if (num != -1) {
switch (work.is_(callRecord.answerAddressAreaCode)) {
case 0:
this.uesrs.get(num).userRecords.answerInCityRecords.add(callRecord);
break;
case 1:
this.uesrs.get(num).userRecords.answerInProvinceRecords.add(callRecord);
break;
case 2:
this.uesrs.get(num).userRecords.answerInLandRecords.add(callRecord);
break;
default:
break;
}
}
}
}
for (MessageRecord messageRecord : messageRecords) {
int num = user_num(messageRecord.callingNumber);
if (num != -1) {
if (this.uesrs.get(num).model == 3) {
this.uesrs.get(num).userRecords.sendMessageRecords.add(messageRecord);
}
}
num = user_num(messageRecord.answerNumber);
if (num != -1) {
if (this.uesrs.get(num).model == 3) {
this.uesrs.get(num).userRecords.receiveMessageRecords.add(messageRecord);
}
}
}
this.sort_users();
for (int i = 0; i < usernum; i++)
if (i != usernum - 1)
System.out.println(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
else
System.out.print(uesrs.get(i).number + " " + Print(uesrs.get(i).calCost()) + " " + Print(uesrs.get(i).calBalance()));
}
// 输入字符计算短信条数
static int what_num(String str) {
if (str.length() % 10 == 0)
return str.length() / 10;
else return str.length() / 10 + 1;
}
//判断时间是否合法
public boolean dateStrIsValid(String str) {
SimpleDateFormat sd = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");//括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
try {
sd.setLenient(false);//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
sd.parse(str);//从给定字符串的开始解析文本，以生成一个日期
} catch (Exception e) {
return false;
}
return true;
}
// 不足一分钟按一分钟计算时间
static long howlong(Date start, Date end) {
long sec = (end.getTime() - start.getTime()) / 1000;
if (sec % 60 == 0) return sec / 60;
else return sec / 60 + 1;
}
// 返回用户组下标
int user_num(String num) {
if (this.uesrs.isEmpty()) return -1;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num)) return i;
}
return -1;
}
//是否重复用户判断
boolean is_in_users(String num) {
if (this.uesrs.isEmpty()) return false;
for (int i = 0; i < this.usernum; i++) {
if (uesrs.get(i).number.equals(num)) return true;
}
return false;
}
// 两区号比较 市内0 省内长途1 国内长途2
int code_num_where(String code1, String code2) {
int[] code1_num = area(code1);
int[] code2_num = area(code2);
if (code1.equals(code2)) return 0;
else if ((code1_num[0] == code2_num[0] && code1_num[1] != code2_num[1])) return 1;
else return 2;
}
// 市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，
// 省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
// int code_where(String code1, String code2) {
// if(work.is_(code1)==0&&work.is_(code2)==0)
// }
// 返回是否为3位区号
boolean is_three_area_code(String num) {
String[] arecode = new String[]{"010", "021", "022", "023", "852", "853", "020", "028", "029"};
for (String code : arecode)
if (num.startsWith(code)) return true;
return false;
}
//返回地区号 地区号两位组成 第一位为省份号 第二为为地区号
//00 为南昌 其他0开头的为江西省内其他
int[] area(String code) {
int[] area_num = new int[2];
area_num[0] = 9;
area_num[1] = 9;
String[] area1 = {"0790", "0791", "0792", "0793", "0794", "0795", "0796", "0797", "0798", "0799", "0701"};
for (int i = 0; i < area1.length; i++) {
if (code.equals(area1[i])) {
area_num[0] = 1;
area_num[1] = i;
}
}
return area_num;
}
//南昌 0 江西省内 1 外2
static int is_(String code) {
String[] codes = {"0790", "0791", "0792", "0793", "0794", "0795", "0796", "0797", "0798", "0799", "0701"};
if (code.equals("0791")) return 0;
for (String codee : codes)
if (code.equals(codee)) return 1;
return 2;
}
// 打印标准格式
static String Print(double a) {
if (Math.abs((int) a - a) < 1e-6) return (int) a + ".0";
else if ((Math.abs((int) a - a + 1) < 1e-6)) return (int) a + 1 + ".0";
else return new DecimalFormat("#.#").format(a);
}
// 用户按号码排序
void sort_users() {
long[] user_num = new long[usernum];
User[] Users = new User[usernum];
for (int i = 0; i < usernum; i++) {
user_num[i] = Long.parseLong(uesrs.get(i).number);
Users[i] = this.uesrs.get(i);
}
for (int i = 0; i < usernum - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < usernum; j++) {
if (user_num[j] < user_num[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
long tmp = user_num[min];
user_num[min] = user_num[i];
user_num[i] = tmp;
User temp = Users[min];
Users[min] = Users[i];
Users[i] = temp;
}
}
}
this.uesrs = new ArrayList<>(Arrays.asList(Users).subList(0, usernum));
}
}
//UserRecords是用户记录类，保存用户各种通话、短信的记录，
//各种计费规则将使用其中的部分或者全部记录。
//其属性从上到下依次是：
//以及发送短信、接收短信的记录。
class UserRecords {
//市内拨打电话
ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）拨打电话
ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
//省外拨打电话
ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//市内接听电话
ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
//省内（不含市内）接听电话
ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
//省外接听电话的记录
ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//发送短信记录
ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
//接收短信的记录
ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
void CallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
void adddAnswerInCityRecords(CallRecord answerRecord) {
answerInCityRecords.add(answerRecord);
}
void addSendMessageRecords(MessageRecord sendMessageRecord) {
sendMessageRecords.add(sendMessageRecord);
}
void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
receiveMessageRecords.add(receiveMessageRecord);
}
ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
}
//User是用户类，包括属性：
//userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）
class User {
String number;
int model;//0为座机用户 1为手机用户 3-手机短信计费
double balance = 100;
ChargeMode chargeMode;//ChargeMode是计费方式的抽象类：
UserRecords userRecords = new UserRecords();//
public User(int model) {
this.model = model;
chargeMode = new ChargeMode(model);
}
//计算余额
public double calBalance() {
if (this.model != 3)
balance = balance - calCost() - chargeMode.getMonthlyRent();
else balance = balance - calCost();
return balance;
}
double calCost() {
LandPhoneIInlandRule lpi = new LandPhoneIInlandRule();
LandPhoneInCityRule lpc = new LandPhoneInCityRule();
LandPhoneInProvinceRule lpp = new LandPhoneInProvinceRule();
if (model == 0)
return lpi.callCost(userRecords.callingInLandRecords) + lpc.callCost(userRecords.callingInCityRecords) + lpp.callCost(userRecords.callingInProvinceRecords);
else if (model == 1) {
double cost = 0;
for (CallRecord callRecord : this.userRecords.callingInCityRecords) {
//市内拨打市内电话
if (callRecord.callingAddressAreaCode.equals("0791") && callRecord.answerAddressAreaCode.equals("0791"))
cost += 0.1 * work.howlong(callRecord.startTime, callRecord.endTime);
else if (work.is_(callRecord.callingAddressAreaCode) == 0 && work.is_(callRecord.answerAddressAreaCode) == 1)
//市内拨打省内电话
cost += 0.2 * work.howlong(callRecord.startTime, callRecord.endTime);
else if (work.is_(callRecord.callingAddressAreaCode) == 0 && work.is_(callRecord.answerAddressAreaCode) == 2)
//市内拨打省外电话
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
else if (work.is_(callRecord.callingAddressAreaCode) == 1)
//省内漫游打电话
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
// 省外漫游拨打0.6元/分钟
else if (work.is_(callRecord.callingAddressAreaCode) == 2)
cost += 0.6 * work.howlong(callRecord.startTime, callRecord.endTime);
}
for (CallRecord callRecord : this.userRecords.callingInProvinceRecords)
cost += chargeMode.ccp * work.howlong(callRecord.startTime, callRecord.endTime);
for (CallRecord callRecord : this.userRecords.callingInLandRecords)
cost += chargeMode.ccc * work.howlong(callRecord.startTime, callRecord.endTime);
return 0;
} else {
int count = 0;
double cost = 0;
for (MessageRecord messageRecord : this.userRecords.sendMessageRecords)
count += work.what_num(messageRecord.message);
if (count < 4)
cost = 0.1 * count;
else if (count < 6)
cost = 0.3 + (count - 3) * 0.2;
else
cost = 0.3 + 0.4 + (count - 5) * 0.3;
return cost;
}
}
UserRecords getUserRecords() {
return userRecords;
}
void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
double getBalance() {
return balance;
}
ChargeMode getChargeMode() {
return chargeMode;
}
void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
String getNumber() {
return number;
}
void setNumber(String number) {
this.number = number;
}
}
// MessageRecord（短信记录）
class MessageRecord extends CommunicationRecord {
String message;
String getMessage() {
return message;
}
void setMessage(String message) {
this.message = message;
}
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
public class Main {
public static void main(String[] args) {
work work = new work();
work.tran();
work.start_work();
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.3 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneInCityRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.1 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandPhoneIInlandRule extends CallChargeRule {
@Override
double callCost(ArrayList<CallRecord> callRecords) {
double cost = 0.0;
for (CallRecord callRecord : callRecords)
cost += 0.6 * work.howlong(callRecord.startTime, callRecord.endTime);
return cost;
}
}
class LandlinePhoneCharging extends ChargeMode {
double monthlyRent = 20;
@Override
ArrayList<ChargeRule> getChargeRules() {
return null;
}
@Override
void setChargeRules(ArrayList<ChargeRule> chargeRules) {
}
@Override
double getMonthlyRent() {
return monthlyRent;
}
}
abstract class CommunicationRecord {
String callingNumber;//拨打号码
String answerNumber;//接听号码
abstract String getCallingNumber();
abstract void setCallingNumber(String callingNumber);
abstract String getAnswerNumber();
abstract void setAnswerNumber(String answerNumber);
}
abstract class ChargeRule {
}
//ChargeMode是计费方式
class ChargeMode {
ArrayList<ChargeRule> chargeRules = new ArrayList<>();
double MonthlyRent;
double ccc, ccp, ccl;//市内拨打电话，省内长途，国内长途
double cp_, cl_;//省内漫游打电话,省外漫游拨打
double rp_;//省外漫游接听
public ChargeMode(int model) {
if (model == 0) {
MonthlyRent = 20;
rp_ = 0;
ccc = 0.1;
ccp = 0.3;
ccl = 0.6;
}
if (model == 1) {
MonthlyRent = 15;
ccc = 0.1;
ccp = 0.2;
ccl = 0.3;
cp_ = 0.3;
rp_ = 0.3;
cl_ = 0.6;
}
}
public ChargeMode() {
}
ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
double getMonthlyRent() {
return MonthlyRent;
}
}
abstract class CallChargeRule extends ChargeRule {
abstract double callCost(ArrayList<CallRecord> callRecords);
}
//CallRecord（通话记录类）包含属性：
//通话的起始、结束时间以及 拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
//区号用于记录在哪个地点拨打和接听的电话。对于座机，就是本机区号。
// 如果是手机号，则接打地点的区号和本机的开户地区会有差异。
class CallRecord extends CommunicationRecord {
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
@Override
String getCallingNumber() {
return callingNumber;
}
@Override
void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
@Override
String getAnswerNumber() {
return answerNumber;
}
@Override
void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
Date getStartTime() {
return startTime;
}
void setStartTime(Date startTime) {
this.startTime = startTime;
}
Date getEndTime() {
return endTime;
}
void setEndTime(Date endTime) {
this.endTime = endTime;
}
String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}类图与分析
由于本次代码是由上次的基础上添加而来，所以也继承了复杂度过高的问题，有非常大的改进空间。
采坑心得
- 座机号有3位的，如北京区号为010，记得区分
- 正则匹配的时候，应该用较复杂的正则进行校验是否存在，再用比较简单的正则进行捕获。
- 时间之间的计算可以用getTime()方法相减，得出的是它们相差的秒数。
改进建议
整个系列的代码都存在复杂度过高的问题，改进空间非常大，增加代码易读性的路程任重道远。
总结：
老师最近几周讲起了代码规范性和结构的设计等，对把代码设计好有一定的帮助。下一步打算用老师讲的javafx把我的农夫过河实验给做好。
浙公网安备 33010602011771号