201621123043 《Java程序设计》第9周学习总结

1. 本周学习总结

1.1 以你喜欢的方式（思维导图或其他）归纳总结集合与泛型相关内容。

泛型的定义：

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

为什么要使用泛型：

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

一个普通的泛型：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

1.2 选做：收集你认为有用的代码片段

//Map对象覆盖compare方法
List<Collections.sort> list = new ArrayList<Entry<String,Integer>>(words.entrySet());   

    Collections.sort(list,new Comparator<Entry<String,Integer>>() {

       public int compare(Entry<String,Integer> o1, Entry<String,Integer> o2) {//覆盖compare方法    }});

//遍历输出
for (Entry<String, ArrayList<Integer>> entry : list) {

            String key = entry.getKey();
            ArrayList<Integer> value = entry.getValue();
            System.out.println(key + "=" + value);

        }

//注：Gender 枚举型的定义：
enum Gender{  man,woman;    };

   student.stream().filter(e -> e!=null&&e.getId()>50&&e.getName().equals("chen")&&e.getAge()>18&&e.getGender()==Gender.man&&e.isJoinsACM()==true)
.forEach(e->System.out.println(e));;

2. 书面作业

本次作业题集集合

1. List中指定元素的删除(题集题目)

JAVA中循环遍历list有三种方式for循环、增强for循环（也就是常说的foreach循环）、iterator遍历。

1、for循环遍历list

    for (int i = list.size()-1; i >= 0; i--) {
            if(list.get(i).equals("del"))
                list.remove(i);
            }

　　需要强调的是，用for循环删除元素必须从后面开始删除元素，否则从前面删除元素的话，会导致删除某个元素后，list的大小发生了变化，而你的索引也在变化，所以会导致你在遍历的时候漏掉某些元素。比如当你删除第1个元素后，继续根据索引访问第2个元素时，因为删除的关系后面的元素都往前移动了一位，所以实际访问的是第3个元素。

2、增强for循环

for(String x:list){
    if(x.equals("del"))
        list.remove(x);
}

　这种方式的问题在于，删除元素后继续循环会报错误信息ConcurrentModificationException，因为元素在使用的时候发生了并发的修改，导致异常抛出。但是删除完毕马上使用break跳出，则不会触发报错。

3、iterator遍历

Iterator<String> it = list.iterator();
while(it.hasNext()){
    String x = it.next();
    if(x.equals("del")){
        it.remove();
    }
}

　　这种方式可以正常的循环及删除。但要注意的是，使用iterator的remove方法，如果用list的remove方法同样会报上面提到的ConcurrentModificationException错误。

　

　

1.1 实验总结。并回答：列举至少2种在List中删除元素的方法。

2. 统计文字中的单词数量并按出现次数排序(题集题目)

2.1 伪代码（不得复制代码，否则扣分）

1.创建一个Map对象，String类型用来存字母，Integer用来存放单个的字母个数

Map<String,Integer> words = new HashMap<>();

2.把每个单词逐一加入Map对象中，注意当加入某个单词是words里面已经存在了，要把Integer类型的值加1.

if (!words.containsKey(word))  // 若尚无此单词
                      words.put(word, 1);

                 else           //如果有，就在将次数加1
                      words.put(word,words.get(word)+1 );

3.用Map里面的keySet()方法返回一个Set对象，再用size()方法求出不同的单词数量

System.out.println(words.keySet().size());//输出不同的单词数量

4.覆盖Collections.sort()中的compare方法来实现比较的目的

        List<Collections.sort> list = new ArrayList<Entry<String,Integer>>(words.entrySet());   

    Collections.sort(list,new Comparator<Entry<String,Integer>>() {

       public int compare(Entry<String,Integer> o1, Entry<String,Integer> o2) {//覆盖compare方法     }});

5.遍历Map集合，并输出前十个

                        int i = 0;
            for(Map.Entry<String, Integer> entry : list) {
                if(i++<10) {
                String key = entry.getKey();
                Integer value = entry.getValue();
                        System.out.println(key+"="+value);
                }
        }

2.2 实验总结

-1.要熟悉Map里面的一些常用方法的使用，可以少走一些弯路

-2.因为Collections.sort的使用对象是List对象，所以必须先将Map对象转化为List 对象（注意Entry

3. 倒排索引(题集题目)

3.1 截图你的代码运行结果

3.2 伪代码

1.创建Map对象.

Map<Integer, ArrayList<String>> Lists = new HashMap<>();//Integer代表行数，ArrayList存放每一行的单词

2.一整行单词输入存入ArrayList中，flag代表的行数每次加1

String[] words = str.split(" +");//分割str
            for (int i = 0; i < words.length; i++) {
                List.add(words[i]);//把str中的每个单词加入List里面
            }
            Lists.put(flag++, List);

3.再新建一个Map对象，判断每一个单词出现的行数，并存入一个Map中的ArrayList

Map<String, ArrayList<Integer>> Lists2 = new HashMap<>();//String 代表单词，ArrayList存储该单词所在的行数
        for (int i = 1; i < flag; i++) {
            for (String e : Lists.get(i)) {//对每一个单词遍历

                ArrayList<Integer> Arr = new ArrayList<Integer>();
                for (int j = 1; j < flag ; j++) {
                if (Lists.get(j).contains(e)) {
                    Arr.add(j);
                }
                }
                Lists2.put(e, Arr);

            }

        }

4.重写Collection.sort()中的compare方法，用于对Lists2中每个单词排序输出

List<Entry<String, ArrayList<Integer>>> list = new ArrayList<Entry<String, ArrayList<Integer>>>(
                Lists2.entrySet());

        Collections.sort(list, new Comparator<Entry<String, ArrayList<Integer>>>() {
            public int compare(Entry<String, ArrayList<Integer>> o1, Entry<String, ArrayList<Integer>> o2) {// 覆盖compare方法

                if (o1.getKey().compareTo(o2.getKey()) > 0)
                    return o1.getKey().compareTo(o2.getKey());
                return -1;

            }
        });

5.遍历输出Lists2中的每个单词

for (Entry<String, ArrayList<Integer>> entry : list) {

            String key = entry.getKey();
            ArrayList<Integer> value = entry.getValue();
            System.out.println(key + "=" + value);

        }

6.输入要查找的单词组，对其查找

        while (true) {

            String s = sc.nextLine();//输入要查找的单词组

            String[] ss = s.split(" +");//分割成一个个单词并存入动态数组sss中
            ArrayList<String> sss = new ArrayList<String>();
            for(int i = 0;i<ss.length; i++) {
                sss.add(ss[i]);
            }

            ArrayList<Integer> find = new ArrayList<Integer>();//用来放要查找单词的所在行数

            for(int i = 0; i<Lists.keySet().size(); i++) {
                if(Lists.get(i+1).containsAll(sss))
                    find.add(i+1);

            }
            if (find.size() == 0)
                System.out.println("found 0 results");
            else
                System.out.println(find);

            for (Integer e : find) {
            System.out.println("line " + e + ":" + L.get(e-1));
            }

        }

3.3 实验总结

这一道题我用到了两个Map对象

1.   Map<Integer, ArrayList<String>> Lists = new HashMap<>();//Integer代表行数，ArrayList存放每一行的单词
2.   Map<String, ArrayList<Integer>> Lists2 = new HashMap<>();//String 代表单词，ArrayList存储该单词所在的行数

第一个用于存入每一个单词，让每一个单词都有自己对应的行数，便于后面的查找。

第二个是把每一个单词和自己对应的行数ArrayList联系起来，之后再对每一个单词排序后输出。

4.Stream与Lambda

编写一个Student类，属性为:

private Long id;
private String name;
private int age;
private Gender gender;//枚举类型
 private boolean joinsACM; //是否参加过ACM比赛

//注：Gender 枚举型的定义：
enum Gender{  man,woman;    };

创建一集合对象，如List

       List<Student> student = new ArrayList<Student>();
               student.add(new Student( 201601,"wang",15,Gender.man,false));
            student.add( new Student(201602,"zhao",16,Gender.woman,true));
            student.add( new Student(201603,"chen",17,Gender.man,false));
            student.add ( new Student(201604,"xu",18,Gender.woman,false));
            student.add( new Student(201605,"chen",19,Gender.man,true));
            student.add( new Student(201607,"chen",20,Gender.man,true));
            student.add( new Student(201608,"chen",21,Gender.man,true));
            

4.1 使用传统方法编写一个搜索方法

static List<Student> search(long i, String name, int age, Gender gender, boolean joinsACM,List<Student> list){
            List<Student> student = new ArrayList<Student>();
            System.out.println("201621123043-翁明强");
            for(Student e:list){
                if(e.getId()>i&&e.getName().equals(name)&&e.getGender()==gender&&e.isJoinsACM()==joinsACM){
                    student.add(e);
                }
            }
            return student;

        }

然后调用该方法将id>某个值，name为某个值, age>某个值, gender为某个值，参加过ACM比赛的学生筛选出来，放入新的集合。在main中调用，然后输出结果。(截图：出现学号、姓名)

//Main 函数
 List<Student> newStudent = search(201603, "chen",18,Gender.man, true,student);
            for(Student e : newStudent){
                System.out.println(e.toString());
                }

        

4.2 使用java8中的stream(), filter(), collect()编写功能同4.1的代码，并测试（要出现测试数据）。构建测试集合的时候，除了正常的Student对象，再往集合中添加一些null，你编写的方法应该能处理这些null而不是抛出异常。(截图：出现学号)

   student.stream().filter(e -> e!=null&&e.getId()>50&&e.getName().equals("chen")&&e.getAge()>18&&e.getGender()==Gender.man&&e.isJoinsACM()==true)
.forEach(e->System.out.println(e));;

//测试数据
 student.add(new Student( 201601,"wang",15,Gender.man,false));
            student.add( new Student(201602,"zhao",16,Gender.woman,true));
            student.add(null);
            student.add( new Student(201603,"chen",17,Gender.man,false));
            student.add ( new Student(201604,"xu",18,Gender.woman,false));
            student.add( new Student(201605,"chen",19,Gender.man,true));
            student.add(null);
            student.add( new Student(201607,"chen",20,Gender.man,true));
            student.add( new Student(201608,"chen",21,Gender.man,true));

5. 泛型类：GeneralStack

题集jmu-Java-05-集合之GeneralStack

5.1 GeneralStack接口的代码

public interface GeneralStack<E> {

    E push(E item);            //如item为null，则不入栈直接返回null。
    E pop();                 //出栈，如为栈为空，则返回null。
    E peek();                //获得栈顶元素，如为空，则返回null.
    public boolean empty();//如为空返回true
    public int size();     //返回栈中元素数量

}

5.2 结合本题与以前作业中的ArrayListIntegerStack相比，说明泛型有什么好处

因为泛型中所有对象都是is-Object，所以集合内部仅仅存放的是object。我们可以根据自己的要去，要决定在集合内部放入什么对象，所以虽然我们只定义了一个GeneralStack接口和其实现类，但我们却可以对不同对象进行栈操作，增加了代码的灵活性。

6. 选做：泛型方法

基础参考文件GenericMain，在此文件上进行修改。

6.1 编写方法max，该方法可以返回List中所有元素的最大值。List中的元素必须实现Comparable接口。编写的max方法需使得String max = max(strList)可以运行成功，其中strList为List

6.2 选做：现有User类，其子类为StuUser，且均实现了Comparable接口。编写方法max1，基本功能同6.1，使得User user = max1(stuList);可以运行成功，其中stuList为List

6.3 选做：编写int myCompare(T o1, T o2, Comparator c)方法，该方法可以比较两个User对象，也可以比较两个StuUser对象，传入的比较器c既可以是Comparator

7. 选做:逆向最大匹配分词算法

集合实验文件中的第07次实验(集合).doc文件，里面的题目6.

7.1 写出伪代码(不得直接复制代码)

7.2 截图你的代码运行结果。

3.码云及PTA

题目集：jmu-Java-05-集合

3.1. 码云代码提交记录

3.2 截图PTA题集完成情况图

Pta第四题和第五题输出结果应该都没错，但是提交上去就不行。

3.3 统计本周完成的代码量

周次	总代码量	新增代码量	总文件数	新增文件数
1	0	0	0	0
2	0	0	0	0
3	0	0	0	0
4	0	0	0	0
5	488	488	23	23
6	488	0	23	0
7	1292	804	42	19
8	1630	338	45	3
9	1798	168	53	8
10	2521	723	65	12

4. 评估自己对Java的理解程度

尝试从以下几个维度评估自己对Java的理解程度

维度	程度
语法	PTA的题目上的题目大部分可以自己搞定，但是效率比较低，一般是多请教其他大佬语法基础不牢固
面向对象设计能力	这个很差
应用能力	多花点时间搞不好可以
至今为止代码行数	2521

选做：5.使用Java解决实际问题

有n门课程，每个学生对每门课程都有几个不懂的问题（每题都有标号）。教师期望对所有学生的问题进行归类，首先对问题按课程分类，在某类中又将同一个学生的题目归类在一起。现有的操作流程，是每个学生把自己的各科目中不懂得题目按课程分类号后发给学习委员，学习委员进行统一汇总。现在希望编写一个程序，帮助学习委员分类，并统计每门课程中哪些题目不懂率最高。尝试写出解决该问题的大概步骤？每个学生发给学习委员的文件内容应遵循一定规范方便程序处理，尝试写出该规范。