理论

1、下列关于泛型描述错误的是

b

2、下列描述错误的是

d

3、以下描述中错误的是

E

4、关于迭代器的说法中错误的是

d

5、以下说法中错误的是

6、简述Colleciton接口的子接口(List/Set/Queue的特点

Set：不能存放重复内容，所有重复的内容靠HashCode()和equals（）两个方法区分
Queue：队列接口
List:可以重复内容

7、阅读代码，指出其中的错误并改正

1.class  Grade<  T  >{
    
    
2.      private  T  stuGrade;
3.      public  void  setStuGrade(T  sGrade){
    
    /*类型  参数名*/
4.                this.stuGrade=sGrade;
5.      }
6.      public  T  getStuGrade(){
    
    
7.                return  stuGrade;
8.      }
9.      public  static  <  E  >  void  Numprint(  E[]  list)  {
    
    
10.            for  (int  i  =  0;  i  <  list.length;  i++)  {
    
    
11.                      System.out.print(list[i]+"  ");
12.            }
13.      }
14.}
15.public    class  TestGrade{
    
    
16.      public  static  void  main(String[]  args){
    
    
17.              Grade<  Float  >    g  =  new  Grade<    >();
18.              g.setStuGrade(89.8);
19.              float  stuGrade  =  g.getStuGrade();
20.              System.out.println("student  grade  is  :"  +  stuGrade);
21.              Integer[]  integers  =  {
    
    2,3,4};
22.              Grade<  Integer  >.Numprint(  integers  );
23.        }
24.}

setStuGrade的参数要Float
Grade.Numprint (integers); 改成Grade.Numprint (integers);

8、阅读以下代码，写出运行结果

import  java.util.*;

public  class  Testlist2  {
    
    
        public  static  void  main(String[]args){
    
    
                LinkedList  link  =  new  LinkedList();
                link.add("日");
                link.add("()");
                link.add("月");
                link.add("（）");
                System.out.println(link.toString());
                link.remove(1);
                link.removeLast();
                link.add(1,"新");
                link.addLast("异");
                System.out.println(link.toString());
                ArrayList  alist  =  new  ArrayList();
                alist.add("日");
                alist.add("()");
                alist.add("月");
                alist.add("()");
                alist.set(1,"积");
                alist.set(3,"累");
                Iterator  it  =  alist.iterator();
                while  (it.hasNext()){
    
    
                        Object  obj  =  it.next();
                        System.out.println(obj);
        }
}

[日, (), 月, ()]
[日, 新, 月, 异]
日
积
月
累

9、阅读以下代码，写出运行结果

import  java.util.*;

public  class  TestListSet{
    
    
        public  static  void  main(String  args[]){
    
    
                ArrayList  list  =  new  ArrayList();
                list.add("1");
                list.add("2");
                list.add("3");
                list.add("2");
                list.add("1");
                System.out.println(list);
                HashSet  setlist  =  new  HashSet();
                setlist.addAll(list);
                System.out.println(setlist.size());
                Iterator  it  =  setlist.iterator();
                while  (it.hasNext()){
    
    
                        Object  obj  =  it.next();
                        System.out.println(obj);
                }
        }

}

[1, 2, 3, 2, 1]
3
1
2
3

10、曹老师专业是医学信息工程，崔老师专业是临床医学，请定义教师类，属性包含姓名和专业名称。将两位教师存入ArrayList集合中，并遍历集合打印教师信息。

package com.company;


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

import static com.company.ThrowExceptioinApp.f;


class Main{
    
    
    public static void main(String[] args) {
    
    
        List<Teacher> t = new ArrayList<>();
        t.add(new Teacher("曹老师","医学信息工程"));
        t.add(new Teacher("崔老师","临床医学"));

        for(Teacher teacher:t){
    
    
            System.out.println(teacher);
        }
    }

}

package com.company;

public class Teacher {
    
    
    private String name;
    private String major;

    public Teacher(){
    
    }
    public Teacher(String name,String major){
    
    
        this.name = name;
        this.major = major;
    }

    public String getName(){
    
    
        return this.name;
    }

    public void setMajor(String major) {
    
    
        this.major = major;
    }

    public String getMajor() {
    
    
        return major;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    @Override
    public String toString(){
    
    
        return "Teacher{" +
                "name='" + name + '\'' +
                ", major='" + major + '\'' +
                '}';
    }
}

实践

了解Java中泛型的概念的基本使用方法，能够设计泛型相关的类和方法。在了解泛型的基础上，能够理解Java常见模板类的设计及使用方法，并能够根据应用问题选择合适的模板类实现相应功能

1、自定义堆栈类

用泛型数组实现自定义堆栈类，可处理任意类型数据。 其中堆栈类功能中要求至少包含以下几点：

• 不带参数构造方法和带一个长度参数构造方法，表明堆栈的初始长度
• 入栈push操作和出栈pop操作
• 访问栈顶元素peek方法
• 获得栈中当前保存元素数size方法
• 其它自定义方法，比如显示堆栈中保存所有元素方法

定义一测试方法，可分别构建整数类型、浮点类型、字符串类型堆栈进行测试，对每个栈自行调用上述至少三种方法实现操作，并显示堆栈中元素

两个java文件一个stack.java，一个main.java

package com.company;

public class Stack<T> {
    
    
    private T[] stack;
    private int max;
    private int top;

    public Stack(){
    
    
        this(10);
    }

     public Stack(int size){
    
    
        this.top = 0;
        this.max = size;
        this.stack = (T[]) new Object[size];
     }

     public boolean isFull(){
    
    
        return top==max;
     }

     public boolean isEpty(){
    
    
        return top==0;
     }

     public void push(T element){
    
    
        if(isFull()){
    
    
            System.out.println("Stack full!");
            return;
        }
        stack[top] = element;
        top++;
     }

     public void pop(){
    
    
        if(isEpty()){
    
    
            System.out.println("stack empty!!");
            return ;
        }
        top--;
        System.out.println(stack[top]);
     }

     public void peek(){
    
    
        if(isEpty()){
    
    
            System.out.println("stack is empty!");
            return ;
        }
        System.out.println(stack[top]);
     }

     public int size(){
    
    
        return top+1;
     }

     public void show(){
    
    
        System.out.println("stack top");
        for(int i =top-1;i>=0;i--){
    
    
            System.out.println(stack[i]);
        }
        System.out.println("stack below");

     }
}

main.java

package com.company;


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



class Main{
    
    
    public static void main(String[] args) {
    
    
        Stack<Integer> stack = new Stack<>(5);
        stack.push(10);
        stack.push(2);
        stack.push(3);
        stack.show();
        stack.pop();
        stack.pop();
        stack.show();
        Stack<Boolean> booleanStack = new Stack<>();
        booleanStack.push(true);
        booleanStack.push(false);
        booleanStack.push(true);
        booleanStack.show();
    }

}

2. 用泛型对数值类型数组求解

利用泛型定义一数组操作类ArrayOp，操作对象为数值类型数组，其中数值类型包括Integer, Short, Byte, Double, Float等，提供若干类的静态方法，实现对任意数值类型数组的下述操作，：

1. 求平均值 average(T[] t)
2. 求数组最大元素 max(T[] t)
3. 对数组元素采用冒泡方法进行排序 bubbleSort(T[] t)
4. 对数组元素利用选择排序方法进行排序 selectionSort(T[] t)
5. 求两长度相同数组的和(对应元素的和) arraySum(T[] ta, T[] tb)

在此基础上定义测试类，测试各方法功能是否正常
Aarrayop.java与Main.java

package com.company;

public class ArrayOp<T extends Number> {
    
    
    public static <T extends Number> double average(T[] t){
    
    
        double sum = 0;
        for(T t1:t){
    
    
            double add = t1.doubleValue();
            sum += add;
        }
        double avg = sum/t.length;
        return avg;
    }

    public static<T extends Number> T max(T[] t){
    
    
        T max = t[0];
        for(int i =0;i<t.length;i++){
    
    
            if(t[i].doubleValue() > max.doubleValue()){
    
    
                max = t[i];
            }
        }
        return max;
    }

    public static <T extends Number>T[] bubbleSort(T[] t){
    
    
        T tmp;
        if(t.length < 2 || t== null){
    
    
            return t;
        }
        for(int i =0;i<t.length-1;i++){
    
    
            for(int j =0;j<t.length-1-i;j++){
    
    
                if(t[i].doubleValue() > t[j+1].doubleValue()){
    
    
                    tmp = t[j];
                    t[j] = t[j+1];
                    t[j+1] = tmp;
                }
            }
        }
        return t;
    }

    public static <T extends Number>T[] selectSort(T[] t) {
    
    
        if (t.length < 2 || t == null) {
    
    
            return t;
        }
        for(int i=0;i<t.length-1;i++){
    
    
            T min = t[i];
            int minIndex = i;
            for(int j = i+1;j<t.length;j++){
    
    
                if(t[j].doubleValue() < min.doubleValue()){
    
    
                    min = t[j];
                    minIndex = j;
                }
            }
            t[minIndex] = t[i];
            t[i] = min;
        }
        return t;
    }

    public static <T extends Number>double[] arraySum(T[] t1,T[] t2){
    
    
        double[] sum = new double[t1.length];
        for(int i =0;i<t1.length;i++){
    
    
            sum[i] = t1[i].doubleValue() + t2[i].doubleValue();
        }
        return sum;
    }
}

main.java

package com.company;


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



class Main{
    
    
    public static void main(String[] args) {
    
    
        Integer[] array = {
    
    6,4,2,8,12};
        Integer[] array1 = {
    
    6,4,1,8,5,9,14};
        double average = ArrayOp.average(array);
        Integer max = ArrayOp.max(array);
        Integer bubbleSort[] = ArrayOp.bubbleSort(array);
        Integer[] selectSort = ArrayOp.selectSort(array1);
        System.out.println("平均值" + average);
        System.out.println("最大值" + max);
        System.out.println("bubbleSort sort of result；" + Arrays.toString(bubbleSort));
        System.out.println("selectsort sort of result；" + Arrays.toString(selectSort));
        Float[] arr3 = {
    
    2f,3f,4f,7f,1f};
        Double[] arr2 = {
    
    1.0,1.0,1.5,1.5,1.5,1.0,1.0,1.0};
        //编译通过算成功。

    }

}

3、找电影

用一个字符串表示目前拥有的电影片名，请设计一个生成器类MovieGenerator，包含一成员， 为该字符串，请设计方法实现以下指定功能，以实现对电影片名的处理：

1. 一个生成方法next，可以获取下一部电影片名，其中如果已获取完毕所有的电影名，则循环到第一部影片名开始

2. 分别用生成器类填充不同类型的容器类型，包括ArrayList, LinkedList, HashSet, LinkedHashSet和TreeSet等，具体实现至少包含两种不同类型容器，以及填充一普通字符串数组，再分别打印每一个容器或数组中的所有内容

比如电影片名的声明如下： static String movie = “战狼,湄公河行动,流浪地球,夏洛特烦恼,我不是药神”; 可以用Array.split(“,”)方式生成String的数组。 collection.addAll(Arrays.asList(movie.split(“,”)));//数组转List加到集合中

两个java文件，一个MoveGenerator文件还有一个Main.java
oveGenerator.java

package com.company;

public class MoveGenerator {
    
    
    private String movie;
    private static int index = 0;
    public MoveGenerator(String movie){
    
    
        this.movie = movie;
    }
    public String  next(){
    
    
        String[] movies = movie.split(",");
        String m = movies[index%movies.length];
        index++;
        return m;
    }
}

main.java

package com.company;


import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;

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



class Main{
    
    
    static String movie = "战狼,湄公河运动,流浪地球,夏洛特无烦恼,我就是药神";
    public static void main(String[] args) {
    
    
        MoveGenerator movieGenera = new MoveGenerator(movie);
        List arraylist = new ArrayList();
        int i=0;
        while(i++<=6){
    
    
            arraylist.add(movieGenera.next());
        }
        List linkList = new LinkedList();
        Collection hasSe = new HashSet();
        linkList.addAll(Arrays.asList(movie.split(",")));
        hasSe.addAll(Arrays.asList("1,2,3,4,5,6,7,8,9".split(",")));
        for(i =0;i<arraylist.size();i++){
    
    
            System.out.println(arraylist.get(i));
        }
        for(i =0;i<linkList.size();i++){
    
    
            System.out.println(linkList.get(i));
        }
        Iterator it = hasSe.iterator();
        while(it.hasNext()){
    
    
            String next = (String)it.next();
            System.out.println(next = " ");
        }
    }
}

4、容器的迭代器

自定义一个任意类，及其toString()方法，使用ArrayList\LinkedList\Vector等任一容器类，往其中填充各种数据，使用Iterator遍历容器，打印输出其中每个元素
两个java文件，一个User.java,另一个main.java

User.java

package com.company;

public class User {
    
    
    private String name;
    private int age;
    public User(){
    
    

    }
    public User(String name,int age){
    
    
        this.name = name;
        this.age = age;
    }
    public String getName(){
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }
    @Override
    public String toString(){
    
    
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';


    }
}

main.java

package com.company;


import jdk.nashorn.internal.ir.visitor.NodeOperatorVisitor;

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



class Main{
    
    
    public static void main(String[] args) {
    
    
        List<User> userList = new ArrayList<>();
        userList.add(new User("zhang",12));
        userList.add(new User("wag",22));
        userList.add(new User("liu",32));
        userList.add(new User("zhao",42));
        userList.add(new User("zhchen",52));
        Iterator<User> it = userList.iterator();
        while(it.hasNext()){
    
    
            User next = it.next();
            System.out.println(next);
        }
    }
}