201521123042 《java程序设计》 第八周学习总结

1. 本周学习总结

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

①泛型定义：泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以在集合框架（Collection framework）中看到泛型的动机。

②命名类型的参数：

K —— 键，比如映射的键

V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。

E —— 异常类。

T —— 泛型。
③ 泛型方法：通过在类的定义中添加一个形式类型参数列表，可以将类泛型化。方法也可以被泛型化，不管它们定义在其中的类是不是泛型化的。泛型类在多个方法签名间实施类型约束。

④其他：

(1)泛型的参数类型可以使用extends语句，例如<T extends superclass>；泛型的参数类型还可以是通配符类型。
(2)泛型的类型参数只能是类类型（包括自定义类），不能是简单类型

2. 书面作业

• 1.List中指定元素的删除
  题集jmu-Java-05-集合之4-1

• 1.1 实验总结

    	public static List<String> convertStringToList(String line){
    					String str[]=line.split("\s+");
    					List<String>string=new ArrayList<String>();
    					for(int i=0;i<str.length;i++){
    						string.add(str[i]);
    					}
    					return string;
    				} 
  

  ①用line.split("\s+");分隔；

  ②以空格为分隔符，将line转换为List<String>;

    public static void remove(List<String> list, String str){
    	for(int i=0;i<list.size();i++){
    		if(list.contains(str)) {list.remove(str);i--;}
    	}
    }
  

  ②list中移除掉以与str内容相同的元素,实现此功能使用ArrayList中的方法：

  Ⅰ. list.contains(str)：判断list中是否包含str
  Ⅱ. list.remove(str):删除list中str元素。这道题中删除该
  位置的元素时，该位置后面所有元素需要往前移动一位（即i需要减1），这样才能保证所有元素都被检测一次。

• 2.统计文字中的单词数量并按出现次数排序(尽量不要出现代码)
  题集jmu-Java-05-集合之5-3 统计文字中的单词数量并按出现次数排序

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

      while(true){
        if(x.equals("!!!!!"))break;
            else {
                if(map.containsKey(x)) map.put(x, map.get(x)+1);
                else map.put(x, 1); 
            }
        }
    List<Entry<String,Integer>> list =new ArrayList<Entry<String,Integer>>(map.entrySet());
    
    
    Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry<String, Integer> o1,Map.Entry<String, Integer> o2) {
            //代码
    })
  

• 2.2 实验总结

  这道题使用了HashMap，用map.containsKey(x)来判断是否已存在映；，map.get(key)得到键所对应的值； map.put(key, value): 将互相关联的一个关键字与一个值放入该映像，如果关键字已存在，则新的值会代替旧的值；collections.sort()对list进行排序；

• 3.倒排索引(尽量不要出现代码)
  题集jmu-Java-05-集合之5-4

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

• 3.2 实验总结

  要特别注意当查询的单词不存在的情况,需要多种情况考虑

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

  存放：

    while (!lineword.equals("!!!!!")) {  
     String[] words = temp.split(" ");  
        for (String word : words) {  
        if(index.containsKey(word)){
          subIndex=index.get(word);	
        }
        index.put(word, subIndex.add(line););
        }  line++;
       }
  

  查找：

    if (temp1.length() == 0) {
    			System.out.println("found 0 results");
    		}
    	 
    	 if (!index.containsKey(s)) {
    		   System.out.println("found 0 results");
    		 } 
    	     subIndex1 = index.get(s);
    	 if (subIndex1.size()==0) {
    				System.out.println("found 0 results");
    			} 
    	else {
    		System.out.println(subIndex1);
    			}
  

