201521123063 《Java程序设计》 第8周学习总结

1. 本周学习总结

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

这次就不弄思维导图了，就直接总结了

• 遍历Map的方法
  （1）使用键值对for循环

Map<String,String> map = new HashMap<String,String>();
for(Map.Entry<String, String> entry:map.entrySet()){ 
    System.out.println(entry.getKey()); 
    System.out.println(entry.getValue()); 
} 

（2）使用迭代器

Iterator<String> it=map.keySet().iterator();    //保存所有的键值
while(it.hasNext()){
     String key = it.next();
     System.out.println(key);
     String value = map.get(key);
     System.out.println(value);
}

• 集合和数组的相互转换
  （1）数组--->集合

直接使用Arrays.asList(array);
经过查找API文档，可知不需要考虑到转型的问题
public static <T> List<T> asList(T a)   //返回一个受指定数组支持的固定大小的列表，对返回列表的更改会影响数组

（2）集合--->数组

  String[] str = (String[]) list.toArray();  //因为toArray返回的是Object类型的数组，需要强制转换

• 对集合的排序
  （1）Collections的排序函数（是一种稳定的排序，会保存原来排序的结果）
  当排序的类型实现了Comparable接口时，直接用Collections.sort(list);
  否则，Collections.sort(List list, Comparator<? super T> c);
  （2）List的排序函数
  前提是实现Comparator接口，例如：list.sort((o1,o2)->o1.compareTo(o2));

• 引入范型定义集合类型
  对list添加元素，因为不会考虑元素的类型，在进行强制转换时候容易出错，所以引入范型
  范型可以限定变量类型，如果当中需要拥有compareTo方法，则又需要改类型继承或实现Comparable
  范型的约束就是：不能使用基本数据类型，而且只能查询原始类型（raw type）

• 通配符

Pair<Employee> e = new Pair<Manager>("ceo", "cfo");//编译出错（虽然Employee是Manager的父类，但是Pair<Employee>不是Pair<Manager>的父类）
此时可使用通配符Pair<? extends Employee> x = new Pair<Manager>(); 
通配符的类型等级：Pair(row type) > Pair< ? > > Pair<? super Manager> > （Pair<Programmer>，Pair<Object>）

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

1.1当中已经选取了部分

2. 书面作业

本次作业题集集合

List中指定元素的删除(题目4-1)

1.1 实验总结

对于删除函数：用contains方法查看是否存在，如果找到了，删除后，list的长度就减一了，此时循环计数i也要减一
对于添加字符串到集合的方法，通过网上查找用String[] line1=line.split("\\s+");可以分隔含有多空格的一行，但是用如下的方法也可以实现
while(scan.HasNextLine){
    while(scan.HasNext){
    ......

    }
}

统计文字中的单词数量并按出现次数排序(题目5-3)

• 2.1 伪代码（简单写出大体步骤）

使用TreeSet<String>，因其含有自动排序的功能
if equals "!!!!!" break;
else: set.add(string)
使用迭代器，但只输出前10个
Iterator it = set.iterator();
print it.next()

• 2.2 实验总结

一开始不大清楚TreeMap,自己写了实现Comparator的类，发现多此一举，因为该集合内部有实现了这个接口，有自动排序的功能，所以就删掉了
最后使用迭代器输出元素，参考了网上的资料

参考博客http://blog.csdn.net/shenshen123jun/article/details/9074097

倒排索引(题目5-4)

3.1 截图你的提交结果(出现学号)

前面提交错误的...

最后通过的...

3.2 伪代码（简单写出大体步骤）

for row in range (1,last)
    read one line&&read each word
        map1.put(string, row)      //用来记录每行的内容
        if(map.contains(string))
             creat a set and add row
             map.put(string set)
        else:
            map.get(string).add(row)
read each line each word
    if(!map.containsKey(s)) false
    while(has next)
        string2= input word
        map.get(string).retainAll(map.get(string2)); //求两个集合的交集，用到retainAll
