java基础增强：统计网上app下载情况，并排序

Posted 2021-01-01 zdl9857

一入编程深似海，从此妹子是路人。

案例：

　　统计网站app下载的情况，后台数据如下：

　　　　日期,用户名,app名,下载渠道,所在城市,app版本

　　　　2017-08-15,xx老师,陌陌,app store,上海,v2.9

　　　　2017-08-15,xx老师,脉脉,jdk1.8,上海,v2.3

　　　　2017-08-15,oo老师,陌陌,app store,上海,v2.6

　　　　。。。。。。。多条上述格式的数据

效果要求：

　　要求统计完后的表示格式：

　

　　统计出每天的app版本升级情况

日期

用户名

app名

新版本下载渠道

升级前版本

升级后版本

　　统计结果示例如下：app的下载渠道分开来看

2017-08-14	xx	app	360应用	v1.0	v1.2
2017-08-15	xx	app	小米应用	v1.2	v2.0

功能分析：

　　1、后台所提供的数据信息为 ：日期，用户名，app名，下载渠道，城市，版本。

　　2、案例要求输出的格式为： 日期，用户名，app名，下载渠道，城市，低版本，新版本。

　　3、利用Map集合将 日期，” 用户名，app名，下载渠道，城市 ”  作为key，版本为value

　　4、进行拼接，当key值向同时，将这两个key映射的两个value添加到一个List集合中。

　　5、将所添加了value的list集合进行排序。

　　6、此时list中可能存在三种情况：

　　　　只有一个value。（不符合接个需要不打印）。

　　　　有两个value。 （按版本先后排序）。

　　　　有多个value。 （只想list中添加最低版本和最高版本）

　　7、根据map的key获取其对应的版本list，判断出长度，确定用户是否更新版本将用户信息及用户版本更新数据封装到Bean中

　　　　将Bean放在List中，然后按照时间排序

　　8、通过控制台输入标识来选择排序条件，和排顺序的顺序。

实现代码：

　　　Appbean代码：

　　　　自行添加有参构造方法，get/set方法，toString方法。

public class PersonBean {
        private String data;
        private String Usr;
        private String app;
        private String downPatch;
        private String city;
        private String preUpgrade;
        private String Upgrade;
        public PersonBean(String data, String usr, String app, String downPatch,  String city,String preUpgrade,String upgrade) {
            this.data = data;
            this.Usr = usr;
            this.app = app;
            this.downPatch = downPatch;
            this.city=city;
            this.preUpgrade=preUpgrade;
            this.Upgrade = upgrade;
        }

　　功能代码：

　　　　　　

main方法：

//由于是练习，所以集合，或者文件为空等异常直接抛出了。可根据自己的需求自行捕获处理。
    public static void main(String[] args) throws Exception  {
            Scanner sc = new Scanner(System.in);
            String str = sc.nextLine();
            //得到拍好格式的List<PersonBean>集合
            List<PersonBean> list = getList();
            //对list排序后，返回int值
            int key = sortTest(str,false,list);
            if( key!=-1) { 
                for (PersonBean p : list) {
                    System.out.println(p);
            }
            }
        
    }

比较方法：

/**
 * 比较方法    
 * @param str 按什么条件排序（日期，地区）
 * @param isAcd true：升序  false：降序
 * @param list 需要排序的集合
 * @return 标识
 */
public static int sortTest(String str,boolean isAcd, List<PersonBean> list)  {
    
    if( str.equals("日期")) { 
        //对排好格式的list<Personbean>集合进行排序
                sortData(list,isAcd); 
    }else if( "地区".equals(str)) { 
        sortCity(list,isAcd);
    } else { 
        System.out.println("请从“日期”或者“地区”选择一个作为查询条件。。。");
        return -1;
    }
    return 0;    
    }

getMap方法：

/**
 * 将读入的数据信息惊醒分割，并存入一个Map中，并返回map
 * @return map对象
 * @throws Exception 此异常为抛出异常，未作处理
 */
public static HashMap<String, List<String>> getMap() throws Exception{
     HashMap<String, List<String>> map = new HashMap<String,List<String>>();
     //创建缓冲字符流
     BufferedReader br = new BufferedReader(new FileReader("C:\\\\Users\\\\zhangdali\\\\Desktop/count.txt"));
     //读取文档
     String line;
     while(( line = br.readLine())!=null) { 
         //对读取的数据进行分割
         String[] split = line.split(",");
         //此处将版本前面的所有变量组成的字符串作为Key，目的在于可以单独操作，版本这个变量。
         //因为案例需求为，日期，用户，app，地址，城市，低版本，高版本。此处要做的就是吧高低版本这俩变量
         //从两条语句中整合到一条中。（共同点：这两条数据Key值相同）。
         String key = split[0] +"," +split[1] + "," + split[2] + "," + split[3] +","+split[4];
         String value = split[5];
         //如果key相同，返回一个List集合接受对应的value值。
        List<String> list = map.getOrDefault(key, new ArrayList<>());
        list.add(value);
        //对存入的版本号信息，按要求从低版本到高版本进行排序版本
        sort(list);
        map.put(key, list);
     }
     //关流
     br.close();
     return map; 
 }

getList方法：

/**
 * getList<PersonBean>
 * 获得储存格式为：日期，用户，APP，下载途径，城市，低版本，高版本。的list<PersonNean>
 * @return list
 * @throws Exception 可能list为空，可捕获处理。（此处选择抛出）
 */
public static List<PersonBean> getList() throws Exception {
    //创建泛型为PersonBean的List集合，用来添加PersonBean的属性。
            //通过对llist进行排序，和遍历
            List<PersonBean> list = new ArrayList<PersonBean>();
            //获得添加了值的map集合
            HashMap<String,List<String>> map = getMap();
            //获得map集合的键值对集合
            Set<Entry<String,List<String>>> set = map.entrySet();
            //遍历键值对集合
            for (Entry<String, List<String>> entry : set) {
                //System.out.println(entry);打印键值对
                //获得每一个键值对所映射的key
                String key = entry.getKey();
                //对每一个key进行分割
                String[] split = key.split(",");
                 String data=split[0];
                 String usr=split[1];
                 String app=split[2];
                 String downPatch=split[3];
                  String city=split[4];
                 //获得键值对所映射的value值
                List<String> value = entry.getValue();
                //此时value是一个List集合，由于需求的要求，只有有两个value的list才可以被打印
                if(value.size()>1) { 
                    String preUpgrade = value.get(0);
                    String upgrade = value.get(value.size()-1);
                    PersonBean bean = new PersonBean(data, usr, app, downPatch, city, preUpgrade, upgrade);
                    list.add(bean);
                }
            }
            return list;
    }

对list<String > 进行排序：

/**
 * 对集合list进行排序
 * @param list
 */
public static void sort(List<String> list) {
        Collections.sort(list, new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                //按字典先后排序
                return o1.compareTo(o2);
            }
        });
}

