java - 继续陷入无限循环(Java)

Question

我是一名 Java 新手，正在尝试构建一个程序，该程序使用数据结构对给定文本文件中的唯一单词进行计数。为了练习起见，我自己实现了数据结构和抽象类。但是，当我运行该程序时，当涉及到 MyArrayList 的 add 方法时，我陷入了无限循环。

本例中的对象是一个 SingleWord 对象，由字符串单词和用于跟踪频率的整数计数组成。我没有在此处包含用于创建对象的类。

public class MyArrayList<E> extends MyAbstractList<E> {

    public static final int INITIAL_CAPACITY = 16;
    private E[] data = (E[])new Object[INITIAL_CAPACITY];

  /** Create a default list */
  public MyArrayList() {
  }

  /** Create a list from an array of objects */
  public MyArrayList(E[] objects) {
    for (int i = 0; i < objects.length; i++)
      add(objects[i]); // Warning: don’t use super(objects)! 
  }

  @Override /** Add a new element at the specified index */
  public void add(int index, E e) {
    ensureCapacity();

    // Move the elements to the right after the specified index
    for (int i = size - 1; i >= index; i--)
      data[i + 1] = data[i];

    // Insert new element to data[index]
    data[index] = e;

    // Increase size by 1
    size++;
  }

  /** Create a new larger array, double the current size + 1 */
  private void ensureCapacity() {
    if (size >= data.length) {
      E[] newData = (E[])(new Object[size * 2 + 1]);
      System.arraycopy(data, 0, newData, 0, size);
      data = newData;
    }
  }

  @Override /** Clear the list */
  public void clear() {
    data = (E[])new Object[INITIAL_CAPACITY];
    size = 0;
  }

  @Override /** Return true if this list contains the element */
  public boolean contains(E e) {
    for (int i = 0; i < size; i++)
      if (e.equals(data[i])) return true;

    return false;
  }

  @Override /** Return the element at the specified index */
  public E get(int index) {
    checkIndex(index);
    return data[index];
  }

  private void checkIndex(int index) {
    if (index < 0 || index >= size)
      throw new IndexOutOfBoundsException
        ("index " + index + " out of bounds");
  }

  @Override /** Return the index of the first matching element 
   *  in this list. Return -1 if no match. */
  public int indexOf(E e) {
    for (int i = 0; i < size; i++)
      if (e.equals(data[i])) return i;

    return -1;
  }

  @Override /** Return the index of the last matching element 
   *  in this list. Return -1 if no match. */
  public int lastIndexOf(E e) {
    for (int i = size - 1; i >= 0; i--)
      if (e.equals(data[i])) return i;

    return -1;
  }

  @Override /** Remove the element at the specified position 
   *  in this list. Shift any subsequent elements to the left.
   *  Return the element that was removed from the list. */
  public E remove(int index) {
    checkIndex(index);

    E e = data[index];

    // Shift data to the left
    for (int j = index; j < size - 1; j++)
      data[j] = data[j + 1];

    data[size - 1] = null; // This element is now null

    // Decrement size
    size--;

    return e;
  }

  @Override /** Replace the element at the specified position 
   *  in this list with the specified element. */
  public E set(int index, E e) {
    checkIndex(index);
    E old = data[index];
    data[index] = e;
    return old;
  }

  @Override
  public String toString() {
    StringBuilder result = new StringBuilder("[");

    for (int i = 0; i < size; i++) {
      result.append(data[i]);
      if (i < size - 1) result.append(", ");
    }

    return result.toString() + "]";
  }

  /** Trims the capacity to current size */
  public void trimToSize() {
    if (size != data.length) { 
      E[] newData = (E[])(new Object[size]);
      System.arraycopy(data, 0, newData, 0, size);
      data = newData;
    } // If size == capacity, no need to trim
  }

  @Override /** Override iterator() defined in Iterable */
  public java.util.Iterator<E> iterator() {
    return new ArrayListIterator();
  }


  private class ArrayListIterator 
      implements java.util.Iterator<E> {
    private int current = 0; // Current index 

    @Override
    public boolean hasNext() {
      return (current < size);
    }

    @Override
    public E next() {
      return data[current++];
    }

    @Override
    public void remove() {
      MyArrayList.this.remove(current);
    }
  }

  public static StringWord compare(StringWord w1, StringWord w2, Comparator<StringWord> c) {
      if(c.compare(w1.word,w2.word) > 0)
          return w1;
      else
          return w2;
  }

}

这是我的抽象类

public abstract class MyAbstractList<E> implements MyList<E> {
  protected int size = 0; // The size of the list

  /** Create a default list */
  protected MyAbstractList() {
  }