for (Integer a : set1) {            
    print("line " + a + ":" + map2.get(a));         
                

3.3 实验总结

这题我弄了挺久的，刚开始是一些小细节没把握好，后来在老师帮助下，有了思路：在读每一行时候，用一个map映射，存放这一整行的信息和行数，读取每一行的每个单词，放入key为String, value为TreeSet<Integer>，即出现的行数，但是我后来用HashMap，发现没办法排序，最后还是用了TreeMap比较方便，求两个集合的交集是用百度查找的方法

Stream与Lambda

编写一个Student类，属性为:

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

创建一集合对象，如List,内有若干Student对象用于后面的测试。

4.1 使用传统方法编写一个方法，将id>10，name为zhang, age>20, gender为女，参加过ACM比赛的学生筛选出来，放入新的集合。在main中调用，然后输出结果。

关键代码：
ArrayList<Student> list =new ArrayList<Student>();
for(Student a:s){
    if(a.getId()>10&&a.getName().equals("zhang")&&a.getAge()>20&&a.getGender().equals(Gender.girl)&&a.isJoinsACM()){
    list.add(a);        
}

运行结果：

4.2 使用java8中的stream(), filter(), collect()编写功能同4.1的函数，并测试。

关键代码：
List<Student> list1 = list.stream().filter          
(a ->(a.getId()>10l&&a.getName().equals("zhang")&&a.getAge()>20&&a.getGender().equals(Gender.girl)&&a.isJoinsACM())).
collect(Collectors.toList());

结果相同

4.3 构建测试集合的时候，除了正常的Student对象，再往集合中添加一些null，然后重新改写4.2，使其不出现异常。

这个嘛...在4.2的筛选条件中开头加入a!=null就行了

泛型类：GeneralStack(题目5-5)

5.1 截图你的提交结果(出现学号)

5.2 GeneralStack接口的代码

interface GeneralStack<T> {
    public T push(T item);            
    public T pop();                 
    public T peek();                
    public boolean empty();
    public int size();     
}

5.3 结合本题，说明泛型有什么好处

答：在pta第一题中，只能对类型为Integer的进行操作，加了范型就更加灵活，可以用你想要的类型，在第一大题的学习总结中有提到范型的好处和约束性

泛型方法

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

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

public class GenericMain {
    public static <T extends Comparable<T>> T max(List<T> list){         //需要传入比较器
        Collections.sort(list);
        return list.get(list.size()-1);
    }

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("banana");
        list.add("apple");
        list.add("pineapple");
        System.out.println(max(list));
    }
}
Integer类型的类似，就不写了

运行结果：

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

public class GenericMain {
    public static <T extends Comparable<? super T>> T max(List<T> list, Comparator<? super T> c){  
        Collections.sort(list,c);
        return list.get(list.size()-1);
    }

    public static void main(String[] args) {
                List<StuUser> list=new ArrayList<StuUser>();
        StuUser[] s=new StuUser[3];
        s[0]=new StuUser(12,"008");
        s[1]=new StuUser(19,"110");
        s[2]=new StuUser(13,"999");
        list.add(s[0]);
        list.add(s[1]);
        list.add(s[2]);
        System.out.println(max(list,new StuUserComparator()));      //找到no最大的一个
        System.out.println(max(list,new UserReverseComparator()));  //找到age最小的一个
    }
}

运行结果：

6.3 选做：编写int myCompare(T o1, T o2, Comparator c)方法，该方法可以比较User对象及其子对象，传入的比较器c既可以是Comparator，也可以是###Comparator。注意：该方法声明未写全，请自行补全。

public static <T extends User> int mycompare(T o1,T o2, Comparator<? super T> c){
        return c.compare(o1, o2);
}
public static void main(String[] args) {
    StuUser s1=new StuUser(12,"008");
    StuUser s2=new StuUser(19,"110");
    User u1=new User(20);
    int x1=mycompare(s1,s2,new StuUserComparator());
    int x2=mycompare(s1,u1,new UserReverseComparator());
    if(x1>0){
        System.out.println("s1.no>s2.no>");
    }else{
        System.out.println("s1.no<=s2.no>");
    }
    if(x2<0){
        System.out.println("s1.age>u1.age>");
    }else{
        System.out.println("s1.age<=u1.age>");
    }

运行结果：

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

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

7.1 写出伪代码

reserve the keys in the HashSet
while(sen.length!=0）
    for(i=sen.length ,i>=0, i=i-p.length)           
        for j in range[1,i]
            if(set.contains(sen.sub(i-j,i))   
                phrase=sen.sub(i-j,i);
        if(find phrase): add list
        else:  
            p=get a word
            sen= the left
            add p to list   
    at last print inverted sequence                          
          

运行结果：

7.2 实验总结

总结：从右往左扫描,截取长度最长的词,剩下继续循环直到被截取完,如果在HashSet当中都没找到，则将单个子加入到list当中

选做:JavaFX入门(待续或不续）

完成其中的作业1、作业2。内有代码，可在其上进行适当的改造。建议按照里面的教程，从头到尾自己搭建。

3. 码云上代码提交记录及PTA实验总结

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

3.1. 码云代码提交记录

在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

3.2. PTA实验

函数（4-1）,编程(5-3，5-4，5-5)

实验总结已经在作业中体现，不用写。

转载于:https://www.cnblogs.com/lyq063/p/6707820.html