7-2 jmu-Java-05集合(泛型)-10-GeneralStack(分数 15)

以前定义的IntegerStack接口，只能用于存放Integer类型的数据。然而对于栈来说，不管内部存放的是什么类型的数据，基本操作与元素的具体类型无关。

1. 编写一个通用的GeneralStack接口，接口中的操作对任何引用类型的数据都适用。

一旦定义完毕，只能存放一种类型的数据，比如只能存放String或只能存放Integer。GeneralStack接口方法如下：

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

2.定义GeneralStack的实现类ArrayListGeneralStack

内部使用ArrayList对象存储，属性名为list。

方法:
public String toString()//该方法的代码为return list.toString();

提示：

1. 不用使用top指针。
2. 直接复用ArrayList中已有的方法。
3. pop时应将相应的元素从ArrayList中移除。
4. 代码中不要出现类型不安全的强制转换。

3.定义Car对象

属性：

private int id;
private String name;

方法：Eclipse自动生成setter/getter,toString方法。

4.main方法说明

1. 输入选项，有quit, Integer, Double, Car4个选项。如果输入quit，则直接退出。否则，输入整数m与n。m代表入栈个数，n代表出栈个数。然后声明栈变量stack。
2. 输入Integer,打印Integer Test。建立可以存放Integer类型的ArrayListGeneralStack。入栈m次，出栈n次。打印栈的toString方法。最后将栈中剩余元素出栈并累加输出。
3. 输入Double ，打印Double Test。剩下的与输入Integer一样。
4. 输入Car，打印Car Test。其他操作与Integer、Double基本一样。只不过最后将栈中元素出栈，并将其name依次输出。

2、3、4步骤做完都要使用代码System.out.println(stack.getClass().getInterfaces()[0]);打印标识信息

特别注意：如果栈为空的时候继续出栈，则返回null

输入样例

Integer
5
2
1 2 3 4 5
Double
5
3
1.1 2.0 4.9 5.7 7.2
Car
3
2
1 Ford
2 Cherry
3 BYD
quit

输出样例

Integer Test
push:1
push:2
push:3
push:4
push:5
pop:5
pop:4
[1, 2, 3]
sum=6
interface GeneralStack
Double Test
push:1.1
push:2.0
push:4.9
push:5.7
push:7.2
pop:7.2
pop:5.7
pop:4.9
[1.1, 2.0]
sum=3.1
interface GeneralStack
Car Test
push:Car [id=1, name=Ford]
push:Car [id=2, name=Cherry]
push:Car [id=3, name=BYD]
pop:Car [id=3, name=BYD]
pop:Car [id=2, name=Cherry]
[Car [id=1, name=Ford]]
Ford
interface GeneralStack

 代码：

import java.util.ArrayList;
import java.util.Scanner;

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

    @Override
    public T push(T item) {
        System.out.println("push:" + item);
        if (item == null) return null;
        arrayList.add(item);
        return null;
    }

    @Override
    public T pop() {
        if (arrayList.isEmpty()) {
            System.out.println("pop:" + null);
            return null;}
        T a = arrayList.get(arrayList.size() - 1);
        arrayList.remove(arrayList.size() - 1);
        System.out.println("pop:" + a);
        return a;
    }

    public T get(int index) {
        return arrayList.get(index);
    }

    @Override
    public T peek() {
        if (arrayList.isEmpty()) return null;
        return arrayList.get(arrayList.size() - 1);
    }

    @Override
    public boolean empty() {
        return arrayList.isEmpty();
    }

    @Override
    public int size() {
        return arrayList.size();
    }

    @Override
    public String toString() {
        return arrayList + "";
    }
}
class Car {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Car(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Car [" +
                "id=" + id +
                ", name=" + name +
                ']';
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()) {
            String op = cin.next();
            if (op.equals("quit")) {
                break;
            }
            int m = cin.nextInt(), n = cin.nextInt();
            if (op.equals("Integer")) {
                System.out.println("Integer Test");
                ArrayListGeneralStack<Integer> stack = new ArrayListGeneralStack<>();
                for (int i = 0; i < m; i ++ ) {
                    Integer a = cin.nextInt();
                    stack.push(a);
                }
                for (int i = 0; i < n; i ++ ) {
                    stack.pop();
                }
                System.out.println(stack.toString());
                int sum = 0;
                for (int i = 0; i < stack.size(); i ++ ) {
                    sum += stack.get(i);
                }
                System.out.println("sum=" + sum);
                System.out.println(stack.getClass().getInterfaces()[0]);
            } else if (op.equals("Double")) {
                System.out.println("Double Test");
                ArrayListGeneralStack<Double> stack = new ArrayListGeneralStack<>();
                for (int i = 0; i < m; i ++ ) {
                    Double a = cin.nextDouble();
                    stack.push(a);
                }
                for (int i = 0; i < n; i ++ ) {
                    stack.pop();
                }
                System.out.println(stack.toString());
                double sum = 0;
                for (int i = 0; i < stack.size(); i ++ ) {
                    sum += stack.get(i);
                }
                System.out.println("sum=" + sum);
                System.out.println(stack.getClass().getInterfaces()[0]);
            } else {
                ArrayListGeneralStack<Car> stack = new ArrayListGeneralStack<>();
                System.out.println("Car Test");
                for (int i = 0; i < m; i ++ ) {
                    int num = cin.nextInt();
                    String name = cin.next();
                    Car car = new Car(num, name);
                    stack.push(car);
                }
                for (int i = 0; i < n; i ++ ) {
                    stack.pop();
                }
                System.out.println(stack.toString());
                for (int i = stack.size() - 1; i >= 0; i -- ) {
                    Car info = stack.get(i);
                    System.out.println(info.getName());
                }
                System.out.println(stack.getClass().getInterfaces()[0]);
            }
        }
    }
}