  /** Create a list from an array of objects */
  protected MyAbstractList(E[] objects) {
    for (int i = 0; i < objects.length; i++)
      add(objects[i]);
  }

/** Add a new element at the end of this list */
  @Override
  public void add(E e) {
    add(size, e);
  }


  @Override /** Return true if this list contains no elements */
  public boolean isEmpty() {
    return size == 0;
  }

  @Override /** Return the number of elements in this list */
  public int size() {
    return size;
  }

  @Override /** Remove the first occurrence of the element e 
   *  from this list. Shift any subsequent elements to the left.
   *  Return true if the element is removed. */
  public boolean remove(E e) {
    if (indexOf(e) >= 0) {
      remove(indexOf(e));
      return true;
    }
    else
      return false;
  }
}

这是我的界面 MyList

public interface MyList<E> extends java.lang.Iterable<E> {
  /** Add a new element at the end of this list */
  public void add(E e);

  /** Add a new element at the specified index in this list */
  public void add(int index, E e);

  /** Clear the list */
  public void clear();

    /** Return true if this list contains the element */
  public boolean contains(E e);

  /** Return the element from this list at the specified index */
  public E get(int index);

  /** Return the index of the first matching element in this list.
   *  Return -1 if no match. */
  public int indexOf(E e);

  /** Return true if this list contains no elements */
  public boolean isEmpty();

  /** Return the index of the last matching element in this list
   *  Return -1 if no match. */
  public int lastIndexOf(E e);

  /** Remove the first occurrence of the element o from this list.
   *  Shift any subsequent elements to the left.
   *  Return true if the element is removed. */
  public boolean remove(E e);

  /** Remove the element at the specified position in this list
   *  Shift any subsequent elements to the left.
   *  Return the element that was removed from the list. */
  public E remove(int index);

  /** Replace the element at the specified position in this list
   *  with the specified element and returns the new set. */
  public Object set(int index, E e);

  /** Return the number of elements in this list */
  public int size();

  /** Return an iterator for the list */
  public java.util.Iterator<E> iterator();
}

主要方法等

import java.io.*;
import java.util.*;
import javax.swing.JOptionPane;

public class DataStruc{
    public static void main(String[] args) throws Exception{
        boolean continueProcess = false;
        Scanner input;
        MyList<SingleWord> list = new MyArrayList<SingleWord>();

        //prompt user for input
        do {
            input = readFile(continueProcess).useDelimiter("[^A-Za-z]+");

            //process input(file)
            while (input.hasNext()) {
                list.add(new SingleWord(input.next()));
            }

            System.out.println(list);

            //prompt user to continue input
            int option = JOptionPane.showConfirmDialog(
                            null,
                            "Continue opening file?",
                            "Select an Option",
                            JOptionPane.YES_NO_OPTION );
            continueProcess = (option == 0)? true : false;
        } while(continueProcess);
    }

    public static Scanner readFile(boolean continueProcess) throws Exception{
        String filename;
        File file;
        do {
            filename = JOptionPane.showInputDialog("Enter file name:");
            file = new File(filename);
            if (file.exists()) { //if file exist, process the file
                System.out.println("\"" + filename + "\"" + " is found.");
                continueProcess = false;
            } else if (filename == null) { //if user click cancel
                System.exit(0);
            } else if(filename.length() == 0) { //if user click yes without entering any value
                System.out.println("No file name has been entered.");
                System.out.println("Please try again.");
                continueProcess = true;
            }
            else{ //if the file does not exist
                System.out.println("File " +
                                    "\"" + filename + "\"" + 
                                    " does not exist");
                continueProcess = true;
            }
        } while(continueProcess);

        return new Scanner(file);
    }

}

创建 SingleWord 对象的类

public class SingleWord{
    private int count = 1;
    private String word;

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

     public String getWord() {
        return word;
    }


    public int getCount() {
    return count;
    }

    @Override
    public String toString() {
    return word;
    }
}

抱歉，谢谢你:'(

文本文件在这里:

An article (abbreviated art) is a word (or prefix or suffix) that is used with a noun to indicate the type of reference being made by the noun. Articles specify grammatical definiteness of the noun, in some languages extending to volume or numerical scope. The articles in the English language are the and a/an, and (in some contexts) some. 'An' and 'a' are modern forms of the Old English 'an', which in Anglian dialects was the number 'one' (compare 'on', in Saxon dialects) and survived into Modern Scots as the number 'ane'. Both 'on' (respelled 'one' by the Normans) and 'an' survived into Modern English, with 'one' used as the number and 'an' ('a', before nouns that begin with a consonant sound) as an indefinite article. they're "a"

Answer 1

这是因为抽象类的 add 方法正在调用自身。

@Override
public void add(E e) {
    add(e);
}

我想你想要的东西更像是:

@Override
public void add(E e) {
    add(size, e);
}