实验十一 泛型和集合的学习

实验十一  泛型和集合的学习

实验目的：

1.  掌握泛型的通配符和泛型的上下限
2.  学习泛型的擦除
3.  掌握Collection集合的方法和迭代器

实验内容：

1. 泛型堆栈类编程

1. 创建一个泛型堆栈类，私有数据成员有：整形变量size表示当前堆栈内容的个数，泛型私数组变量elements存储堆栈元素。公有成员函数有：带参数构造函数，根据传递参数值设置数组的初始容量；push函数，将接收的参数压栈；pop函数出栈，将出栈元素返回；peek函数返回栈顶元素；isEmpty函数判断堆栈是否为空，通过判断size是否为0判断；getSize函数返回当前堆栈大小size。
2. 编写测试程序，分别创建字符串堆栈和double堆栈对象，压栈多个字符串或double数据，显示堆栈大小、栈顶元素，然后用循环语句出栈并按出栈顺序显示元素。再创建一个不指定泛型类型的对象，压栈不同类型的数据，显示堆栈大小、栈顶元素，然后用循环语句出栈并按出栈顺序显示元素。

 

1. 集合函数学习

1. 创建2个列表，{"George", "Jim", "John", "Blake", "Kevin", "Michael"}和{"George", "Katie", "Kevin", "Michelle", "Ryan"}，求它们的并集、交集和差集。
2. 创建一个字符串集的示例如下：

Collection<String> list1=new ArrayList<>(Arrays.asList(new String[]{"George", "Jim", "John", "Blake", "Kevin", "Michael"}));

1. 差集的显示用forEach语句，内部用lambda表达式，交集的显示用迭代器迭代显示
2. 运行结果参见下图：

 

 

 

1. 挑战

1. 完成pair3 项目中的下面几个函数

printBuddles(buddiles); 实现输出buddiles对象的的两个成员

minmaxBonus(managers,result); 实现设置result中的first为奖金低的，second为奖金高的

maxminBoune(managers,result); 调用minmaxBonus(managers,result);函数获取result值，再调用PairAlg.swapHelper(result);交换result中的2个值

1. 项目最后显示结果如下图：

 

import java.util.Collection;

public class StackTest {
    public static void main(String[] args){
        Stack <String>stack1=new Stack(4);
        stack1.push("ally");
        stack1.push("bob");
        stack1.push("skevin");
        System.out.println("字符串堆栈大小有："+stack1.getSize());
        System.out.println("栈顶："+stack1.peek());
        while (!stack1.isEmpty()){
            System.out.print(stack1.pop()+"  ");
        }
        System.out.println();
        System.out.println();
        Stack<Double> stack2=new Stack<>(5);
        stack2.push(1.1);
        stack2.push(2.2);
        stack2.push(3.3);
        stack2.push(4.4);
        stack2.push(5.5);
        System.out.println("double堆栈大小有："+stack2.getSize());
        System.out.println("栈顶："+stack2.peek());
        while (!stack2.isEmpty()) {
            System.out.print(stack2.pop()+"  ");
        }
        System.out.println();
        System.out.println();
        Stack stack3=new Stack(3);
        stack3.push(1.1);
        stack3.push('a');
        stack3.push("hello");
        System.out.println("堆栈大小有："+stack3.getSize());
        System.out.println("栈顶："+stack3.peek());
        while (!stack3.isEmpty()) {
            System.out.print(stack3.pop()+"  ");
        }

    }
}
class Stack<E>{
    private int size;
    private E[] elements;
    public Stack(int s){
        elements=(E[])new Object[s];
    }
    public E push(E value){
        if(size>=elements.length){
            E[] temp=(E[])new Object[elements.length*2];
            System.arraycopy(elements,0,temp,0,elements.length);
            elements=temp;
        }
        return elements[size++]=value;
    }
    public E pop(){
        return elements[--size];
    }
    public E peek(){
        return elements[size-1];
    }
    public boolean isEmpty(){
        return size==0;
    }
    public int getSize(){
        return size;
    }
}