• 4.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中调用，然后输出结果。

    public  ArrayList<Student> choose(ArrayList<Student> arrayList){for (Student student :list) {
        if (student.getId() > 10L && student.getName().equals("zhang")
                && student.getAge() > 20 && student.getGender().equals(Gender.女)&& student.isJoinsACM()) {
            				System.out.println(student);
        	}}
  

  结果：
  

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

    ArrayList<Student> list1 =(ArrayList<Student>) list.stream().filter(stu -> (stu.getId()>10l&&stu.getName().equals("zhang")&&stu.getAge()>20&&stu.getGender().equals(Gender.女)&&stu.isJoinsACM())).collect(Collectors.toList());
    		for (int i = 0; i < list1.size(); i++) {
    			System.out.println(list1.get(i));
    		}
  

  结果：
  

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

加个判断stu不为空的情况即可：stu != null

	ArrayList<Student> list1 =(ArrayList<Student>) list.stream().filter(stu -> (stu!=null&&stu.getId()>10l&&stu.getName().equals("zhang")&&stu.getAge()>20&&stu.getGender().equals(Gender.女)&&stu.isJoinsACM())).collect(Collectors.toList());
					for (int i = 0; i < list1.size(); i++) {
						System.out.println(list1.get(i));
					}

• 5.泛型类：GeneralStack
  题集jmu-Java-05-集合之5-5 GeneralStack

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

• 5.2GeneralStack接口的代码

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

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

  泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型的类型参数可以有多个 。题5-5需要我们实现栈中存放多种类型的数据，通过泛型我们既可以实现这个操作。如果不用泛型，我们就需要编写多个类型的栈。部分代码如下：

    class ArrayListGeneralStack<T> implements GeneralStack<T>{
    	 private List<T> list;
          public ArrayListGeneralStack() {
      		list=new ArrayList<T>();
       	}  
    ArrayListGeneralStack<Integer> stack=new ArrayListGeneralStack<Integer>();
    ArrayListGeneralStack<Double> stack=new ArrayListGeneralStack<Double>()>.
  

  ①通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设，所以泛型提高了程序的类型安全；

  ②消除了强制类型转换，减小代码出错的可能性

• 6.泛型方法
  基础参考文件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);
    		T max=list.get(list.size()-1);
    		return max;
    	}
    
    	public static void main(String[] args) {
    		List<String>strList=new ArrayList<String>();
            List<Integer>intList=new ArrayList<Integer>();
           strList.add("b"); 
           strList.add("a");
            intList.add(1);
            intList.add(2);
            String max = max(strList);
           Integer maxInt = max(intList);
           System.out.println("Stringmax="+max);
           System.out.println("Intmax="+maxInt);
    	}
    }
  

  运行结果：
  

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

    public class GenericMain {
    	public static<T extends StuUser> T max1 (List<T>list){
    		Collections.sort(list,new StuUserComparator());
    		
    		return list.get(list.size()-1);
    	}
    
    	public static void main(String[] args) {
    		 List<StuUser>stuList=new ArrayList<StuUser>();
    		 stuList.add(new StuUser(18,"111"));
    		 stuList.add(new StuUser(17,"222"));
    		 System.out.println(max1(stuList));
    	}
    }
  

  运行结果：
  

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

    public static<T extends User>int myComoare (T o1, T o2, Comparator c){
    		 return c.compare(o1,o2);
    			}
    		public static void main(String[] args) {
    		 List<StuUser>stuList=new ArrayList<StuUser>();
    		  if(myComoare(new StuUser(18,"111"),new StuUser(17,"222"),new StuUserComparator())>0){
    		        System.out.println("first person is first");
    		    }else{
    		        System.out.println("Second person is Second");
    		    }
    		    if(myComoare(new StuUser(18,"111"),new User(19),new UserReverseComparator())>0){
    		        System.out.println("first person is older");
    		    }
    		    else{
    		        System.out.println("Second person is older");
    		 
    	}
    }
  

  结果：
  

• 7.选做:逆向最大匹配分词算法
  集合实验文件中的第07次实验(集合).doc文件，里面的题目6.

• 7.1 写出伪代码即可

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

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

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

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

• 3.1. 码云代码提交记录