Question

对，这个话题可能是模糊的，让我首先承认这是一个与家庭作业相关的问题。因此，如果你对这些问题有一些有趣的仇杀，请加以警告。

我已经和它坐了好几个小时了，而且我已经不好意思没有“得到它”了。

所以我希望你们中的一些人可以告诉我我缺少的东西。

我要创建一个存储变量的类，并记住该类的下一个对象。

以下是我的主要课程：

public class SticksAndStones {

public static void main(String[] args) {

    Scanner scan = new Scanner(System.in);
    String response = "n";
    Stick currentStick = null;
    int numberOfSticks = 0;

    while (response.equals("n")) {

        System.out.println("What diameter should the stick have?");
        response = Integer.toString(scan.nextInt());

        currentStick = new Stick(Integer.parseInt(response), currentStick);
        numberOfSticks++;

        System.out.println("Are you done adding sticks? ('n' or 'y')");
        response = scan.next();

        while (!response.equals("y") && !response.equals("n")) {
            System.out.println("Please type 'y' for yes, or 'n' for no.");
            response = scan.next();
        }
    }

    for (int i = 0; i < numberOfSticks; i++) {
        System.out.println(currentStick.getDiameter());
        currentStick = currentStick.getNext();
    }

}
}

My Stick类看起来像：

public class Stick {

int diameter;
Stick stick;

public Stick(int diameter, Stick stick) {

    this.diameter = diameter;
    this.stick = stick;

}

public int getDiameter() {
    return diameter;
}

public Stick getNextStick() {
    return stick;
}

现在你可以看到，我的班级似乎能够记住以前的棒，但不会以任何方式记住下一棒。

这是一个问题的原因，是因为在我的SticksAndStones类的底部，我尝试打印每个伸出的直径，但它们没有以正确的顺序出现。换句话说，第一根棍子最后出现，最后一根棍子首先出现。

我不需要。我需要他们以相反的方式走出来。首先坚持下去，首先坚持下去。

我们在此任务中唯一的限制是我们不能使用任何形式的数组，列表，表格或数据库。

我在这里错过了一些非常简单的东西吗？

PS：会使用“家庭作业”标签，但它不允许。

更新

New SticksAndStones类：

import java.util.Scanner;

public class SticksAndStones {

public static void main(String[] args) {

    Scanner scan = new Scanner(System.in);
    String response = "n";
    int numberOfSticks = 0;

    Stick firstStick = null;
    Stick currentStick = null;
    ;
    Stick prevStick = null;

    while (response.equals("n")) {

        System.out.println("What diameter should the stick have?");
        response = Integer.toString(scan.nextInt());

        if (firstStick == null) {
            firstStick = new Stick(Integer.parseInt(response));
            prevStick = firstStick;
        } else {
            currentStick = new Stick(Integer.parseInt(response));
            prevStick.setNextStick(currentStick);
            prevStick = currentStick;
        }

        numberOfSticks++;

        System.out.println("Are you done adding sticks? ('n' or 'y')");
        response = scan.next();

        while (!response.equals("y") && !response.equals("n")) {
            System.out.println("Please type 'y' for yes, or 'n' for no.");
            response = scan.next();
        }
    }

    currentStick = firstStick;
    for (int i = 0; i < numberOfSticks; i++) {
        System.out.println(currentStick.getDiameter());
        currentStick = currentStick.getNextStick();
    }

}
}

我的Sticks课程：

public class Stick {

int diameter;
Stick stick;
Stick nextStick;

public Stick(int diameter, Stick stick) {

    this.diameter = diameter;
    this.stick = stick;

}

public Stick(int diameter) {
    this.diameter = diameter;
}

public int getDiameter() {
    return diameter;
}

public Stick getNextStick() {
    return stick;
}

public void setNextStick(Stick nextStick) {
    this.nextStick = nextStick;
}
}

微笑和拥抱谁能告诉我为什么我会遇到NullPointerException。

Answer 1

嗯，显然没有Stick可以“记住”第一次创建时的下一根棍子，因为还没有任何下一根棍子。但是如果唯一的Stick构造函数将前一个标记作为参数，那么 - 虽然它非常难看 - 它可以修改前一个标记以引用新标记：< / p>

public Stick(int diameter, Stick previousStick) {
    this.diameter = diameter;
    this.previous = previousStick;
    previousStick.next = this;
}

当然，假设在Stick类中有一个新的和一个重命名的字段。

在创建新Stick之后添加前向引用会更好，但是，Stick构造函数不会修改其参数：

public Stick(int diameter, Stick previousStick) { this.diameter = diameter; this.previous = previousStick; } // ... main() ... Stick newStick = new Stick(Integer.parseInt(response), currentStick); currentStick.setNext(newStick);

此外，如果您希望能够在前进方向上遍历链接列表（这是您正在创建的内容），那么您需要在某处保留对第一个Stick的引用。如果您不需要向后遍历列表，则可以省略跟踪该引用（在这种情况下，Stick构造函数不需要将Stick作为参数）。我将剩下的其余部分供你解决。

Answer 2

一点点的重构还有很长的路要走：

由于不可能知道构造时间next什么是构造函数不应该将其作为参数或者至少给出创建没有nextStick的对象的选项

public Stick(int diameter) {
    this.diameter = diameter;
}

在开始循环添加Sticks之前，请保留3个引用：

Stick firstStick = null;
Stick currentStick;
Stick prevStick = null;

在您要求Diameter后，在while loop内，检查是否已经定义了初始棒，或者您是否在不断添加棒......

if (firstStick == null) {
    firstStick = new Stick(Integer.parseInt(response));
    prevStick = firstStick;                
} else {
    currentStick = new Stick(Integer.parseInt(response));
    prevStick.setNextStick(currentStick);
    prevStick = currentStick;
}

在打印信息时，在您的循环外，您将currentStick设置为指向firstStick并始终循环

currentStick = firstStick;
for (int i = 0; i < numberOfSticks; i++) {
    System.out.println(currentStick.getDiameter());
    currentStick = currentStick.getNextStick();
}

<强>更新

根据您对Stick班级

的更改

这应该是它的样子

public class Stick {

    int diameter;
    Stick stick;

    public Stick(int diameter) {
        this.diameter = diameter;
    }

    public int getDiameter() {
        return diameter;
    }

    public Stick getNextStick() {
        return stick;
    }

    public void setNextStick(Stick stick) {
        this.stick = stick;
    }
}

Answer 3

另一个避免添加第二个引用以使每个Stick记住前一个引用的选项是编写一个递归方法来执行一个post-order traversal棒链：

public static void printSticks(Stick s) {
  if (s != null) {
    printSticks(s.getNextStick());
    System.out.println(s.getDiameter());
  }
}

这种方法不适用于很长的列表，因为它会遇到堆栈溢出错误，但它是如何使用递归算法解决限制的一个例子。您正在使用的数据结构。

Answer 4

你可以让你的班级了解上一支和下一支。

public class Stick {
    private int diameter;
    private Stick previousStick;
    private Stick nextStick;

    public Stick(int diameter, Stick previousStick, Stick nextStick) {
        setDiameter(diameter);
        setPreviousStick(previousStick);
        setNextStick(nextStick);
    }

    //getters and setters
}

然后在您的main方法中，您需要适当地设置它们。这是你应该做的功课＆＃34;。以下是一些起步帮助。想想如何使用它。

Stick lastStick;
Stick currentStick;

lastStick = currentStick;
currentStick = new Stick(diameter, lastStick, null);
lastStick.setNextStick(currentStick);

让对象记住下一个对象

4 个答案: