如何修复OutOfMemoryError:Java堆空间？

嗨，我需要帮助修复我的WordLadder程序的OutOfMemoryError。基本上，我在输入wordladder文件（其中包含开始和结束单词）的中途创建世界阶梯后，速度明显减慢，出现错误。我相信这个错误是由于创建了几个堆栈而没有删除已经使用过的堆栈

错误发生在getNewStacks方法的WordStack文件的第74行，正如名称所示，该方法应该获得新的堆栈

以下是所有必需的文件：

---

字典文本：

---

输入文本：

---

WordLadder main：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class WordLadder {
    public static void main(String args[]) throws FileNotFoundException {
        Dictionary dictionary = new Dictionary(new File("dictionary.txt"));

        Scanner scan = new Scanner(new File("input.txt"));
        while (scan.hasNextLine()) {
            String start = scan.next();
            String stop = scan.next();

            System.out.println(findLadder(start, stop, dictionary));
        }
    }


    static String findLadder(String start, String end, Dictionary dictionary) {

        if (!dictionary.contains(start) || !dictionary.contains(end)) {
            return "No word ladder between \"" + start + "\" and \"" + end + "\".";
        }

        if (start.equals(end)) return start + " " + end;

        LinkedList stackQueue = new LinkedList();

        stackQueue.enqueue(new WordStack(start, end));

        boolean continueSearch;
        boolean success = false;

        WordStack ladder = new WordStack();

        do {
            int queueSize = stackQueue.size();
            continueSearch = false;

            for (int stackIndex = 0; stackIndex < queueSize; stackIndex++) {
                LinkedList newStacks = ((WordStack) stackQueue.dequeue()).getNewStacks(dictionary);
                if (newStacks.size > 0) {
                    while (newStacks.size() > 0) {
                        WordStack next = (WordStack) newStacks.dequeue();
                        if (next.success()) {
                            success = true;
                            ladder = next;
                            break;
                        }
                        stackQueue.enqueue(next);
                    }
                    continueSearch = true;
                }
                if (success) break;
            }
            if (success) break;
        } while (continueSearch);

        if (success) return ladder.toString();
        else return "No word ladder between \"" + start + "\" and \"" + end + "\".";
    }
}

---

链接列表：

public class LinkedList {
   Node head;
   Node tail;
   int size;


   LinkedList() {
      head = null;
      tail = null;
      size = 0;
   }

   LinkedList hardCopy() {
      LinkedList copy = new LinkedList();
      if(size() < 1) return copy;

      Node current = head;

      while(current.getNextPtr() != null) {
         copy.addEnd(current.get());
         current = current.getNextPtr();
      }

      copy.addEnd(current.get());

      return copy;
   }

   void iterateHead() {
      head = head.getNextPtr();
      size--;
   }

   void addEnd(Object newObj) {
      enqueue(newObj);
   }

   void add(Object newObj) {
      Node newNode = new Node(newObj);

      if(size == 0) {
         head = newNode;
      }

      else {
         newNode.setNextPtr(head);
         head = newNode;
      }

      size++;
   }


   Object peek() {
      return head.get();
   }

   void push(Object newObj) {
      add(newObj);
   }

   void enqueue(Object newObj) {
      Node newNode = new Node(newObj);

      if(size < 1) {
         head = newNode;
         tail = newNode;
      } else {
         tail.setNextPtr(newNode);

         tail = newNode;
      }

      size++;
   }


   Object pop() {
      Node pop = head;

      if(size > 1) {
         head = head.getNextPtr();
         size--;
         return pop.get();
      }

      else if(size == 1) {
         size--;
         head = null;

         return pop.get();
      }

      else return null;
   }

   Object dequeue() {
      if(size < 1) return null;

      Node dequeueNode = head;

      if(size > 1) {
         iterateHead();
      }
      else {
         head = null;
         tail = null;
         size--;
      }

      return dequeueNode.get();
   }


   int size() {
      return size;
   }


   Object getPeek(int index) {
      if(index >= size) return null;

      Node current = head;
      for(int i = 0; i < index; i++) { 
         current = current.getNextPtr();
      }

      Object data = current.get();
      return data;
   }

}

公共类链接列表{
节点头；
节尾；
整数大小；
LinkedList（）{
head=null；
tail=null；
尺寸=0；
}
LinkedList硬拷贝（）{
LinkedList copy=新建LinkedList（）；
如果（size（）<1）返回副本；
节点电流=头；
while（current.getNextPtr（）！=null）{
copy.addEnd（current.get（））；
current=current.getNextPtr（）；
}
copy.addEnd（current.get（））；
返回副本；
}
void iterateHead（）{
head=head.getNextPtr（）；
大小--；
}
无效加数（对象newObj）{
排队（newObj）；
}
void add（对象newObj）{
Node newNode=新节点（newObj）；
如果（大小==0）{
头=新节点；
}
否则{
newNode.setNextPtr（head）；
头=新节点；
}
大小++；
}
对象peek（）{
返回head.get（）；
}
无效推送（对象newObj）{
添加（newObj）；
}
无效排队（对象newObj）{
Node newNode=新节点（newObj）；
如果（尺寸<1）{
头=新节点；
tail=newNode；
}否则{
tail.setNextPtr（newNode）；
tail=newNode；
}
大小++；
}
对象pop（）{
节点pop=头部；
如果（大小>1）{
head=head.getNextPtr（）；
大小--；
返回pop.get（）；
}
否则如果（大小==1）{
大小--；
head=null；
返回pop.get（）；
}
否则返回null；
}
对象出列（）{
if（size<1）返回null；
Node dequeueNode=head；
如果（大小>1）{
迭代头（）；
}
否则{
head=null；
tail=null；
大小--；
}
返回dequeueNode.get（）；
}
int size（）{
返回大小；
}
对象getPeek（int索引）{
如果（索引>=大小）返回null；
节点电流=头；
对于（inti=0；i

---

---

对于程序运行所需的代码量，我深表歉意。

关于如何设置java堆大小，有很多示例：我将在何处插入命令？您可以在运行程序时添加命令，而不是这样：

java WordLadder

，尝试以下方法以1024兆字节的最大堆大小运行您的程序：

java-xmx1024mWordLadder

您能解释一下您想要实现的目标吗？例如，findLadder和GetNewstack在理论上应该做什么？类字典的实现是什么？你为什么不使用和可能？很抱歉，可能会有很多问题让你不知所措，但我想问的是，也许有一种更有效的方法可以做到这一点。大概不确定，但我认为值得一问。

    public class Node {
       public Object data;
       Node next;

       Node() {
          data = null;
          next = null;
       }

       Node(Object data) {
          this.data = data;
          next = null;
       }

       Object get() {
          return data;
       }

       void set(Object data) {
          this.data = data;
       }

       Node getNextPtr() {
          return next;
       }

       void setNextPtr(Node next) {
          this.next = next;
       }

       public String toString() {
          return "" + data;
       }
    }

public class LinkedList {
   Node head;
   Node tail;
   int size;


   LinkedList() {
      head = null;
      tail = null;
      size = 0;
   }

   LinkedList hardCopy() {
      LinkedList copy = new LinkedList();
      if(size() < 1) return copy;

      Node current = head;

      while(current.getNextPtr() != null) {
         copy.addEnd(current.get());
         current = current.getNextPtr();
      }

      copy.addEnd(current.get());

      return copy;
   }

   void iterateHead() {
      head = head.getNextPtr();
      size--;
   }

   void addEnd(Object newObj) {
      enqueue(newObj);
   }

   void add(Object newObj) {
      Node newNode = new Node(newObj);

      if(size == 0) {
         head = newNode;
      }

      else {
         newNode.setNextPtr(head);
         head = newNode;
      }

      size++;
   }


   Object peek() {
      return head.get();
   }

   void push(Object newObj) {
      add(newObj);
   }

   void enqueue(Object newObj) {
      Node newNode = new Node(newObj);

      if(size < 1) {
         head = newNode;
         tail = newNode;
      } else {
         tail.setNextPtr(newNode);

         tail = newNode;
      }

      size++;
   }


   Object pop() {
      Node pop = head;

      if(size > 1) {
         head = head.getNextPtr();
         size--;
         return pop.get();
      }

      else if(size == 1) {
         size--;
         head = null;

         return pop.get();
      }

      else return null;
   }

   Object dequeue() {
      if(size < 1) return null;

      Node dequeueNode = head;

      if(size > 1) {
         iterateHead();
      }
      else {
         head = null;
         tail = null;
         size--;
      }

      return dequeueNode.get();
   }


   int size() {
      return size;
   }


   Object getPeek(int index) {
      if(index >= size) return null;

      Node current = head;
      for(int i = 0; i < index; i++) { 
         current = current.getNextPtr();
      }

      Object data = current.get();
      return data;
   }

}