java - Eclipse 在 Debug模式下挂起我的进程

Question

所以我正在研究一个涉及链接列表的项目。我们必须自己制作节点和链表(不允许使用Java提供的)。作为该项目的一部分，我正在制作一个列表，该列表将根据某些条件自动调整自身(当输入的单词与已存在的单词相同时，将该节点移动到列表的前面)。我的代码似乎运行良好，但在一段时间后，它就停止运行。当我尝试调试它时，Eclipse 只是在此时暂停了该进程，我无法弄清楚为什么，因为它根本不提供任何反馈。它似乎在 while 循环之一上，但我似乎无法弄清楚为什么。任何帮助将不胜感激。代码比较长，所以我将其粘贴到这面文字墙下面。我在编程方面还不是很有经验，所以你可能会注意到一些错误/烦恼。

SelfAdjustingListOne.java

public class SelfAdjustingListOne extends UnsortedList
{
    public SelfAdjustingListOne()
    {
        super();
    }

    public SelfAdjustingListOne(long timer)
    {
        super(timer);
    }

    public void adjustingAdd(Node input)
    {
        // If there's nothing in the list, make this the first and last node
        if (getFront() == null)
        {
            setFront(input);
            setBack(input);
            input.setIndex(0);
        } else if (sameWord(input) != null)
        {
            // If the word already exists, increment the word count and send that node to
            // the front of the list
            Node sameString = sameWord(input), current = getFront(), previous;
            try
            {
                // Will return null if sameString is the first node on the list
                previous = getByIndex(sameString.getIndex() - 1);
            } catch (NullPointerException e)
            {
                previous = null;
            }
            // If sameString is the first node, no link needs to be set
            if (previous != null)
                previous.setLink(sameString.getLink());
            // Link the node we are moving to the front node
            sameString.setLink(getFront());
            // Set the value of the front node to the node we are moving
            setFront(sameString);
            // Increment its count
            sameString.plusCount();
            // While the current node exists and has not surpassed the previous location of
            // the node we moved, increment the index value of each node by 1
            while (current != null && current.getIndex() != sameString.getIndex())
            {
                current.plusIndex();
                current = current.getLink();
            }
            // Set the new front node's index to 0 (Beginning of the list)
            sameString.setIndex(0);
            plusComparisons();
            plusComparisons();
        } else
        {
            // If the list has at least one node and the word being added doesn't exist, add
            // this node to the front of the list
            input.setLink(getFront());
            Node current = getFront();
            while (current != null)
            {
                current.plusIndex();
                current = current.getLink();
            }
            setFront(input);
            input.setIndex(0);
            plusComparisons();
            plusNodeChanges();
            plusNodeChanges();
        }
    }
}

UnsortedList.java

import java.text.DecimalFormat;

public class UnsortedList
{
    private Node front;
    private Node back;
    private Long timer;
    private int numOfComparisons;
    private int nodeChanges;

    public UnsortedList()
    {

    }

    public UnsortedList(long timer)
    {
        this.timer = timer;
    }

    public void addBack(Node input)
    {
        if (front == null)
        {
            setFront(input);
            setBack(input);
            input.setIndex(0);
        } else if (sameWord(input) != null)
        {
            Node sameString = sameWord(input);
            sameString.plusCount();
            numOfComparisons += 2;
        } else
        {
            getBack().setLink(input);
            input.setIndex(back.getIndex() + 1);
            setBack(input);
            numOfComparisons++;
            nodeChanges += 2;
        }
    }

    public void addFront(Node input)
    {
        if (front == null)
        {
            setFront(input);
            setBack(input);
            input.setIndex(0);
        } else if (sameWord(input) != null)
        {
            Node sameString = sameWord(input);
            sameString.plusCount();
            numOfComparisons += 2;
        } else
        {
            input.setLink(front);
            Node current = front;
            while (current != null)
            {
                current.plusIndex();
                current = current.getLink();
            }
            setFront(input);
            input.setIndex(0);
            numOfComparisons++;
            nodeChanges += 2;
        }
    }

    public void remove(int index)
    {
        Node current = front;
        do
        {
            if (current.getIndex() == index - 1)
            {
                if (current.getLink().getLink() != null)
                {
                    current.getLink().setIndex(-1);
                    current.setLink(current.getLink().getLink());
                    Node currentIndexNode = current.getLink();
                    while (currentIndexNode != null)
                    {
                        currentIndexNode.minusIndex();
                        currentIndexNode = currentIndexNode.getLink();
                    }
                } else
                {
                    current.getLink().setIndex(-1);
                    current.setLink(null);
                }
            }
            current = current.getLink();
        } while (!current.isEqual(back));
    }

    public void setFront(Node input)
    {
        front = input;
    }

    public void setBack(Node input)
    {
        back = input;
    }