import java.time.LocalDate;

public class Pairtest {
    public static void main(String[] args) {
        Manager ceo=new Manager("Gus Greedy",800000,2003,12,15);
        Manager cfo=new Manager("SId Sneaky",600000,2003,11,15);
        Pair<Manager>buddiles=new Pair<>(ceo,cfo);
        printBuddles(buddiles);
        ceo.setBonus(1000000);
        cfo.setBonus(500000);
        Manager []managers={ceo,cfo};
        Pair<Employee> result=new Pair<>();
        minmaxBonus(managers,result);
        System.out.println("first: "+result.getFirst().getName()+",second: "+result.getSecond().getName());
        maxminBoune(managers,result);
        System.out.println("first: "+result.getFirst().getName()+",second: "+result.getSecond().getName());

    }
    public static void printBuddles(Pair<? extends Employee > p){
        Employee first=p.getFirst();
        Employee second=p.getSecond();
        System.out.println(first.getName()+" and "+second.getName()+" are buddies.");
    }
    public static void minmaxBonus(Manager[] a,Pair<? super Manager> result){
        if(a.length==0)return;
        Manager min=a[0];
        Manager max=a[0];
        for(int i=1;i<a.length;i++){
            if (min.getBonus()>a[i].getBonus())
                min=a[i];
            if (max.getBonus()<a[i].getBonus())
                max=a[i];
        }
        result.setFirst(min);
        result.setSecond(max);
    }
    public static void maxminBoune(Manager[] a,Pair<? super Manager> result){
        minmaxBonus(a,result);
        PairAlg.swapHelper(result);
    }
}
class Pair<T>{
    private T first;
    private T second;
    public Pair(){
        first=null;
        second=null;
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public T getSecond() {
        return second;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setSecond(T second) {
        this.second = second;
    }
}
class PairAlg {
    public static boolean hasNulls(Pair<?> p){
        return p.getFirst()==null||p.getSecond()==null;
    }
    public static void swap(Pair<?>p){
        swapHelper(p);
    }
    public static <T> void swapHelper(Pair<T> p){
        T t=p.getFirst();
        p.setFirst(p.getSecond());
        p.setSecond(t);
    }
}
class Employee {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }

    public Employee(String name, double salary, int year, int month, int day) {
        this.name = name;
        this.salary = salary;
        this.hireDay = LocalDate.of(year,month,day);

    }
}
class Manager extends Employee{
    private double bonus;
    public Manager(String name,double salary,int year,int month,int day){
        super(name,salary,year,month,day);
        bonus=0;
    }
    public double getSalary(){
        double baseSalary=super.getSalary();
        return baseSalary+bonus;
    }
    public void setBonus(double b){
        bonus=b;
    }
    public double getBonus(){
        return bonus;
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class FuncTest {
    public static void main(String[] args) {
        Collection<String> list1=new ArrayList<>(Arrays.asList(new String[]{"George", "Jim", "John", "Blake", "Kevin", "Michael"}));
        Collection <String> list2=new ArrayList<>(Arrays.asList(new String[]{"George", "Katie", "Kevin", "Michelle", "Ryan"}));
        list1.addAll(list2);
        System.out.println("合并集="+list1);
        list1=new ArrayList<>(Arrays.asList(new String[]{"George", "Jim", "John", "Blake", "Kevin", "Michael"}));
        list1.removeAll(list2);
        System.out.print("差集=");
        list1.forEach(obj->System.out.print(obj+" "));
        System.out.println();
        list1=new ArrayList<>(Arrays.asList(new String[]{"George", "Jim", "John", "Blake", "Kevin", "Michael"}));
        list1.retainAll(list2);
        Iterator it=list1.iterator();
        System.out.print("交集=");
        while(it.hasNext()){
            Object o=it.next();
            System.out.print(o+" ");
        }
        System.out.println();
    }
}