文章目录

任务8
- 【任务8.1.1】对IDataAnalyse类方法返回值使用泛型集合升级
- 【任务8.1.2】对DataFilter类成员属性使用泛型集合升级，类型参数是有界的（DataBase的子类）
- 【任务8.2】对LogRecAnalyse类成员属性使用泛型集合升级,相关数据集合进行泛型升级
- 【任务8.3】对TransportAnalyse类成员属性使用泛型集合升级
- 【任务8.4.1】对LogRecService类成员属性使用泛型集合升级
- 【任务8.4.2】对TransportService类成员属性使用泛型集合升级
- 【任务8.5】完善MenuDriver类，整合数据采集、数据匹配、数据显示功能

任务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();
            }
        }
    }
}