    public Node getFront()
    {
        return front;
    }

    public Node getBack()
    {
        return back;
    }

    public Node getByIndex(int index) throws NullPointerException
    {
        Node current = front, currentIndexNode = current.getLink();
        while (current != null)
        {
            do
            {
                if (current.getIndex() == index)
                    return current;
                current = currentIndexNode;
                currentIndexNode = currentIndexNode.getLink();
            } while (currentIndexNode != null);
        }
        return null;
    }

    public Node getByWord(String word) throws NullPointerException
    {
        Node current = front, currentIndexNode = current.getLink();
        while (current != null)
        {
            do
            {
                if (current.getWord().equalsIgnoreCase(word))
                    return current;
                current = currentIndexNode;
                currentIndexNode = currentIndexNode.getLink();
            } while (currentIndexNode != null);
        }
        return null;
    }

    public int totalWords()
    {
        Node current = front;
        int totalWords = 0;
        while (current != null)
        {
            totalWords += current.getCount();
            current = current.getLink();
        }
        return totalWords;
    }

    public int totalUniqueWords()
    {
        Node current = front;
        int totalUniqueWords = 0;
        while (current != null)
        {
            totalUniqueWords++;
            current = current.getLink();
        }
        return totalUniqueWords;
    }

    public int totalNumOfComparisons()
    {
        return numOfComparisons;
    }

    public int totalNodeChanges()
    {
        return nodeChanges;
    }

    public String totalTimeElapsed()
    {
        if (timer == null)
            return "This is an untimed list";
        DecimalFormat threePlaces = new DecimalFormat("#0.000");
        return threePlaces.format((System.nanoTime() - timer) * Math.pow(10, -9)) + " seconds";
    }

    public void plusComparisons()
    {
        numOfComparisons++;
    }

    public void plusNodeChanges()
    {
        nodeChanges++;
    }

    protected Node sameWord(Node input)
    {
        Node current = front;
        while (current != null)
        {
            if (current.getWord().equalsIgnoreCase(input.getWord()))
                return current;
            current = current.getLink();
        }
        return null;
    }
}

Node.java

public class Node
{
    private Node link;
    private String word;
    private int count = 1;
    private int index = -1;

    public Node(String word)
    {
        this.word = word;
    }

    public Node getLink()
    {
        return link;
    }

    public String getWord()
    {
        return word;
    }

    public int getCount()
    {
        return count;
    }

    public int getIndex()
    {
        return index;
    }

    public void setLink(Node input)
    {
        link = input;
    }

    public void setWord(String input)
    {
        word = input;
    }

    public void setCount(int input)
    {
        count = input;
    }

    public void setIndex(int input)
    {
        index = input;
    }

    public void plusCount()
    {
        count++;
    }

    public void plusIndex()
    {
        index++;
    }

    public void minusIndex()
    {
        index--;
    }

    public boolean isEqual(Node input)
    {
        if (input.getWord().equalsIgnoreCase(this.word))
            return true;
        return false;
    }
}

运行SelfAdjustingListOne的代码

public static SelfAdjustingListOne salo;
public static void main(String[] args)
    {
        System.out.println("Running fifth pass...");
        System.out.println("Time to execute fifth pass: " + pass5());
    }
public static String pass5()
    {
        salo = new SelfAdjustingListOne(System.nanoTime());
            try
            {
                Scanner scanner = new Scanner(new File(fileDirectory + fileNames[0] + fileExtension));
                while (scanner.hasNext())
                {
                    String s = scanner.next();
                    s.replaceAll("^[^a-zA-Z0-9]+", "");
                    s.replaceAll("[^a-zA-Z0-9]+$", "");
                    if (s.length() == 1 || s.length() == 0)
                    {
                        if (!Character.isAlphabetic(s.charAt(0)) && !Character.isDigit(s.charAt(0)))
                            continue;
                    }
                    salo.adjustingAdd(new Node(s));
                }
                scanner.close();
            } catch (FileNotFoundException e)
            {
                System.out.println("No file found matching that name/directory");
            }
        return salo.totalTimeElapsed();
    }

它说正在读取的文件是《蜜蜂电影脚本》，由于帖子的最大长度，我无法发布该脚本，但任何文本文件都可以。

Answer 1

在 samabcde 的帮助下我解决了这个问题。

这里的代码块需要更改:

if (previous != null)
previous.setLink(sameString.getLink());
// Link the node we are moving to the front node
sameString.setLink(getFront());
// Set the value of the front node to the node we are moving
setFront(sameString);

对此:

if(sameString != getFront())
{
    sameString.setLink(getFront());
    // Set the value of the front node to the node we are moving
    setFront(sameString);
}

它链接到自身，因为它从未检查它设置链接的节点是否已经是列表中的第一个节点，因此将链接设置为等于其自身。