Java 在同一类中的堆栈上调用方法

我正在制作一个程序，它接收一系列的

整数

，并将它们放入一个

统计学家策略

。我在试图找出如何调用此堆栈上的其他方法时遇到了困难。关于如何调用

nextNumber

方法中的所有其他方法，有什么建议吗

统计学家策略：

public class StatisticianStack {

    Stack<Integers> stack = new Stack();


    public  void nextNumber(Integer stackNums){
        stack.push(stackNums);
        stack.length(); // what I would want to do, but do not know what to pass it.

    }

     public static int length(StatisticianStack numbers){

         if(numbers.isEmpty())
                 return 0;

         int sizeOfStack = numbers.size();
         return sizeOfStack;
    }

     public static int sum(Stack<Integer> numbers){
         int sum = 0;
         if(numbers.isEmpty())
                 return sum;

         for(int i = 0; i < numbers.size(); i++)
             sum = sum + numbers.pop();

         return sum;
     }

     public static Double mean(Stack<Integer> numbers){
         double mean = 0;
         double sum = 0;

         if(numbers.isEmpty())
                 return Double.NaN;

         for (int i = 0; i < numbers.size(); i++){
             sum += i;
         }
         mean = sum/numbers.size();
         return mean;
     }

     public static Double largestNum(Stack<Integer> numbers){
         double largestNum = numbers.firstElement();

         if(numbers.isEmpty())
                 return Double.NaN;

         for (int i = 0; i < numbers.size(); i++){
             if(largestNum < numbers.pop())
                 largestNum = numbers.pop();

         }
         return largestNum;
     }

     public static Double smallestNum(Stack<Integer> numbers){
         double smallestNum = numbers.firstElement();

         if(numbers.isEmpty())
                 return Double.NaN;

         for (int i = 0; i < numbers.size(); i++){
             if(smallestNum > numbers.pop())
                 smallestNum = numbers.pop();

         }
         return smallestNum;
     }
}

public class StatisticianStackDemonstartion {

    public static Integer numbers;
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    StatisticianStack stack = new StatisticianStack();
    stack.nextNumber(-1);


    }

}

`

---

有什么建议吗？谢谢。

这里有很多psudo代码和缺少的contex。但是您同时拥有

stack.push（stackNums）

和

stacks.push（stackNums）

。你能提供更多的上下文和错误信息吗？

现在我明白了。您可能想在这里考虑面向对象

您有一个StatististicanStack类型的对象：

StatisticianStack stack = new StatisticianStack();

然后将一些数字放入该堆栈：

stack.nextNumber(-1);
stack.nextNumber(2.34);
stack.nextNumber(17);

然后，您需要对堆栈中的所有元素进行一些计算：

int length = stack.getLength();
double mean = stack.getMean();
double largest = stack.getLargestNumber();
double smallest = stack.getSmallestNumber();

为此，您需要首先更改方法签名：

public class StatisticanStack {
  Stack<Double> stack = new Stack<Double>();

  public void nextNumber(Double stackNums) {
    stack.push(stackNums);
  }

  public int length() {
    return stack.size();
  }

  public double sum() {

  }

  public double mean() {

  }

  public double largestNum() {

  }

  public double smallestNum() {

  }
}

等等

---

您可能想澄清您想要的“最小”数字：最接近零？最负面？

@Jan我最近的编辑说明了我想做什么。因此，我会在main中创建一个StatisticanStack，并在其上调用

nextNumber

方法。。。看看我的最新编辑-我想我现在明白你想要什么了。是的！这正是我想要做的。请参阅我使用Java8Lambda表达式编辑添加的实现。随时可以投票/接受：-）长度如何（这个）？@saka1029由于主方法中的

统计学家策略

而无法工作。在方法

nextNumber（）

中，

此

表示一个

StatisticianStack

实例，它将在“无法将StatisticianStack转换为整数堆栈”的行周围出现错误。因此，方法中的

length（this）

调用静态方法

statisticianstack.length（statisticanstacknumber）

import java.util.Stack;

public class StatisticanStack {

    Stack<Double> stack = new Stack<Double>();

    public void nextNumber(Double stackNums) {
        stack.push(stackNums);
    }

    public void nextNumber(Integer stackNums) {
        stack.push(new Double(stackNums));
    }

    public int length() {
        return stack.size();
    }

    public double sum() {
        return stack.stream()
        .mapToDouble(Double::doubleValue)
        .sum();
    }

    public double mean() {
        return stack.stream()
                .mapToDouble(Double::doubleValue)
                .average().getAsDouble();
    }

    public double largestNum() {
        return stack.stream()
                .mapToDouble(Double::doubleValue)
                .max().getAsDouble();
    }

    public double smallestNum() {
        return stack.stream()
                .mapToDouble(Double::doubleValue)
                .min().getAsDouble();
    }

    public static void main(String... args) {
        StatisticanStack stack = new StatisticanStack();
        stack.nextNumber(-1);
        stack.nextNumber(2.34);
        stack.nextNumber(17);
        System.out.println(stack.smallestNum());
        System.out.println(stack.largestNum());
        System.out.println(stack.mean());
        System.out.println(stack.sum());
    }

}

public double sum() {
    double sum = 0;
    for(Double entry : stack) {
        sum += entry.doubleValue();
    }
    return sum;
}