按日期进行排序：

/**
 * 按下载日期的先后进行排序。
 * @param list 进行排序的集合
 * @param isAcd 为true进行升序，为false进行降序
 */
public static void sortData(List<PersonBean> list, boolean isAcd) {
         Collections.sort(list, new Comparator<PersonBean>() {

            @Override
            public int compare(PersonBean o1, PersonBean o2) {
                //通过对象.属性获得data（注意：此时得到的是String类型）
                String d1 = o1.getData();
                String d2 = o2.getData();
                //创建Format对象，用正则表达式进行格式控制
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                //使用format中的parse方法将d1，d2,转成Data类型
                try {
                    Date date1 = format.parse(d1);
                    Date date2 = format.parse(d2);
                    if( isAcd) { 
                        //升序
                        return date2.before(date1)?1:-1;
                    }else { 
                        //降序
                        return date1.before(date2)?1:-1;
                    }
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return 0;
            }
        });
    }

按地区排序：

/**
 * 按地区排序
 * @param list 进行排序的集合
 * @param isAcd true：按字典升序，false：按字典降序
 */
@SuppressWarnings("unchecked")
private static void sortCity(List<PersonBean> list,boolean isAcd) {
    Collections.sort(list, new Comparator<PersonBean>() {

        @Override
        public int compare(PersonBean o1, PersonBean o2) {
            if(isAcd) { 
                return o1.getCity().compareTo(o2.getCity());
            } else { 
                return o2.getCity().compareTo(o1.getCity());
            }
        }
    });
}

知识点总结：

　　日期的比较：

　　　　　　1、获取类中data成员变量

　　　　　　　　　//通过对象.属性获得data（注意：此时得到的是String类型）

                String d1 = o1.getData();
                String d2 = o2.getData();
                //创建Format对象，用正则表达式进行格式控制
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
　
　　　　　　　　　　Date date1 = format.parse(d1);

                  Date date2 = format.parse(d2);

　　　　　　　　　　//共有两种比较方法，before，after
　　　　　　　　　　return date2.after(date1);//降序
　　　　　　　　　　return date1.befor(date2); //降序
　　　　　　　　　　

　　　　　　　　　　　return date2.befor(date1); //升序
　　　　　　　　　　　return date1.after(date2);//升序

耐得住寂寞，经得住诱惑。