7-1 电信计费系列2-手机+座机计费 分数 80 作者 蔡轲 单位 南昌航空大学
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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更多内容详见附件：
分析：
增加手机后，题目难度稍微增加了一点，其一就是对于输入格式的判定，很通俗的一个方式就是以1开头的都是手机，以0开头的都是区号。所以我将添加用户的正则表达式改为"(^u-0[0-9]{10,11} [0|1]$)|(^u-1[0-9]{10} [0|1]$)"，而通话讯息则需要考虑手机打座机、手机打手机、座机打座机和座机打手机的四种情况，为了不在正则表达式上出错，我依旧选择将每种可能罗列出来，所以正则表达式看起来会很长，但其实其中有很大的比重都是时间的判别，如果你去细看正则表达式，实际上就是将每种情况枚举出来了，正则表达式为"(^t-[0]{1}[0-9]{9,11} ((0[0-9]{9,11})|(1[0-9]{10} 0[0-9]{2,3})) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$)|(^t-1[0-9]{10} 0[0-9]{2,3} ((0[0-9]{9,11})|(1[0-9]{10} 0[0-9]{2,3})) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$)"。将正则表达式的问题解决后，手机与座机不同的是部分地区接电话也会收费，座机是接电话固定不收费。所以需要将接电话收费的规则按照打电话收费类实现即可。主要可能稍微困难的就是通讯记录的存入，其实也好办，分类判别即可。就是将手机打座机、手机打手机、座机打座机和座机打手机的四种情况全部分析出来，然后按输入对号入座即可。如果不去这么判定，实际上你去存储区号时非常不方便，因为手机的状态栏要比座机天生多一个区号。各项类代码如下，有需要自行参考：
Main类
public class Main {
public static void main(String[] args) throws ParseException {
ArrayList<User> user=new ArrayList<>();
ArrayList<CallRecord> callRecords=new ArrayList<>();
SimpleDateFormat sdf=new SimpleDateFormat( "yyyy.MM.dd HH:mm:ss" );
Scanner input=new Scanner(System.in);
String ss1="(^u-0[0-9]{10,11} [0|1]$)|(^u-1[0-9]{10} [0|1]$)";
String ss2="(^t-[0]{1}[0-9]{9,11} ((0[0-9]{9,11})|(1[0-9]{10} 0[0-9]{2,3})) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$)|(^t-1[0-9]{10} 0[0-9]{2,3} ((0[0-9]{9,11})|(1[0-9]{10} 0[0-9]{2,3})) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) [0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) (([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$)";
String s1=input.nextLine();
String[] s01=s1.split(" ");
while(!s01[0].equals("end")){
if(!s1.matches(ss1)&&!s1.matches(ss2)){
s1=input.nextLine();
s01=s1.split(" ");
continue;
}
switch (s01[0].charAt(0)){
case 'u': {
boolean creat=true;
User u=new User();
u.setNumber(s01[0].substring(2));
u.setUserRecords(new UserRecords());
switch (s01[1]){
case "0":
u.setChargeMode(new LandlinePhoneCharging());
break;
case "1":
u.setChargeMode(new PhoneCharging());
break;
case "2":
break;
}
for(int i=0;i< user.size();i++){
if(user.get(i).getNumber().equals(u.getNumber())){
creat=false;
}
}
if(creat!=false)
user.add(u);
break;
}
case 't':{
String s0=s01[0].substring(2);
String num1_code = null;
String num1=null;
String num2_code = null;
String num2 = null;
Date start = null;
Date end = null;
boolean update=true;
for(int i=0;i< user.size();i++){
if(s0.equals(user.get(i).getNumber())){
update=false;
if(s0.startsWith("0")){
num1_code=s0.substring(0,4);
num1=s0;
if(s01[1].startsWith("1")){
num2_code=s01[2];
num2=s01[1];
start=sdf.parse(s01[3]+" "+s01[4]);
end=sdf.parse(s01[5]+" "+s01[6]);
}
else if(s01[1].startsWith("0")){
num2_code=s01[1].substring(0,4);
num2=s01[1];
start=sdf.parse(s01[2]+" "+s01[3]);
end=sdf.parse(s01[4]+" "+s01[5]);
}
}
else if(s0.startsWith("1")){
num1_code=s01[1];
num1=s0;
if(s01[2].startsWith("1")){
num2_code=s01[3];
num2=s01[2];
start=sdf.parse(s01[4]+" "+s01[5]);
end=sdf.parse(s01[6]+" "+s01[7]);
}
else if(s01[2].startsWith("0")){
num2_code=s01[2].substring(0,4);
num2=s01[2];
start=sdf.parse(s01[3]+" "+s01[4]);
end=sdf.parse(s01[5]+" "+s01[6]);
}
}
CallRecord c=new CallRecord();
c.setCallingAddressAreaCode(num1_code);
c.setAnswerAddressAreaCode(num2_code);
c.setCallingNumber(num1);
c.setAnswerNumber(num2);
c.setStartTime(start);
c.setEndTime(end);
if(num1_code.equals("0791")){
user.get(i).getUserRecords().addCallinglnCityRecords(c);
}
else if(num1_code.matches("(079\\d)|(0701)")){
user.get(i).getUserRecords().addCallinglnProvinceRecords(c);
}
else{
user.get(i).getUserRecords().addCallinglnLandRecords(c);
}
}
}
CallRecord c=new CallRecord();
if(s0.startsWith("1")){
num1_code=s01[1];
num2=s01[2];
if(s01[2].startsWith("0")){
num2_code=s01[2].substring(0,4);
start=sdf.parse(s01[3]+" "+s01[4]);
end=sdf.parse(s01[5]+" "+s01[6]);
}
else if(s01[2].startsWith("1")){
num2_code=s01[3];
start=sdf.parse(s01[4]+" "+s01[5]);
end=sdf.parse(s01[6]+" "+s01[7]);
}
}
else if(s0.startsWith("0")){
num2=s01[1];
num1_code=s0.substring(0,4);
if(s01[1].startsWith("1")){
num2_code=s01[2];
start=sdf.parse(s01[3]+" "+s01[4]);
end=sdf.parse(s01[5]+" "+s01[6]);
} else if (s01[1].startsWith("0")) {
num2_code=s01[1].substring(0,4);
start=sdf.parse(s01[2]+" "+s01[3]);
end=sdf.parse(s01[4]+" "+s01[5]);
}
}
if(!num2_code.equals("0791")&&!num2_code.matches("(079\\d)|(0701)")){
c.setAnswerAddressAreaCode(num2_code);
c.setAnswerNumber(num2);
c.setStartTime(start);
c.setEndTime(end);
for(int j=0;j< user.size();j++){
if(user.get(j).getNumber().equals(num2)){
if(num2_code.equals("0791")){
user.get(j).getUserRecords().addAnswerlnCityRecords(c);
}
else if(num2_code.matches("(079\\d)|(0701)")){
user.get(j).getUserRecords().addAnswerlnProvinceRecords(c);
}
else {
user.get(j).getUserRecords().addAnswerlnLandRecords(c);
}
}
}
}
}
}
s1=input.nextLine();
s01=s1.split(" ");
}
sort s=new sort();
s.Sort(user);
for(int i=0;i< user.size();i++){
if(user.get(i).getNumber().startsWith("0"))
System.out.println(user.get(i).getNumber()+" "+(float)user.get(i).calCost()+" "+(float)(user.get(i).getBalance()-user.get(i).calCost()-user.get(i).getChargeMode().getMonthlyRent()));
}
for(int i=0;i< user.size();i++){
if(user.get(i).getNumber().startsWith("1"))
System.out.println(user.get(i).getNumber()+" "+(float)user.get(i).calCost()+" "+(float)(user.get(i).getBalance()-user.get(i).calCost()-user.get(i).getChargeMode().getMonthlyRent()));
}
}
}CommunicationRecord类
abstract class CommunicationRecord{
private String callingNumber;
private String answerNumber;
String getCallingNumber(){
return this.callingNumber;
}
void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
String getAnswerNumber(){
return this.answerNumber;
}
void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}CallRecord类
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String 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;
}
}MessageRecord类
class MessageRecord{
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}ChargeRule类
abstract class ChargeRule{
}CallChargeRule类
abstract class CallChargeRule extends ChargeRule{
abstract double calCost(ArrayList<CallRecord> callRecords);
}LandPhonelnCityRule类
class LandPhonelnCityRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0;
for(int i=0;i<callRecords.size();i++){
if(callRecords.get(i).getAnswerAddressAreaCode().equals("0791")){
t=0.1;
}
else if(callRecords.get(i).getAnswerAddressAreaCode().matches("(079\\d)|(0701)")){
t=0.3;
}
else{
t=0.6;
}
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnlandRule类
class LandPhonelnlandRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0;
for(int i=0;i<callRecords.size();i++){
if(callRecords.get(i).getAnswerAddressAreaCode().equals("0791")){
t=0.1;
}
else if(callRecords.get(i).getAnswerAddressAreaCode().matches("(079\\d)|(0701)")){
t=0.3;
}
else{
t=0.6;
}
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}LandPhonelnProvinceRule类
class LandPhonelnProvinceRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0;
for(int i=0;i<callRecords.size();i++){
if(callRecords.get(i).getAnswerAddressAreaCode().equals("0791")){
t=0.1;
}
else if(callRecords.get(i).getAnswerAddressAreaCode().matches("(079\\d)|(0701)")){
t=0.3;
}
else{
t=0.6;
}
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}ChargeMode类
abstract class ChargeMode{
private ArrayList<ChargeRule> chargeRules=new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}LandlinePhoneCharging类
class LandlinePhoneCharging extends ChargeMode{
private double monthlyRent=20;
LandlinePhoneCharging(){
super();
getChargeRules().add(new LandPhonelnCityRule());
getChargeRules().add(new LandPhonelnProvinceRule());
getChargeRules().add(new LandPhonelnlandRule());
}
public double calCost(UserRecords userRecords){
double sum=0;
sum+=((LandPhonelnCityRule)getChargeRules().get(0)).calCost(userRecords.getCallinglnCityRecords());
sum+=((LandPhonelnProvinceRule)getChargeRules().get(1)).calCost(userRecords.getCallinglnProvinceRecords());
sum+=((LandPhonelnlandRule)getChargeRules().get(2)).calCost(userRecords.getCallinglnLandRecords());
return sum;
}
public double getMonthlyRent() {
return monthlyRent;
}
}PhonelnCityRule类
class PhonelnCityRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0;
for(int i=0;i<callRecords.size();i++){
if(callRecords.get(i).getAnswerAddressAreaCode().equals("0791")){
t=0.1;
}
else if(callRecords.get(i).getAnswerAddressAreaCode().matches("(079\\d)|(0701)")){
t=0.2;
}
else{
t=0.3;
}
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}PhonelnlandRule类
class PhonelnlandRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0.6;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}PhonelnProvinceRule类
class PhonelnProvinceRule extends CallChargeRule{
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0.3;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}PhoneInLandRule类
class PhoneInLandRule extends CallChargeRule{//接电话计费
double calCost(ArrayList<CallRecord> callRecords){
double sum=0;
double t=0.3;
for(int i=0;i<callRecords.size();i++){
long t1=callRecords.get(i).getStartTime().getTime();
long t2=callRecords.get(i).getEndTime().getTime();
if((t2-t1)%60000!=0)
sum+=t*((t2-t1)/60000+1);
else
sum+=t*((t2-t1)/60000);
}
return sum;
}
}PhoneCharging类
class PhoneCharging extends ChargeMode{
private double monthlyRent=15;
PhoneCharging(){
super();
getChargeRules().add(new PhonelnCityRule());
getChargeRules().add(new PhonelnProvinceRule());
getChargeRules().add(new PhonelnlandRule());
getChargeRules().add(new PhoneInLandRule());
}
public double calCost(UserRecords userRecords){
double sum=0;
sum+=((PhonelnCityRule)getChargeRules().get(0)).calCost(userRecords.getCallinglnCityRecords());
sum+=((PhonelnProvinceRule)getChargeRules().get(1)).calCost(userRecords.getCallinglnProvinceRecords());
sum+=((PhonelnlandRule)getChargeRules().get(2)).calCost(userRecords.getCallinglnLandRecords());
sum+=((PhoneInLandRule)getChargeRules().get(3)).calCost(userRecords.getAnswerlnLandRecords());
sum+=((PhoneInLandRule)getChargeRules().get(3)).calCost(userRecords.getAnswerlnCityRecords());
sum+=((PhoneInLandRule)getChargeRules().get(3)).calCost(userRecords.getAnswerlnProvinceRecords());
return sum;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}UserRecords类
class UserRecords{
private ArrayList<CallRecord> callinglnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> callinglnLandRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnCityRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnProvinceRecords=new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerlnLandRecords=new ArrayList<CallRecord>();
private ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
void addCallinglnCityRecords(CallRecord callRecord){
callinglnCityRecords.add(callRecord);
}
void addCallinglnProvinceRecords(CallRecord callRecord){
callinglnProvinceRecords.add(callRecord);
}
void addCallinglnLandRecords(CallRecord callRecord){
callinglnLandRecords.add(callRecord);
}
void addAnswerlnCityRecords(CallRecord callRecord){
answerlnCityRecords.add(callRecord);
}
void addAnswerlnProvinceRecords(CallRecord callRecord){
answerlnProvinceRecords.add(callRecord);
}
void addAnswerlnLandRecords(CallRecord callRecord){
answerlnLandRecords.add(callRecord);
}
void SendMessageRecords(MessageRecord sendMessageRecord){
}
void ReceiveMessageRecords(MessageRecord receiveMessageRecord){
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public ArrayList<CallRecord> getCallinglnCityRecords() {
return callinglnCityRecords;
}
public ArrayList<CallRecord> getCallinglnLandRecords() {
return callinglnLandRecords;
}
public ArrayList<CallRecord> getCallinglnProvinceRecords() {
return callinglnProvinceRecords;
}
public ArrayList<CallRecord> getAnswerlnCityRecords() {
return answerlnCityRecords;
}
public ArrayList<CallRecord> getAnswerlnLandRecords() {
return answerlnLandRecords;
}
public ArrayList<CallRecord> getAnswerlnProvinceRecords() {
return answerlnProvinceRecords;
}
}User类
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
String number;
double calBalance() {
return getBalance()-calCost();
}
double calCost() {
return chargeMode.calCost(userRecords) ;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return 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;
}
}sort类
class sort{
void Sort(ArrayList<User> users){
for(int i=0;i<users.size()-1;i++){
for(int j=i+1;j<users.size();j++){
if(Long.parseLong(users.get(i).getNumber())>Long.parseLong(users.get(j).getNumber())){
User temp=users.get(i);
users.set(i,users.get(j));
users.set(j,temp);
}
}
}
}
}对了，我嫌麻烦，所以内部排序没有完全按照座机升序后手机升序排序，我是其中的记录保证座机和手机都是升序，然后我先输出座机再输出手机的信息。
电信计费1-3都实现后类图如下：
SourceMonitor生成报表如下：
说明代码量大，但是实际复杂度并不大。
7-2 sdut-Collection-sort--C~K的班级（II） 分数 10 作者 周雪芹 单位 山东理工大学经过不懈的努力，C~K终于当上了班主任。
现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？
输入格式:
第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.
接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。
输出格式:
第一行输出一个n，代表删除重复名字后C~K的班级共有几人。
接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。
输入样例:
6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F输出样例:
3
0000 blf2 22 F
0001 MeiK 20 M
0002 sdk2 21 M相信能够写出来多边形和电信计费的同学不会被这种送分题难住，没啥分析的，送分题。代码如下：
import java.util.ArrayList;
import java.util.Scanner;
class Main{
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
classes cl=new classes();
int cnt=input.nextInt();
for(int i=0;i<cnt;i++){
String num=input.next();
String name=input.next();
int age= input.nextInt();
String sex=input.nextLine().split(" ")[1];
student s=new student(num,name,age,sex);
cl.addStudent(s);
}
cl.print_student();
}
}
class student{
private String Snum;
private String Sname;
private int age;
private String sex;
student(){
}
student(String num,String name,int age,String sex){
this.Snum=num;
this.Sname=name;
this.age=age;
this.sex=sex;
}
public void setAge(int age) {
this.age = age;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setSname(String sname) {
Sname = sname;
}
public void setSnum(String snum) {
Snum = snum;
}
public int getAge() {
return age;
}
public String getSex() {
return sex;
}
public String getSname() {
return Sname;
}
public String getSnum() {
return Snum;
}
}
class classes{
private ArrayList<student> s=new ArrayList<>();
public void print_student(){
s.sort((s1,s2)->s1.getSnum().compareTo(s2.getSnum()));
System.out.println(s.size());
for(student ss:s){
System.out.println(ss.getSnum()+" "+ss.getSname()+" "+ss.getAge()+" "+ss.getSex());
}
}
public void addStudent(student s1){
for(student ss:s){
if(ss.getSnum().equals(s1.getSnum())&&ss.getSname().equals(s1.getSname()) &&ss.getAge()== s1.getAge()&&ss.getSex().equals(s1.getSex()))
return;
}
s.add(s1);
}
public ArrayList<student> getS() {
return s;
}
}唯一值得说的是s.sort((s1,s2)->s1.getSnum().compareTo(s2.getSnum()))，你可以重写compareTo这个函数去改变排序规则。
7-3 阅读程序，按照题目需求修改程序 分数 10 作者 肖斌 单位 西南石油大学功能需求：
使用集合存储3个员工的信息（有序);
通过迭代器依次找出所有的员工。提示：学生复制以下代码到编程区，并按需求进行调试修改。
// 1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
public class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ;
// 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}输入样例:
在这里给出一组输入。例如：
zs
10
ls
20
ww
30输出样例:
在这里给出相应的输出。例如：
zs---10
ls---20
ww---30这道题pta存在问题，我能通过的代码再次提交不一定能通过，所以如果你测试点没通过，可能不是你代码的问题，多提交几次，说不定就过了。据我所知这道题，有提交2-40次不等，最后通过的同学。
代码如下：
// 1、导入相关包
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Scanner;
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
public class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c =new ArrayList<Employee>();
// 创建3个员工元素对象
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
String employeeName = sc.next();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it = c.iterator();
//3、遍历
while (it.hasNext()) {
//4、集合中对象未知，向下转型
Employee e = (Employee) it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}标签：String,nchu,s01,ArrayList,oop,2022,double,new,public From： https://www.cnblogs.com/pillowtalk/p/16951914.html