集合与IO流考试

一.题目要求

• 一个文本文件test.txt(目录自定),数据内容为部分用户的银行卡消费记录，消费记录信息包含姓名 消费金额，找出消费次数最多的用户，并且该用户单笔消费最高的金额是多少，得出此信息并将信息写入到result.txt中？
  考试要求如下：
  1、要求读取文件test.txt(能正确读取15分)
  2、要求将文件中的内容按行存入到集合类中(成功存入30分)
  3、对集合类中的每一条记录进行分割，分别获取用户名，消费金额(20分)
  4、并在上一步基础上进行计数，获取消费次数最多的用户(20分)
  5、在上一步基础上获取该用户消费最高金额，打印并写入文件(15分)

二.资料准备

链接: https://pan.baidu.com/s/1bmRPvKpXwBwmZqKKhfMSnA 提取码: 5vxq

三.题目分析

• 1.首先看看具体文件内容,如下:
  
• 2.可知文件内容十分简单只是数据非常的多,每行的内容具体为–>中文名字 : 消费数字
• 3.读取文件内容比较简单,用一个缓冲流按行来读内容即可
• 4.文件内容存入
• 1)根据文件内容可知我们需要存入一个名字,然后是对应各次消费的金额,那么可用一个Map 键为名字,值为一个泛型为Integer的List集合即可实现这个功能
• 2)每次按行读完用:打断该行内容,分成名字和消费金额存入Map即可
• 5.遍历Map找出List集合的最大长度即为消费次数最多,并记录这个用户名字和次数
• 6.遍历消费次数最大的Lsit中的最大值即为最高消费金额,记录该最大值
• 7.用一个输出流将以上记录的数存入一个文件即可(可单独写一个方法)

四.具体代码如下:

package count;

import java.io.*;
import java.util.*;

/**
 * @author sunyong
 * @date 2020/06/20
 * @description
 * 考试:读取一个文件内容,分析其中内容获取相关数据
 */
public class Test {
    /*
    * @param path:存入的路径
    * @param content:文件内容
    */
    public static void write(String path,String content) throws IOException {
        //定义一个输出字符流
        FileWriter fw = new FileWriter(path);
        //定义一个输出缓冲流(装入之前的输出字符流)
        BufferedWriter bw = new BufferedWriter(fw);
        //写入内容
        fw.write(content);
        //关闭流(先开的后关)
        bw.close();
        fw.close();
    }
    /*
    * @param filePath :读取的文件路径
    */
    public static void getUserName(String filePath) {
        try {
            //字符输入流
            FileReader fr = new FileReader(filePath);
            //缓冲输入流包装字符输入流
            BufferedReader br = new BufferedReader(fr);
            //定义最大消费次数的名字
            String maxCountUserName = null;
            //读取文件中的内容
            String str = null;
            //  key是名字 list里面放该用户每次消费的金额  list.size()该用户出现的次数
            HashMap<String, List<Integer>> map = new HashMap<>();
            while(!((str = br.readLine()) ==null)) {
                //按照": "打断为一个字符串数组
                String[] split = str.split("：");
                //给名字赋值
                String name = split[0];
                //第二个字符串为消费金额
                Integer money = Integer.valueOf(split[1]);
                if(map.containsKey(name)) {
                    //如果map内出现过某个用户的处理流程
                    //获取该用户的消费金额集合
                    List<Integer> list = map.get(name);
                    //把该次消费金额加入该集合后再覆盖map
                    list.add(money);
                    map.put(name, list);
                }else{
                    //没出现过某个用户的处理流程
                    ArrayList <Integer> integers = new ArrayList <Integer>();
                    integers.add(money);
                    map.put(name,integers );
                }
            }
            //使用迭代器遍历map键值对
            Iterator<Map.Entry<String,List<Integer>>> iterator = map.entrySet().iterator();
            Integer num = 0;
            while(iterator.hasNext()) {
                Map.Entry<String,List<Integer>> next = iterator.next();
                //获取键值对的键
                String name1 = next.getKey();
                //获取值
                List<Integer> moneyNum = next.getValue();
                //找最大消费次数
                if(moneyNum.size()>num) {
                    num = moneyNum.size();
                    maxCountUserName = name1;
                }
            }
            String s0 = "最大消费次数:"+num;
            System.out.println(s0);
            String s1 = "消费次数最多的用户是："+ maxCountUserName;
            System.out.println(s1);
            /*
             * 使用map的get方法获取值-->存金额的集合
             * 通过遍历消费次数最多的的那个用户的消费记录，
             * 寻找出消费次数最多的的那个用户的消费金额最大的那次
             */
            List<Integer> list2 = map.get(maxCountUserName);
            Iterator<Integer> iterator1 = list2.iterator();
            Integer maxMoney = 0;
            while(iterator1.hasNext()) {
                Integer next = iterator1.next();
                if(next  > maxMoney  ) {
                    maxMoney = next;
                }
            }
            String s2 ="该用户一次消费最大金额是："+maxMoney;
            System.out.println(s2);
            //获取所有的键遍历-->查看到底有几个人
            Set<String> set=map.keySet();
            Iterator<String> iterator2 = set.iterator();
            while (iterator2.hasNext()){
                System.out.println(iterator2.next());
            }
            //关闭流
            br.close();
            fr.close();
            //写入文件
            write("result.txt",s0+"\r\n"+s1+"\r\n"+s2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //测试
    public static void main(String[] args) {
       //查找次数最大的人并且写入文件
        getUserName("F:\\sunyong\\Java\\codes\\examination\\buy_record.txt");
    }
}

五.测试结果如下图:

六.使用spark处理数据

#计算消费次数
sc.textFile("/data/test.txt").map(_.split("：")).map(x=>(x(0),x)).groupBy(_._1).map(x=>(x._1,x._2.size)).collect
#根据名字分组,最大消费金额,消费总数
val rdd1 = sc.textFile("/data/test.txt").map(_.split("：")).map(x=>(x(0),x(1))).groupBy(_._1).map(x=>(x._1,x._2.map(x=>x._2))).map(x=>(x._1,x._2.map(x=>x.toInt).sum,x._2.map(x=>x.toInt).max))
查询最大消费的人
rdd1.sortBy(-_._2).take(1)

• 结果如下:

scala> sc.textFile("/data/test.txt").map(_.split("：")).map(x=>(x(0),x)).groupBy(_._1).map(x=>(x._1,x._2.size)).collect
res25: Array[(String, Int)] = Array((项羽,49279), (韩信,49573), (孙膑,49312), (白起,49392), (养由基,49480), (孙武,49415))

scala> sc.textFile("/data/test.txt").map(_.split("：")).map(x=>(x(0),x)).groupBy(_._1).map(x=>(x._1,x._2.size)).collect
res26: Array[(String, Int)] = Array((项羽,49279), (韩信,49573), (孙膑,49312), (白起,49392), (养由基,49480), (孙武,49415))

scala> val rdd1 = sc.textFile("/data/test.txt").map(_.split("：")).map(x=>(x(0),x(1))).groupBy(_._1).map(x=>(x._1,x._2.map(x=>x._2))).map(x=>(x._1,x._2.map(x>x.toInt).sum,x._2.map(x=>x.toInt).max))
rdd1: org.apache.spark.rdd.RDD[(String, Int, Int)] = MapPartitionsRDD[158] at map at <console>:24

scala> rdd1.sortBy(-_._2).take(1)
res27: Array[(String, Int, Int)] = Array((韩信,272142491,9999))