文章目录
任务8
【任务8.1.1】对IDataAnalyse类方法返回值使用泛型集合升级
Object[]---》ArrayList<?>
程序设计
package com.qst.dms.gather;
import com.qst.dms.exception.DataAnalyseException;
import java.util.ArrayList;
public interface IDataAnalyse<T> {
ArrayList<?> matchData() throws DataAnalyseException;
}
【任务8.1.2】对DataFilter类成员属性使用泛型集合升级，类型参数是有界的（DataBase的子类）
DataBase[]---》ArrayList<? extends DataBase>
程序设计
package com.qst.dms.gather;
import com.qst.dms.entity.DataBase;
import java.util.ArrayList;
public abstract class DataFilter<T extends DataBase> {
// 数据集合
private ArrayList<? extends DataBase> datas;
// 构造方法
public DataFilter(ArrayList<? extends DataBase> datas) {
this.datas = datas;
}
// 获取数据集合
public ArrayList<? extends DataBase> getDatas() {
return datas;
}
// 设置数据集合
public void setDatas(ArrayList<? extends DataBase> datas) {
this.datas = datas;
}
// 数据过滤抽象方法
public abstract void doFilter();
}
【任务8.2】对LogRecAnalyse类成员属性使用泛型集合升级,相关数据集合进行泛型升级
// “登录”集合
private List<LogRec> logIns= new ArrayList<>();
// “登出”集合
private List<LogRec> logOuts= new ArrayList<>();
// 获取数据集合
List<LogRec> logs = (ArrayList<LogRec>) this.getDatas();
// 创建日志匹配数组
List<MatchedLogRec> matchLogs = new ArrayList<>();
程序设计
package com.qst.dms.gather;
import com.qst.dms.entity.DataBase;
import com.qst.dms.entity.LogRec;
import com.qst.dms.entity.MatchedLogRec;
import com.qst.dms.exception.DataAnalyseException;
import java.util.ArrayList;
import java.util.List;
public class LogRecAnalyse extends DataFilter<LogRec> implements IDataAnalyse {
// “登录”集合
private List<LogRec> logIns = new ArrayList<>();
// “登出”集合
private List<LogRec> logOuts = new ArrayList<>();
public LogRecAnalyse(List<LogRec> datas) {
super((ArrayList<? extends DataBase>) datas);
}
// 实现DataFilter抽象类中的过滤抽象方法
@Override
public void doFilter() {
// 获取数据集合
List<LogRec> datas = (List<LogRec>) getDatas();
// 根据日志登录状态统计不同状态的日志个数
int numIn = 0;
int numOut = 0;
// 遍历统计
for (LogRec data : datas) {
if (data.getLogType() == LogRec.LOG_IN) {
numIn++;
} else if (data.getLogType() == LogRec.LOG_OUT) {
numOut++;
}
}
// 创建登录、登出集合
logIns = new ArrayList<>(numIn);
logOuts = new ArrayList<>(numOut);
// 遍历，对日志数据进行过滤，根据日志登录状态分别放在不同的集合中
for (LogRec data : datas) {
if (data.getLogType() == LogRec.LOG_IN) {
logIns.add(data);
} else if (data.getLogType() == LogRec.LOG_OUT) {
logOuts.add(data);
}
}
}
// 实现IDataAnalyse接口中数据分析方法
@Override
public ArrayList<MatchedLogRec> matchData() throws DataAnalyseException {
if (logIns.size() == 0 || logOuts.size() == 0) {
throw new DataAnalyseException("没有匹配的日志数据");
}
// 创建日志匹配集合
ArrayList<MatchedLogRec> matchLogs = new ArrayList<>();
// 数据匹配分析
for (LogRec in : logIns) {
for (LogRec out : logOuts) {
if ((in.getUser().equals(out.getUser()))
&& (in.getIp().equals(out.getIp()))
&& out.getType() != DataBase.MATHCH) {
// 修改in和out日志状态类型为“匹配”
in.setType(DataBase.MATHCH);
out.setType(DataBase.MATHCH);
// 添加到匹配集合中
matchLogs.add(new MatchedLogRec(in, out));
}
}
}
if (matchLogs.size() == 0) {
throw new DataAnalyseException("没有匹配的日志数据");
}
return matchLogs;
}
}
【任务8.3】对TransportAnalyse类成员属性使用泛型集合升级
// 发货集合
private List<Transport> transSends = new ArrayList<>();
// 送货集合
private List<Transport> transIngs = new ArrayList<>();
// 已签收集合
private List<Transport> transRecs = new ArrayList<>();
// 获取数据集合
List<Transport> trans = (List<Transport>) this.getDatas();
// 创建物流匹配集合
List<MatchedTransport> matchTrans = new ArrayList<>();
程序设计
package com.qst.dms.gather;
import com.qst.dms.entity.DataBase;
import com.qst.dms.entity.MatchedTransport;
import com.qst.dms.entity.Transport;
import com.qst.dms.exception.DataAnalyseException;
import java.util.ArrayList;
import java.util.List;
public class TransportAnalyse extends DataFilter implements IDataAnalyse {
// 成员属性
private List<Transport> transSends = new ArrayList<>();
private List<Transport> transIngs = new ArrayList<>();
private List<Transport> transRecs = new ArrayList<>();
// 构造方法
public TransportAnalyse(List<Transport> trans) {
super((ArrayList<? extends DataBase>) trans);
}
// 实现DataFilter抽象类中的过滤抽象方法
@Override
public void doFilter() {
// 获取数据集合
List<Transport> trans = (List<Transport>) getDatas();
// 根据物流状态统计不同状态的物流个数
int numSend = 0;
int numTran = 0;
int numRec = 0;
// 遍历统计
for (Transport tran : trans) {
if (tran.getTransportType() == Transport.SENDING) {
numSend++;
} else if (tran.getTransportType() == Transport.TRANSPORTING) {
numTran++;
} else if (tran.getTransportType() == Transport.RECEIVED) {
numRec++;
}
}
// 创建不同状态的物流集合
transSends = new ArrayList<>(numSend);
transIngs = new ArrayList<>(numTran);
transRecs = new ArrayList<>(numRec);
// 遍历，对物流数据进行过滤，根据物流状态分别放在不同的集合中
for (Transport tran : trans) {
if (tran.getTransportType() == Transport.SENDING) {
transSends.add(tran);
} else if (tran.getTransportType() == Transport.TRANSPORTING) {
transIngs.add(tran);
} else if (tran.getTransportType() == Transport.RECEIVED) {
transRecs.add(tran);
}
}
}
// 实现IDataAnalyse接口中数据分析方法
@Override
public ArrayList<MatchedTransport> matchData() throws DataAnalyseException {
if (transSends.isEmpty() || transIngs.isEmpty() || transRecs.isEmpty()) {
throw new DataAnalyseException("没有匹配的物流数据");
}
// 创建物流匹配集合
ArrayList<MatchedTransport> matchTrans = new ArrayList<>();
// 数据匹配分析
for (Transport send : transSends) {
for (Transport tran : transIngs) {
for (Transport rec : transRecs) {
if (send.getReciver().equals(tran.getReciver())
&& send.getReciver().equals(rec.getReciver())
&& tran.getType() != DataBase.MATHCH
&& rec.getType() != DataBase.MATHCH) {
// 修改物流状态类型为“匹配”
send.setType(DataBase.MATHCH);
tran.setType(DataBase.MATHCH);
rec.setType(DataBase.MATHCH);
// 添加到匹配集合中
matchTrans.add(new MatchedTransport(send, tran, rec));
}
}
}
}
if (matchTrans.isEmpty()) {
throw new DataAnalyseException("没有匹配的物流数据");
}
return matchTrans;
}
}
【任务8.4.1】对LogRecService类成员属性使用泛型集合升级
// 匹配日志信息输出,参数是集合
public void showMatchLog(List<MatchedLogRec> matchLogs)
程序设计
package com.qst.dms.service;
import com.qst.dms.entity.LogRec;
import com.qst.dms.entity.MatchedLogRec;
import sun.rmi.runtime.Log;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
public class LogRecService {
private Scanner scanner;
public LogRecService() {
scanner = new Scanner(System.in);
}
public LogRec inputLog() {
int id, type, logType;
Date nowDate;
String address;
String user;
String ip;
while (true) {
try {
System.out.println("请输入ID标识：");
id = scanner.nextInt();
nowDate = new Date();
System.out.println("请输入地址：");
address = scanner.next();
type = LogRec.GATHER;
System.out.println("请输入登录用户名：");
user = scanner.next();
System.out.println("请输入主机IP：");
ip = scanner.next();
System.out.println("请输入登录状态（1表示登录，0表示登出）：");
logType = scanner.nextInt();
if (logType == 0 || logType == 1) {
break;
} else {
throw new IllegalArgumentException("非法的登录状态");
}
} catch (Exception e) {
System.out.println("输入错误，请重新输入");
scanner.nextLine();
}
}
return new LogRec(id, nowDate, address, type, user, ip, logType);
}
public void showLog(List<LogRec> logRecs) {
System.out.println("日志信息：");
for (LogRec logRec : logRecs) {
System.out.println(logRec);
}
}
// 匹配日志信息输出，参数是集合
public void showMatchLog(List<MatchedLogRec> matchLogs) {
System.out.println("匹配日志信息：");
for (MatchedLogRec matchLog : matchLogs) {
System.out.println(matchLog);
}
}
}
【任务8.4.2】对TransportService类成员属性使用泛型集合升级
// 匹配的物流信息输出，参数是集合
public void showMatchTransport(List<MatchedTransport> matchTrans)
程序设计
package com.qst.dms.service;
import com.qst.dms.entity.MatchedLogRec;
import com.qst.dms.entity.MatchedTransport;
import com.qst.dms.entity.Transport;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
public class TransportService {
private Scanner scanner;
public TransportService() {
scanner = new Scanner(System.in);
}
public Transport inputTransport() {
int transportType;
int id, type;
Date nowDate;
String address, handler, receiver;
while (true) {
try {
System.out.println("请输入ID标识：");
id = scanner.nextInt();
nowDate = new Date();
System.out.println("请输入地址：");
address = scanner.next();
type = Transport.GATHER;
System.out.println("请输入货物经手人：");
handler = scanner.next();
System.out.println("请输入收货人：");
receiver = scanner.next();
System.out.println("请输入物流状态（1表示发货中，2表示送货中，3表示已签收）：");
transportType = scanner.nextInt();
if (transportType == 1 || transportType == 2 || transportType == 3) {
break;
} else {
throw new IllegalArgumentException("非法的物流状态");
}
} catch (Exception e) {
System.out.println("输入错误，请重新输入");
scanner.nextLine();
}
}
return new Transport(id, nowDate, address, type, handler, receiver, transportType);
}
public void showTransport(List<Transport> transports) {
System.out.println("物流信息：");
for (Transport transport : transports) {
System.out.println(transport);
}
}
// 匹配物流信息输出，参数是集合
public void showMatchTransport(List<MatchedTransport> matchTrans) {
System.out.println("匹配物流信息：");
for (MatchedTransport matchTran : matchTrans) {
System.out.println(matchTran);
}
}
}
【任务8.5】完善MenuDriver类，整合数据采集、数据匹配、数据显示功能
// 建立一个从键盘接收数据的扫描器
Scanner scanner = new Scanner(System.in);
// 创建一个泛型ArrayList集合存储日志数据
List<LogRec> logRecList = new ArrayList<>();
// 创建一个泛型ArrrayList集合存储物流数据
List<Transport> transportList = new ArrayList<>();
// 创建一个日志业务类
LogRecService logService = new LogRecService();
// 创建一个物流业务类
TransportService tranService = new TransportService();
// 日志数据匹配集合
List<MatchedLogRec> matchedLogs = null;
// 物流数据匹配集合
List<MatchedTransport> matchedTrans = null;
在每个菜单中添加数据类型选择
System.out.println("请输入采集数据类型：1.日志 2.物流");
// 接收键盘输入的选项
int type = scanner.nextInt();
if (type == 1) {
System.out.println("正在采集日志数据，请输入正确信息，确保数据的正常采集！");
// 采集日志数据
LogRec log = logService.inputLog();
// 将采集的日志数据添加到logRecList集合中
logRecList.add(log);
} else if (type == 2) {
System.out.println("正在采集物流数据，请输入正确信息，确保数据的正常采集！");
// 采集物流数据
Transport tran = tranService.inputTransport();
// 将采集的物流数据添加到transportList集合中
transportList.add(tran);
}
程序设计
package com.qst.dms.dos;
import com.qst.dms.entity.LogRec;
import com.qst.dms.entity.MatchedLogRec;
import com.qst.dms.entity.MatchedTransport;
import com.qst.dms.entity.Transport;
import com.qst.dms.exception.DataAnalyseException;
import com.qst.dms.gather.LogRecAnalyse;
import com.qst.dms.gather.TransportAnalyse;
import com.qst.dms.service.LogRecService;
import com.qst.dms.service.TransportService;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MenuDriver {
public static void main(String[] args) {
// 建立一个从键盘接收数据的扫描器
Scanner scanner = new Scanner(System.in);
// 创建一个泛型ArrayList集合存储日志数据
List<LogRec> logRecList = new ArrayList<>();
// 创建一个泛型ArrrayList集合存储物流数据
List<Transport> transportList = new ArrayList<>();
// 创建一个日志业务类
LogRecService logService = new LogRecService();
// 创建一个物流业务类
TransportService tranService = new TransportService();
// 日志数据匹配集合
List<MatchedLogRec> matchedLogs = null;
// 物流数据匹配集合
List<MatchedTransport> matchedTrans = null;
// 运行菜单选择
while (true) {
System.out.println("请选择操作：");
System.out.println("1. 采集数据");
System.out.println("2. 数据匹配");
System.out.println("3. 显示数据");
System.out.println("4. 退出");
// 接收键盘输入的选项
try {
int choice = scanner.nextInt();
int type;
switch (choice) {
case 1:
System.out.println("请输入采集数据类型：1.日志 2.物流");
// 接收键盘输入的选项
type = scanner.nextInt();
if (type == 1) {
System.out.println("正在采集日志数据，请输入正确信息，确保数据的正常采集！");
// 采集日志数据
LogRec log = logService.inputLog();
// 将采集的日志数据添加到logRecList集合中
logRecList.add(log);
} else if (type == 2) {
System.out.println("正在采集物流数据，请输入正确信息，确保数据的正常采集！");
// 采集物流数据
Transport tran = tranService.inputTransport();
// 将采集的物流数据添加到transportList集合中
transportList.add(tran);
}
break;
case 2:
System.out.println("请输入匹配数据类型：1.日志 2.物流");
// 接收键盘输入的选项
type = scanner.nextInt();
if (type == 1) {
System.out.println("匹配日志数据如下：");
// 数据匹配
// 创建日志数据分析对象
LogRecAnalyse logAnalyse = new LogRecAnalyse(logRecList);
// 日志数据过滤
logAnalyse.doFilter();
// 日志数据匹配分析
try {
List<MatchedLogRec> objs = logAnalyse.matchData(); // 进行数据匹配
// 处理匹配的日志数据
// 判断objs集合是否是配置日志集合
if (objs instanceof List<?>) {
// 将集合强制类型转换成配置日志集合
matchedLogs = (List<MatchedLogRec>) objs;
// 输出匹配的日志信息
for (MatchedLogRec log : matchedLogs) {
if (log != null) {
System.out.println(log);
}
}
}
} catch (DataAnalyseException e) {
System.out.println(e.getMessage());
}
} else if (type == 2) {
System.out.println("匹配物流数据如下：");
// 数据匹配
// 创建物流数据分析对象
TransportAnalyse ta = new TransportAnalyse(transportList);
// 物流数据过滤
ta.doFilter();
try {
// 物流数据分析
List<MatchedTransport> objs = ta.matchData();
// 判断objs集合是否是匹配物流集合
if (objs instanceof List<?>) {
// 将集合强制类型转换成匹配物流集合
matchedTrans = (List<MatchedTransport>) objs;
// 输出匹配的物流信息
for (MatchedTransport log : matchedTrans) {
if (log != null) {
System.out.println(log);
}
}
}
} catch (DataAnalyseException e) {
System.out.println(e.getMessage());
}
}
break;
case 3:
System.out.println("请输入显示原始数据类型：1.日志 2.物流");
// 接收键盘输入的选项
type = scanner.nextInt();
if (type == 1) {
// 显示日志数据
System.out.println("日志数据如下：");
try {
logService.showLog(logRecList);
} catch (Exception e) {
System.out.println("未录入日志数据！");
}
} else if (type == 2) {
// 显示物流数据
System.out.println("物流数据如下：");
try {
tranService.showTransport(transportList);
} catch (Exception e) {
System.out.println("未录入物流数据！");
}
}
break;
case 4:
System.out.println("谢谢使用！");
return;
default:
System.out.println("无效选项，请重新选择！");
}
} catch (Exception e) {
System.out.println("非法输入，请重新输入！");
scanner.nextLine();
}
}
}
}
测试
