Java 第三階段總結
阿新 • • 發佈：2022-12-10
前言
這幾次的PTA相對於前面的多邊形來說，我覺得更簡單了。因為給了對應的類圖，只需要弄明白每個類的作用，就很好寫了。而且老師給的時間也很充足，不存在沒寫完的情況，只不過要多注意細節，特別是正則表示式的判斷，這部分很重要。
知識點主要考察的是繼承、多型以及一些庫類的應用。
設計分析
7-1 電信計費系列1-座機計費
實現一個簡單的電信計費程式：
假設南昌市電信分公司針對市內座機使用者採用的計費方式：
月租20元，接電話免費，市內撥打電話0.1元/分鐘，省內長途0.3元/分鐘，國內長途撥打0.6元/分鐘。不足一分鐘按一分鐘計。
南昌市的區號：0791，江西省內各地市區號包括：0790~0799以及0701。
輸入格式:
輸入資訊包括兩種型別
- 逐行輸入南昌市使用者開戶的資訊，每行一個使用者，
格式：u-號碼 計費型別 （計費型別包括：0-座機 1-手機實時計費 2-手機A套餐）
例如：u-079186300001 0
座機號碼除區號外由是7-8位數字組成。
本題只考慮計費型別0-座機計費，電信系列2、3題會逐步增加計費型別。 - 逐行輸入本月某些使用者的通訊資訊，通訊資訊格式：
座機呼叫座機：t-主叫號碼 接聽號碼 起始時間 結束時間
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四項內容之間以一個英文空格分隔，
時間必須符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat類。
以上兩類資訊，先輸入所有開戶資訊，再輸入所有通訊資訊，最後一行以“end”結束。
注意：
本題非法輸入只做格式非法的判斷，不做內容是否合理的判斷（時間除外，否則無法計算），比如：
- 輸入的所有通訊資訊均認為是同一個月的通訊資訊，不做日期是否在同一個月還是多個月的判定，直接將通訊費用累加，因此月租只計算一次。
- 記錄中如果同一電話號碼的多條通話記錄時間出現重合，這種情況也不做判斷，直接 計算每條記錄的費用並累加。
- 使用者區號不為南昌市的區號也作為正常使用者處理。
輸出格式:
根據輸入的詳細通訊資訊，計算所有已開戶的使用者的當月費用（精確到小數點後2位，
單位元）。假設每個使用者初始餘額是100元。
每條通訊資訊單獨計費後累加，不是將所有時間累計後統一計費。
格式：號碼+英文空格符+總的話費+英文空格符+餘額
每個使用者一行，使用者之間按號碼字元從小到大排序。
錯誤處理：
輸入資料中出現的不符合格式要求的行一律忽略。
輸入樣例:
在這裡給出一組輸入。例如：
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.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
ArrayList<User> users = new ArrayList<>();
while(!str.equals("end")) {
try {
Inputer.disposeStr(users,str);
} catch (Exception e) {}
str = in.nextLine();
}
//compare()接受兩個同類型的不同物件進行比較
users.sort(new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
return 1;
} else {
return -1;
}
}
});
for (User u : users) {
String temp = String.format("%.1f",u.calCost());
double cost = Double.parseDouble(temp);
temp = String.format("%.1f",u.calBalance());
double balance = Double.parseDouble(temp);
System.out.println(u.getNumber() + " "+ cost+" "+balance);
}
in.close();
}
}
/**
* 使用者類
* 包括手機和座機使用者
* 手機使用者有兩種計費方式 1,2
* 座機使用者只有一種即 0 固定月租為20
*/
class User {
//使用者記錄
private UserRecords userRecords = new UserRecords();
//餘額
private double balance = 100;
//計費方式
private ChargeMode chargeMode;
//號碼
private String number;
//get、set方法
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
/**
* 計算每月餘額
* @return
*/
public double calBalance() {
return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
}
/**
* 計算每月消費
* @return
*/
public double calCost() {
return chargeMode.calCost(userRecords);
}
}
/**
* 使用者記錄類，儲存使用者各種通話、簡訊的記錄
*/
class UserRecords {
//市內撥打電話、省內（不含市內）撥打電話、省外撥打電話的記錄
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//市內接聽電話、省內（不含市內）接聽電話、省外接聽電話的記錄
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//傳送簡訊、接收簡訊的記錄
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
/**
* 新增市內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
/**
* 新增省內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
/**
* 新增省外撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
/**
* 新增市內接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
/**
* 新增省內接收電話記錄
* @param callRecord 通話記錄
*/
public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
/**
* 新增省外接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
/**
* 添加發送簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addSendMessageRecords(MessageRecord callRecord) {
sendMessageRecords.add(callRecord);
}
/**
* 新增接受簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addReceiveMessageRecords(MessageRecord callRecord) {
receiveMessageRecords.add(callRecord);
}
//以下為各種屬性的set、get方法
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
this.callingInCityRecords = callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
this.callingInProvinceRecords = callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
this.callingInLandRecords = callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
this.answerInCityRecords = answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
this.answerInProvinceRecords = answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
this.answerInLandRecords = answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
this.sendMessageRecords = sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
this.receiveMessageRecords = receiveMessageRecords;
}
}
/**
* 簡訊記錄類
*/
class MessageRecord extends CommunicationRecord{
//記錄簡訊的資訊
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
/**
* 座機撥打省內電話的計費規則類
*/
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.3;
}
return sum;
}
}
/**
* 座機撥打省外電話的計費規則類
*/
class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) {
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.6;
}
return sum;
}
}
/**
* 座機撥打市內電話的計費規則類
*/
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
//每條通話記錄計算總額
for (CallRecord call : userRecords.getCallingInCityRecords()) {
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
// System.out.print(second);
if (second < 0) {
continue;
}
double minute = (int) second / 60;
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.1;
}
return sum;
}
}
/**
* 該類為座機計費方式的計算
*/
class LandlinePhoneCharging extends ChargeMode {
//座機月租固定為20元
private double monthlyRent = 20;
/**
* 建構函式 座機計費的計費方式
*/
public LandlinePhoneCharging() {
super();
chargeRules.add(new LandPhoneInCityRule());
chargeRules.add(new LandPhoneInProvinceRule());
chargeRules.add(new LandPhoneInLandRule());
}
/**
* 計算每月通話傳送簡訊的消費
*/
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (ChargeRule rule : chargeRules) {
sumCost += rule.calCost(userRecords);
}
return sumCost;
}
/**
* 返回每月月租
*/
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
/**
* 對輸入進行處理的一個類
*/
class Inputer {
/**
* 對輸入的每一行資訊做處理 利用正則判斷格式對錯 以及 是否符合要求
*
* @param str 傳入輸入的資訊
*/
public static void disposeStr(ArrayList<User> users, String str) {
String[] s = str.split(" ");
String flag = str.substring(0, 1);
if (flag.equals("u")) {
if (s[0].matches("^u-(079[0-9]|0701)\\d{7,8}$") && s[1].matches("^[0-2]$")) {
dealUsers(users, str);
}
} else if (flag.equals("t")) { // 是否需要考慮 時間1比時間2大的情況
if (s[0].matches("^t-(079[0-9]|0701)\\d{7,8}$") && s[1].matches("^[0-9]{10,12}$")) {
if (matchDate(s[2]) && matchDate(s[4]) && matchTime(s[3]) && matchTime(s[5])) {
dealRecords(users, str);
}
}
} else if (flag.equals("m")) {
}
}
/**
* 對使用者的資訊做處理 目前只包含座機使用者之間的處理
*
* @param user 使用者表
* @param str 使用者資訊
*/
public static void dealUsers(ArrayList<User> users, String str) {
User u = new User();
String in[] = str.split(" ");
String number = in[0].substring(2);
// 先檢查號碼是否重複 不可以有重複號碼
for (User user : users) {
if (user.getNumber().equals(number) ) {
return;
}
}
if (in[1].equals("0")) { // 座機使用者
u.setChargeMode(new LandlinePhoneCharging());
} else if (in[1].equals("1")) {// 手機使用者 計費方式1
} else if (in[1].equals("2")) {// 手機使用者 計費方式2
}
u.setNumber(number);
users.add(u);
}
/**
* 對通訊的內容做處理d
* @param user 使用者表
* @param str 通訊記錄 包括通話和簡訊
*/
public static void dealRecords(ArrayList<User> user,String str) {
CallRecord call = new CallRecord();
String in[] = str.split(" ");
String number = in[0].substring(2);
// for(int i=0;i<in.length;i++)
// System.out.println(in[i]+" ");
User callu = null,answeru = null;
//先判斷撥打 或者接聽的使用者是否在使用者表內 即該次通話是否合理
for(User i:user) {
if(i.getNumber().equals(number)) {
callu = i;
}
if(i.getNumber().equals(in[1])) {
answeru = i;
}
}
call.setCallingAddressAreaCode(in[0].substring(2,6));
call.setAnswerAddressAreaCode(in[1].substring(0,4));
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
call.setStartTime(simpleDateFormat.parse(in[2] + " " + in[3]));
call.setEndTime(simpleDateFormat.parse(in[4] + " " + in[5]));
} catch (ParseException e) {
}
if(callu!=null) {
if(matchAdressArea(call.getAnswerAddressAreaCode()) == 1) {
callu.getUserRecords().addCallingInCityRecords(call);
}
else if(matchAdressArea(call.getAnswerAddressAreaCode()) == 2) {
callu.getUserRecords().addCallingInProvinceRecords(call);
}else callu.getUserRecords().addCallingInLandRecords(call);
}
if(answeru!=null) {
if(matchAdressArea(call.getCallingAddressAreaCode()) == 1) {
callu.getUserRecords().addAnswerInCityRecords(call);
}
else if(matchAdressArea(call.getCallingAddressAreaCode()) == 2) {
callu.getUserRecords().aaddAnswerInProvinceRecords(call);
}else callu.getUserRecords().addAnswerInLandRecords(call);
}
}
//判斷通話型別
public static void getCallType() {
}
//匹配區號的地域 是否為市內1、省內2、省外3
public static int matchAdressArea(String str) {
if(str.matches("^0791$")) {
return 1;
}else if(str.matches("^(079[023456789]|0701)$")){
return 2;
}else return 3;
}
// 匹配日期
public static boolean matchDate(String str) {
String[] data = str.split("\\.");
//先判斷大致格式
String regEx = "^(19|20)\\d\\d\\.([1-9]|1[0-2])\\.([1-9]|[12][0-9]|3[01])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
//下面判斷日期是否合理 以及潤平年的判斷
int year = Integer.parseInt(data[0]);
int month = Integer.parseInt(data[1]);
int day = Integer.parseInt(data[2]);
int[] days = {0,31,28,31,30,31,30,31,31,30,31,30,31};//平年
if(isLeapYear(year)) {
days[2]=29;
}
//月日的判斷
for(int i=1;i<=12;i++) {
if(day>days[month] || day<=0) {
return false;
}
}
return true;
}
//閏年
public static boolean isLeapYear(int year) {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
// 匹配時間
public static boolean matchTime(String str) {
String regEx = "^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
return true;
}
//對時間進行處理
public static void dealDate(String[] inputs) {
}
}
/**
* 抽象類、通訊記錄類
* 包括通話和傳送簡訊,記錄兩者的號碼
*/
abstract class CommunicationRecord {
//記錄號碼
protected String callingNumber;
protected String answerNumbe;
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumbe() {
return answerNumbe;
}
public void setAnswerNumbe(String answerNumbe) {
this.answerNumbe = answerNumbe;
}
}
/**
* 計費規則抽象類
*/
abstract class ChargeRule {
abstract public double calCost(UserRecords userRecords);
}
/**
* 計費方式的抽象類
*/
abstract class ChargeMode {
//計費方式所包含的各種計費規則的集合
protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
public abstract double calCost(UserRecords userRecords);
/**
* @return 返回月租
*/
public abstract double getMonthlyRent();
//計費規則的get、set方法
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
}
/**
* 通話記錄類
*
*/
class CallRecord extends CommunicationRecord{
//通話的起始、結束時間
private Date startTime;
private Date endTime;
//撥號地點的區號、接聽地點的區號
//區號用於記錄在哪個地點撥打和接聽的電話 座機無法移動，就是本機區號，如果是手機號，則會有差異。
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord() {
}
public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
super();
this.startTime = startTime;
this.endTime = endTime;
this.callingAddressAreaCode = callingAddressAreaCode;
this.answerAddressAreaCode = answerAddressAreaCode;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}
/**
* 撥打電話計費規則抽象類
*/
abstract class CallChargeRule extends ChargeRule{
}
報表：
7-1 電信計費系列2-手機+座機計費
實現南昌市電信分公司的計費程式，假設該公司針對手機和座機使用者分別採取了兩種計費方案，分別如下：
- 針對市內座機使用者採用的計費方式（與電信計費系列1內容相同）：
月租20元，接電話免費，市內撥打電話0.1元/分鐘，省內長途0.3元/分鐘，國內長途撥打0.6元/分鐘。不足一分鐘按一分鐘計。
假設本市的區號：0791，江西省內各地市區號包括：0790~0799以及0701。 - 針對手機使用者採用實時計費方式：
月租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
輸入：
輸入資訊包括兩種型別
- 逐行輸入南昌市使用者開戶的資訊，每行一個使用者，含手機和座機使用者
格式：u-號碼 計費型別 （計費型別包括：0-座機 1-手機實時計費 2-手機A套餐）
例如：u-079186300001 0
座機號碼由區號和電話號碼拼接而成，電話號碼包含7-8位數字，區號最高位是0。
手機號碼由11位數字構成，最高位是1。
本題在電信計費系列1基礎上增加型別1-手機實時計費。
手機設定0或者座機設定成1，此種錯誤可不做判斷。 - 逐行輸入本月某些使用者的通訊資訊，通訊資訊格式：
座機呼叫座機：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元。
每條通訊、簡訊資訊均單獨計費後累加，不是將所有資訊累計後統一計費。
格式：號碼+英文空格符+總的話費+英文空格符+餘額
每個使用者一行，使用者之間按號碼字元從小到大排序。
錯誤處理：
輸入資料中出現的不符合格式要求的行一律忽略。
輸入樣例:
在這裡給出一組輸入。例如：
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 java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
ArrayList<User> users = new ArrayList<>();
while(!str.equals("end")) {
try {
Inputer.disposeStr(users,str);
} catch (Exception e) {}
str = in.nextLine();
}
//compare()接受兩個同類型的不同物件進行比較
//排序 方法重寫
users.sort(new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
if (u1.getNumber().charAt(0) == '0' && u2.getNumber().charAt(0) != '0') {
return -1;
} else if (u1.getNumber().charAt(0) != '0' && u2.getNumber().charAt(0) == '0') {
return 1;
}
if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
return 1;
} else {
return -1;
}
}
});
//對每個使用者輸出費用
for (User u : users) {
//格式化 保留兩位小數
String temp = String.format("%.1f",u.calCost());
double cost = Double.parseDouble(temp);
temp = String.format("%.1f",u.calBalance());
double balance = Double.parseDouble(temp);
System.out.println(u.getNumber() + " "+ cost+" "+balance);
}
in.close();
}
}
/**
* 撥打電話計費規則抽象類
*/
abstract class CallChargeRule extends ChargeRule{
}
/**
* 通話記錄類
*
*/
class CallRecord extends CommunicationRecord {
// 通話的起始、結束時間
private Date startTime;
private Date endTime;
// 撥號地點的區號、接聽地點的區號
// 區號用於記錄在哪個地點撥打和接聽的電話 座機無法移動，就是本機區號，如果是手機號，則會有差異。
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord(String[] in) {
super();
String st1 = null, st2 = null, ed1 = null, ed2 = null; //分別記錄時間
if (in.length == 6) { // 座機打座機
st1 = in[2];
st2 = in[4];
ed1 = in[3];
ed2 = in[5];
if (in[0].length() == 10) { // 3位區號 7位座機號 4 7 |3 8
callingAddressAreaCode = in[0].substring(2, 5);
answerAddressAreaCode = in[1].substring(0, 3);
} else {
callingAddressAreaCode = in[0].substring(2, 6);
answerAddressAreaCode = in[1].substring(0, 4);
}
} else if (in.length == 7) { // 座機打手機或- 座機打手機
st1 = in[3];
st2 = in[5];
ed1 = in[4];
ed2 = in[6];
if (in[0].charAt(2) != '0') { //shoujida
if (in[2].length() == 10) {
answerAddressAreaCode = in[2].substring(0, 3);
} else {
answerAddressAreaCode = in[2].substring(0, 4);
}
callingAddressAreaCode = in[1];
} else { //座機打手機
if (in[0].length() == 10) {
callingAddressAreaCode = in[0].substring(2, 5);
} else {
callingAddressAreaCode = in[0].substring(2, 6);
}
answerAddressAreaCode = in[2];
}
} else if (in.length == 8) { // 手機打手機
st1 = in[4];
st2 = in[6];
ed1 = in[5];
ed2 = in[7];
callingAddressAreaCode = in[1];
answerAddressAreaCode = in[3];
}
// 時間
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
startTime = simpleDateFormat.parse(st1 + " " + ed1);
endTime = simpleDateFormat.parse(st2 + " " + ed2);
} catch (ParseException e) {
}
}
// 建構函式
public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
super();
this.startTime = startTime;
this.endTime = endTime;
this.callingAddressAreaCode = callingAddressAreaCode;
this.answerAddressAreaCode = answerAddressAreaCode;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}
/**
* 計費方式的抽象類
*/
abstract class ChargeMode {
//計費方式所包含的各種計費規則的集合
//
protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
/**
* 計算每月通話 傳送簡訊的消費
*/
public abstract double calCost(UserRecords userRecords);
/**
* @return 返回月租
*/
public abstract double getMonthlyRent();
//計費規則的get、set方法
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
}
/**
* 計費規則抽象類
*/
abstract class ChargeRule {
abstract public double calCost(UserRecords userRecords);
}
/**
* 抽象類、通訊記錄類
* 包括通話和傳送簡訊,記錄兩者的號碼
*/
abstract class CommunicationRecord {
//記錄號碼
protected String callingNumber;
protected String answerNumbe;
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumbe() {
return answerNumbe;
}
public void setAnswerNumbe(String answerNumbe) {
this.answerNumbe = answerNumbe;
}
}
/**
* 對輸入進行處理的一個類
*/
class Inputer {
/**
* 對輸入的每一行資訊做處理 利用正則判斷格式對錯 以及 是否符合要求
*
* @param str 傳入輸入的資訊
*/
public static void disposeStr(ArrayList<User> users, String str) {
String[] s = str.split(" ");
String flag = str.substring(0, 1);
if (flag.equals("u")) {
if(str.matches("^u-(0[0-9]{10,11}\\s[0]|1\\d{10}\\s[1])$")) {
dealUsers(users, str);
}
// if ((s[0].matches("^u-(079[0-9]|0701)\\d{7,8}$") || s[0].matches("^u-1[0-9]{10}$"))
// && s[1].matches("^[0-2]$")) {
// dealUsers(users, str);
// }
} else if (flag.equals("t")) { // 是否需要考慮 時間1比時間2大的情況
if(str.matches("^t-0[0-9]{9,11}\\s"+"0[0-9]{9,11}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}$")){
// if (s[0].matches("^t-(010|\\d{4})\\d{7,8}$") && s[1].matches("^[0-9]{10,12}$")) {
if (matchDate(s[2]) && matchDate(s[4]) && matchTime(s[3]) && matchTime(s[5])) {
dealRecords(users, str);
}
}
if(str.matches("^t-0[0-9]{9,11}\\s[1]\\d{10}\\s(\\d){3,4}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}$")){
// if (s[0].matches("^t-(010|\\d{4})\\d{7,8}$") && s[1].matches("^1[0-9]{10}$")) {
if (matchDate(s[3]) && matchDate(s[5]) && matchTime(s[4]) && matchTime(s[6])) {
dealRecords(users, str);
}
}
if(str.matches("^t-1(\\d){10}\\s(\\d){3,4}\\s0[0-9]{9,11}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}$")){
// if (s[0].matches("^t-1[0-9]{10}$") && s[2].matches("^(010|\\d{4})\\d{7,8}$") ) {
if (matchDate(s[3]) && matchDate(s[5]) && matchTime(s[4]) && matchTime(s[6])) {
dealRecords(users, str);
}
}
if(str.matches("^t-1(\\d){10}\\s\\s(\\d){3,4}\\s1(\\d){10}\\s(\\d){3,4}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}\\s\\d{4}.\\d{1,2}.\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}$")){
// if (s[0].matches("^t-1[0-9]{10}$") && s[2].matches("^1[0-9]{10}$")) {
if (matchDate(s[4]) && matchDate(s[6]) && matchTime(s[5]) && matchTime(s[7])) {
dealRecords(users, str);
}
}
} else if (flag.equals("m")) {
}
}
/**
* 對使用者的資訊做處理 目前只包含座機使用者之間的處理
*
* @param user 使用者表
* @param str 使用者資訊
*/
public static void dealUsers(ArrayList<User> users, String str) {
User u = new User();
String in[] = str.split(" ");
String number = in[0].substring(2);
// 先檢查號碼是否重複 不可以有重複號碼
for (User user : users) {
if (user.getNumber().equals(number)) {
return;
}
}
u.setNumber(number);
if (in[1].equals("0")) { // 座機使用者
u.setChargeMode(new LandlinePhoneCharging());
} else if (in[1].equals("1")) { // 手機使用者 計費方式1
u.setChargeMode(new MobilePhoneCharging());
} else if (in[1].equals("2")) { // 手機使用者 計費方式2
}
users.add(u);
}
/**
* 對通訊的內容做處理d
*
* @param user 使用者表
* @param str 通訊記錄 包括通話 -簡訊
*/
public static void dealRecords(ArrayList<User> user, String str) {
String in[] = str.split(" ");
String number = in[0].substring(2);
// 對字元處理得到該次通話記錄
CallRecord call = new CallRecord(in);
int flag = 0;
if(in.length==8)
flag = 2;
else if(in.length==6)
flag = 1;
else if(in.length==7 ) {
if(in[1].length()<=4)
flag = 2;
else flag = 1;
}
User callu = null, answeru = null;
// 先判斷撥打 或者接聽的使用者是否在使用者表內 即該次通話是否合理
for (User i : user) {
if (i.getNumber().equals(number)) {
callu = i;
}
if (i.getNumber().equals(in[flag])) {
answeru = i;
}
}
// 該次通話 的撥打人在使用者表內
if (callu != null) {
if (matchAdressArea(call.getCallingAddressAreaCode()) == 1) {
callu.getUserRecords().addCallingInCityRecords(call); //市內撥打
} else if (matchAdressArea(call.getCallingAddressAreaCode()) == 2) {
callu.getUserRecords().addCallingInProvinceRecords(call);//省內撥打
} else
callu.getUserRecords().addCallingInLandRecords(call);//省外撥打
}
// 該次通話 的接聽人在使用者表內
if (answeru != null) {
if (matchAdressArea(call.getAnswerAddressAreaCode()) == 1) {
answeru.getUserRecords().addAnswerInCityRecords(call); //市內接聽
} else if (matchAdressArea(call.getAnswerAddressAreaCode()) == 2) {
answeru.getUserRecords().aaddAnswerInProvinceRecords(call); //省內接聽
} else
answeru.getUserRecords().addAnswerInLandRecords(call); //省外接聽
}
}
// 判斷通話型別
public static void getCallType() {
}
// 匹配區號的地域 是否為市內1、省內2、省外3
public static int matchAdressArea(String str) {
if (str.matches("^0791$")) {
return 1;
} else if (str.matches("^(079[023456789]|0701)$")) {
return 2;
} else
return 3;
}
// 匹配日期
public static boolean matchDate(String str) {
String[] data = str.split("\\.");
// 先判斷大致格式
String regEx = "^(19|20)\\d\\d\\.([1-9]|1[0-2])\\.([1-9]|[12][0-9]|3[01])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
// 下面判斷日期是否合理 以及潤平年的判斷
int year = Integer.parseInt(data[0]);
int month = Integer.parseInt(data[1]);
int day = Integer.parseInt(data[2]);
int[] days = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };// 平年
if (isLeapYear(year)) {
days[2] = 29;
}
// 月日的判斷
for (int i = 1; i <= 12; i++) {
if (day > days[month] || day <= 0) {
return false;
}
}
return true;
}
// 閏年
public static boolean isLeapYear(int year) {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
// 匹配時間 匹配 01? 還是1
public static boolean matchTime(String str) {
String regEx = "^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
return true;
}
// 對時間進行處理
public static void dealDate(String[] inputs) {
}
}
/**
* 該類為座機計費方式的計算
*/
class LandlinePhoneCharging extends ChargeMode {
//座機月租固定為20元
private double monthlyRent = 20;
/**
* 建構函式 座機計費的計費方式
*/
public LandlinePhoneCharging() {
super();
chargeRules.add(new LandPhoneInCityRule());
chargeRules.add(new LandPhoneInProvinceRule());
chargeRules.add(new LandPhoneInLandRule());
}
/**
* 計算每月通話 傳送簡訊的消費
*/
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (ChargeRule rule : chargeRules) {
sumCost += rule.calCost(userRecords);
}
return sumCost;
}
/**
* 返回每月月租
*/
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
/**
* 座機撥打市內電話的計費規則類
*/
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
//每條通話記錄計算總額
for (CallRecord call : userRecords.getCallingInCityRecords()) {//市內撥打 接免費
int flag = Inputer.matchAdressArea(call.getAnswerAddressAreaCode());
// .getTime()返回毫秒數 即 /1000
double second = (call.getEndTime().getTime() - call.getStartTime().getTime() ) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
if (second % 60 != 0) {
minute += 1;
}
if (flag == 1) // 打市內
sum += minute * 0.1;
else if (flag == 2)// 打省內
sum += minute * 0.3;
else if (flag == 3)// 打省外
sum += minute * 0.6;
}
return sum;
}
}
/**
* 座機撥打省外電話的計費規則類
*/
class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) {
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.6;
}
return sum;
}
}
/**
* 座機撥打省內電話的計費規則類
*/
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.3;
}
return sum;
}
}
/**
* 簡訊記錄類
*/
class MessageRecord extends CommunicationRecord{
//記錄簡訊的資訊
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
/**
* 手機計費方式計算
*/
class MobilePhoneCharging extends ChargeMode {
//手機月租固定為15元
private double monthlyRent = 15;
//手機計費
public MobilePhoneCharging(){
super();
chargeRules.add(new MobilePhoneInCityRule()); //市內打市內
chargeRules.add(new MobilePhoneInProvinceRule());//市內打省內
chargeRules.add(new MobilePhoneInLandRule());//市內打省外
// chargeRules.add(new MobilePhoneRoamingInProvinceRule());//省內漫遊打電話
// chargeRules.add(new MobilePhoneRoamingInLandRule());//省外漫遊接
// chargeRules.add(new MobilePhoneRoamingInLandCallRule());//省外漫遊打
}
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sumCost = 0;
for (ChargeRule rule : chargeRules) {
sumCost += rule.calCost(userRecords);
}
return sumCost;
}
@Override
public double getMonthlyRent() {
// TODO 自動生成的方法存根
return monthlyRent;
}
}
/**
* 手機市內撥打市內計費規則
*/
class MobilePhoneInCityRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sum = 0;
// 每條通話記錄計算總額
for (CallRecord call : userRecords.getCallingInCityRecords()) {// 市內撥打
int flag = Inputer.matchAdressArea(call.getAnswerAddressAreaCode());
// .getTime()返回毫秒數 即 /1000
double second = (call.getEndTime().getTime() - call.getStartTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
if (second % 60 != 0) {
minute += 1;
}
if (flag == 1) // 打市內
sum += minute * 0.1;
else if (flag == 2)// 打省內
sum += minute * 0.2;
else if (flag == 3)// 打省外
sum += minute * 0.3;
}
return sum;
}
}
/**
* 手機市內撥打省外計費規則
*/
class MobilePhoneInLandRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sum = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) { //省外撥打
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.6;
}
for (CallRecord call : userRecords.getAnswerInLandRecords()) {//省外接聽
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.3;
}
return sum;
}
}
/**
* 手機市內撥打省內計費規則
*/
class MobilePhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sum = 0;
for (CallRecord call : userRecords.getCallingInProvinceRecords()) { //省內撥打
// .getTime()返回毫秒數 即 /1000
double second = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (second < 0) {
continue;
}
double minute = (int) second / 60;
//不足一分鐘按一分鐘計算
if (second % 60 != 0) {
minute += 1;
}
sum += minute * 0.3;
}
return sum;
}
}
/**
* 使用者類 包括手機和座機使用者 手機使用者有兩種計費方式 1,2 座機使用者只有一種即 0 固定月租為20
*/
class User {
// 使用者記錄
private UserRecords userRecords = new UserRecords();
// 餘額
private double balance = 100;
// 計費方式
private ChargeMode chargeMode;
// 號碼
private String number;
// get、set方法
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
/**
* 計算每月餘額
*
* @return
*/
public double calBalance() {
return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
}
/**
* 計算每月消費
*
* @return
*/
public double calCost() {
return chargeMode.calCost(userRecords);
}
@Override
public String toString() {
return balance + " " + number;
}
}
/**
* 使用者記錄類，儲存使用者各種通話、簡訊的記錄
*/
class UserRecords {
//撥打市內電話、省內（不含市內）撥打電話、省外撥打電話的記錄
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//接聽市內電話、省內（不含市內）接聽電話、省外接聽電話的記錄
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//
// private ArrayList<CallRecord> answerIn = new ArrayList<CallRecord>();
// private ArrayList<CallRecord> answerInProvinceR = new ArrayList<CallRecord>();
//傳送簡訊、接收簡訊的記錄
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
/**
* 新增市內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
/**
* 新增省內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
/**
* 新增省外撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
/**
* 新增市內接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
/**
* 新增省內接收電話記錄
* @param callRecord 通話記錄
*/
public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
/**
* 新增省外接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
/**
* 添加發送簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addSendMessageRecords(MessageRecord callRecord) {
sendMessageRecords.add(callRecord);
}
/**
* 新增接受簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addReceiveMessageRecords(MessageRecord callRecord) {
receiveMessageRecords.add(callRecord);
}
//以下為各種屬性的set、get方法
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
this.callingInCityRecords = callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
this.callingInProvinceRecords = callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
this.callingInLandRecords = callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
this.answerInCityRecords = answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
this.answerInProvinceRecords = answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
this.answerInLandRecords = answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
this.sendMessageRecords = sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
this.receiveMessageRecords = receiveMessageRecords;
}
}
報表：
7-1 電信計費系列3-簡訊計費
實現一個簡單的電信計費程式，針對手機的簡訊採用如下計費方式：
- 接收簡訊免費，傳送簡訊0.1元/條，超過3條0.2元/條，超過5條0.3元/條。
- 如果一次傳送簡訊的字元數量超過10個，按每10個字元一條簡訊進行計算。
輸入：
輸入資訊包括兩種型別
- 逐行輸入南昌市手機使用者開戶的資訊，每行一個使用者。
格式：u-號碼 計費型別 （計費型別包括：0-座機 1-手機實時計費 2-手機A套餐 3-手機簡訊計費）
例如：u-13305862264 3
座機號碼由區號和電話號碼拼接而成，電話號碼包含7-8位數字，區號最高位是0。
手機號碼由11位數字構成，最高位是1。
本題只針對型別3-手機簡訊計費。 - 逐行輸入本月某些使用者的簡訊資訊，簡訊的格式：
m-主叫號碼，接收號碼，簡訊內容 （簡訊內容只能由數字、字母、空格、英文逗號、英文句號組成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上兩類資訊，先輸入所有開戶資訊，再輸入所有通訊資訊，最後一行以“end”結束。
輸出：
根據輸入的詳細簡訊資訊，計算所有已開戶的使用者的當月簡訊費用（精確到小數點後2位，單位元）。假設每個使用者初始餘額是100元。
每條簡訊資訊均單獨計費後累加，不是將所有資訊累計後統一計費。
格式：號碼+英文空格符+總的話費+英文空格符+餘額
每個使用者一行，使用者之間按號碼字元從小到大排序。
錯誤處理：
輸入資料中出現的不符合格式要求的行一律忽略。
本題只做格式的錯誤判斷，無需做內容上不合理的判斷，比如同一個電話兩條通訊記錄的時間有重合、開戶號碼非南昌市的號碼、自己給自己打電話等，此類情況都當成正確的輸入計算。但時間的輸入必須符合要求，比如不能輸入2022.13.61 28:72:65。
本題只考慮簡訊計費，不考慮通訊費用以及月租費。
輸入樣例:
在這裡給出一組輸入。例如：
u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end
輸出樣例:
在這裡給出相應的輸出。例如：
18907910010 0.3 99.7
程式碼：
點選檢視程式碼
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
ArrayList<User> users = new ArrayList<>();
while(!str.equals("end")) {
Inputer.disposeStr(users,str);
str = in.nextLine();
}
//compare()接受兩個同類型的不同物件進行比較
//排序 方法重寫
users.sort(new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
if (u1.getNumber().charAt(0) == '0' && u2.getNumber().charAt(0) != '0') {
return -1;
} else if (u1.getNumber().charAt(0) != '0' && u2.getNumber().charAt(0) == '0') {
return 1;
}
if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
return 1;
} else {
return -1;
}
}
});
//對每個使用者輸出費用
for (User u : users) {
//格式化 保留兩位小數
String temp = String.format("%.1f",u.calCost());
double cost = Double.parseDouble(temp);
temp = String.format("%.1f",u.calBalance());
double balance = Double.parseDouble(temp);
System.out.println(u.getNumber() + " "+ cost+" "+balance);
}
in.close();
}
}
/**
* 使用者類 包括手機和座機使用者 手機使用者有兩種計費方式 1,2 座機使用者只有一種即 0 固定月租為20
*/
class User {
// 使用者記錄
private UserRecords userRecords = new UserRecords();
// 餘額
private double balance = 100;
// 計費方式
private ChargeMode chargeMode;
// 號碼
private String number;
// get、set方法
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
/**
* 計算每月餘額
*
* @return
*/
public double calBalance() {
return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
}
/**
* 計算每月消費
*
* @return
*/
public double calCost() {
return chargeMode.calCost(userRecords);
}
@Override
public String toString() {
return balance + " " + number;
}
}
/**
* 使用者記錄類，儲存使用者各種通話、簡訊的記錄
*/
class UserRecords {
//撥打市內電話、省內（不含市內）撥打電話、省外撥打電話的記錄
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
//接聽市內電話、省內（不含市內）接聽電話、省外接聽電話的記錄
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
//傳送簡訊、接收簡訊的記錄
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
/**
* 新增市內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInCityRecords(CallRecord callRecord) {
callingInCityRecords.add(callRecord);
}
/**
* 新增省內撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
/**
* 新增省外撥打電話記錄
* @param callRecord 通話記錄
*/
public void addCallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
/**
* 新增市內接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
/**
* 新增省內接收電話記錄
* @param callRecord 通話記錄
*/
public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
/**
* 新增省外接收電話記錄
* @param callRecord 通話記錄
*/
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
/**
* 添加發送簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addSendMessageRecords(MessageRecord callRecord) {
sendMessageRecords.add(callRecord);
}
/**
* 新增接受簡訊記錄
* @param callRecord 簡訊記錄
*/
public void addReceiveMessageRecords(MessageRecord callRecord) {
receiveMessageRecords.add(callRecord);
}
//以下為各種屬性的set、get方法
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
this.callingInCityRecords = callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
this.callingInProvinceRecords = callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
this.callingInLandRecords = callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
this.answerInCityRecords = answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
this.answerInProvinceRecords = answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
this.answerInLandRecords = answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
this.sendMessageRecords = sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
this.receiveMessageRecords = receiveMessageRecords;
}
}
/**
* 對輸入進行處理的一個類
*/
class Inputer {
/**
* 對輸入的每一行資訊做處理 利用正則判斷格式對錯 以及 是否符合要求
*
* @param str 傳入輸入的資訊
*/
public static void disposeStr(ArrayList<User> users, String str) {
String[] s = str.split(" ");
String flag = str.substring(0, 1);
if (flag.equals("u")) {
if(str.matches("^u-((079[0-9]|0701)\\d{7,8}|1[0-9]{10})\\s[0-3]$")) {
dealUsers(users, str);
}
} else if (flag.equals("t")) { // 是否需要考慮 時間1比時間2大的情況
if (s[0].matches("^t-(010|\\d{4})\\d{7,8}$") && s[1].matches("^[0-9]{10,12}$")) {
if (matchDate(s[2]) && matchDate(s[4]) && matchTime(s[3]) && matchTime(s[5])) {
dealRecords(users, str);
}
}
if (s[0].matches("^t-(010|\\d{4})\\d{7,8}$") && s[1].matches("^1[0-9]{10}$")) {
if (matchDate(s[3]) && matchDate(s[5]) && matchTime(s[4]) && matchTime(s[6])) {
dealRecords(users, str);
}
}
if (s[0].matches("^t-1[0-9]{10}$") && s[2].matches("^(010|\\d{4})\\d{7,8}$") ) {
if (matchDate(s[3]) && matchDate(s[5]) && matchTime(s[4]) && matchTime(s[6])) {
dealRecords(users, str);
}
}
if (s[0].matches("^t-1[0-9]{10}$") && s[2].matches("^1[0-9]{10}$")) {
if (matchDate(s[4]) && matchDate(s[6]) && matchTime(s[5]) && matchTime(s[7])) {
dealRecords(users, str);
}
}
} else if (flag.equals("m")) {
if (str.matches("^m-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "[0-9a-zA-Z\\s\\.,]+$")) {
dealRecords(users,str);
}
}
}
/**
* 對使用者的資訊做處理 目前只包含座機使用者之間的處理
*
* @param user 使用者表
* @param str 使用者資訊
*/
public static void dealUsers(ArrayList<User> users, String str) {
User u = new User();
String in[] = str.split(" ");
String number = in[0].substring(2);
// 先檢查號碼是否重複 不可以有重複號碼
for (User user : users) {
if (user.getNumber().equals(number)) {
return;
}
}
u.setNumber(number);
if (in[1].equals("0")) { // 座機使用者
// u.setChargeMode(new LandlinePhoneCharging());
} else if (in[1].equals("1")) { // 手機使用者 計費方式1
// u.setChargeMode(new MobilePhoneCharging());
} else if (in[1].equals("3")) {
u.setChargeMode(new MessageCharging());
}
users.add(u);
}
/**
* 對通訊的內容做處理d
*
* @param user 使用者表
* @param str 通訊記錄 包括通話 -簡訊
*/
public static void dealRecords(ArrayList<User> user, String str) {
String in[] = str.split(" ");
String number = in[0].substring(2);
// CallRecord call = new CallRecord(in);;
// 對字元處理得到該次通話記錄
int flag = 0;
if(in.length==8)
flag = 2;
else if(in.length==6)
flag = 1;
else if(in.length==7 ) {
if(in[1].length()<=4)
flag = 2;
else flag = 1;
}
User callu = null, answeru = null;
// 先判斷撥打 或者接聽的使用者是否在使用者表內 即該次通話是否合理
for (User i : user) {
if (i.getNumber().equals(number)) {
callu = i;
}
if (i.getNumber().equals(in[flag])) {
answeru = i;
}
}
// // 該次通話 的撥打人在使用者表內
// if (callu != null) {
// if (matchAdressArea(call.getCallingAddressAreaCode()) == 1) {
// callu.getUserRecords().addCallingInCityRecords(call); //市內撥打
// } else if (matchAdressArea(call.getCallingAddressAreaCode()) == 2) {
// callu.getUserRecords().addCallingInProvinceRecords(call);//省內撥打
// } else
// callu.getUserRecords().addCallingInLandRecords(call);//省外撥打
// }
// // 該次通話 的接聽人在使用者表內
// if (answeru != null) {
// if (matchAdressArea(call.getAnswerAddressAreaCode()) == 1) {
// answeru.getUserRecords().addAnswerInCityRecords(call); //市內接聽
// } else if (matchAdressArea(call.getAnswerAddressAreaCode()) == 2) {
// answeru.getUserRecords().aaddAnswerInProvinceRecords(call); //省內接聽
// } else
// answeru.getUserRecords().addAnswerInLandRecords(call); //省外接聽
// }
if (str.charAt(0) == 'm') {
MessageRecord messageRecord = new MessageRecord(str);
if (callu != null) {
callu.getUserRecords().addSendMessageRecords(messageRecord);
;
}
if (answeru != null) {
callu.getUserRecords().addReceiveMessageRecords(messageRecord);
}
}
}
// 判斷通話型別
public static void getCallType() {
}
// 匹配區號的地域 是否為市內1、省內2、省外3
public static int matchAdressArea(String str) {
if (str.matches("^0791$")) {
return 1;
} else if (str.matches("^(079[023456789]|0701)$")) {
return 2;
} else
return 3;
}
// 匹配日期
public static boolean matchDate(String str) {
String[] data = str.split("\\.");
// 先判斷大致格式
String regEx = "^(19|20)\\d\\d\\.([1-9]|1[0-2])\\.([1-9]|[12][0-9]|3[01])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
// 下面判斷日期是否合理 以及潤平年的判斷
int year = Integer.parseInt(data[0]);
int month = Integer.parseInt(data[1]);
int day = Integer.parseInt(data[2]);
int[] days = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };// 平年
if (isLeapYear(year)) {
days[2] = 29;
}
// 月日的判斷
for (int i = 1; i <= 12; i++) {
if (day > days[month] || day <= 0) {
return false;
}
}
return true;
}
// 閏年
public static boolean isLeapYear(int year) {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
// 匹配時間 匹配 01? 還是1
public static boolean matchTime(String str) {
String regEx = "^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
if (!m.matches()) {
return false;
}
return true;
}
// 對時間進行處理
public static void dealDate(String[] inputs) {
}
}
/**
* 撥打電話計費規則抽象類
*/
abstract class CallChargeRule extends ChargeRule{
}
/**
* 通話記錄類
*
*/
class CallRecord extends CommunicationRecord {
// 通話的起始、結束時間
private Date startTime;
private Date endTime;
// 撥號地點的區號、接聽地點的區號
// 區號用於記錄在哪個地點撥打和接聽的電話 座機無法移動，就是本機區號，如果是手機號，則會有差異。
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord(String[] in) {
super();
String st1 = null, st2 = null, ed1 = null, ed2 = null; //分別記錄時間
if (in.length == 6) { // 座機打座機
st1 = in[2];
st2 = in[4];
ed1 = in[3];
ed2 = in[5];
if (in[0].length() == 10) { // 3位區號 7位座機號 4 7 |3 8
callingAddressAreaCode = in[0].substring(2, 5);
answerAddressAreaCode = in[1].substring(0, 3);
} else {
callingAddressAreaCode = in[0].substring(2, 6);
answerAddressAreaCode = in[1].substring(0, 4);
}
} else if (in.length == 7) { // 座機打手機或- 座機打手機
st1 = in[3];
st2 = in[5];
ed1 = in[4];
ed2 = in[6];
if (in[0].charAt(2) != '0') { //shoujida
if (in[2].length() == 10) {
answerAddressAreaCode = in[2].substring(0, 3);
} else {
answerAddressAreaCode = in[2].substring(0, 4);
}
callingAddressAreaCode = in[1];
} else { //座機打手機
if (in[0].length() == 10) {
callingAddressAreaCode = in[0].substring(2, 5);
} else {
callingAddressAreaCode = in[0].substring(2, 6);
}
answerAddressAreaCode = in[2];
}
} else if (in.length == 8) { // 手機打手機
st1 = in[4];
st2 = in[6];
ed1 = in[5];
ed2 = in[7];
callingAddressAreaCode = in[1];
answerAddressAreaCode = in[3];
}
// 時間
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
startTime = simpleDateFormat.parse(st1 + " " + ed1);
endTime = simpleDateFormat.parse(st2 + " " + ed2);
} catch (ParseException e) {
}
}
// 建構函式
public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
super();
this.startTime = startTime;
this.endTime = endTime;
this.callingAddressAreaCode = callingAddressAreaCode;
this.answerAddressAreaCode = answerAddressAreaCode;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}
/**
* 計費方式的抽象類
*/
abstract class ChargeMode {
//計費方式所包含的各種計費規則的集合
//
protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
/**
* 計算每月通話 傳送簡訊的消費
*/
public abstract double calCost(UserRecords userRecords);
/**
* @return 返回月租
*/
public abstract double getMonthlyRent();
//計費規則的get、set方法
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
}
/**
* 計費規則抽象類
*/
abstract class ChargeRule {
abstract public double calCost(UserRecords userRecords);
}
/**
* 抽象類、通訊記錄類
* 包括通話和傳送簡訊,記錄兩者的號碼
*/
abstract class CommunicationRecord {
//記錄號碼
protected String callingNumber;
protected String answerNumber;
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
class MessageCharging extends ChargeMode{
MessageCharging(){
super();
chargeRules.add(new MessageRule());
}
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sum = 0;
for (ChargeRule rule : chargeRules) {
sum += rule.calCost(userRecords);
}
return sum;
}
@Override
public double getMonthlyRent() {
// TODO 自動生成的方法存根
return 0;
}
}
/**
* 簡訊記錄類
*/
class MessageRecord extends CommunicationRecord{
//記錄簡訊的資訊
private String message;
MessageRecord(String in){
super();
this.message = in.substring(26);
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
class MessageRule extends ChargeRule {
@Override
public double calCost(UserRecords userRecords) {
// TODO 自動生成的方法存根
double sum = 0;
int number = 0; // 條數
// 每條通話記錄計算總額
for (MessageRecord call : userRecords.getSendMessageRecords()) {// 市內撥打
int length = call.getMessage().length();
if (length <= 10) {
number++;
} else {
number += length / 10;
if (length % 10 != 0) {
number++;
}
}
}
if (number <= 3) {
sum = number * 0.1;
} else if (number <= 5) {
sum = 0.3 + 0.2 * (number - 3);
} else {
sum = 0.7 + 0.3 * (number - 5);
}
return sum;
}
}
報表：
踩坑心得
- 在對陣列型別的資料進行處理時，應該明確陣列的大小。
- 在判斷區號時，有三位的區號，我這裡預設寫的是四位，所以一直有一個點過不去QAQ。
- 對使用者資訊處理時，要進行去重操作，並且要考慮到使用者撥打或接收的多種情況。
- 對每條通訊資訊處理的操作應該放在CallRecord類的建構函式裡面，inputer類只需對不合法的資訊做處理即可。
改進建議
總結
總的來說，這幾次的題目不難。主要都是根據老師給的類圖寫的，如果題目沒有給出類圖，自己是否能夠把類設計成這樣，還需要更加努力學習這方面的知識，即類的設計模式。