我是一个Java新手试图构建一个程序，该程序使用数据结构计算给定文本文件的唯一单词。为了实践起见，我自己实现了数据结构和抽象类。但是，当我运行程序时，当涉及到add方法是MyArrayList时，我陷入无限循环。
在这种情况下，对象是一个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;
}
}
抱歉，谢谢你：'（
文本文件在这里：
文章（缩写为art）是与名词一起使用的单词（或前缀或后缀），用于表示名词所引用的引用类型。文章规定了名词的语法确定性，在某些语言中扩展到数量或数值范围。英语中的文章是和/和，在某些情况下（在某些情况下）。 'an'和'a'是古英语'an'的现代形式，在Anglian方言中是数字'one'（在撒克逊方言中比较'on'）并且作为'ane'存在于Modern Scots中。两个'on'（由诺曼人推翻'一个'）和'an'幸存到现代英语中，其中'one'用作数字，'an'（'a'，在以辅音声音开头的名词之前）不定冠词。他们是“一个”
答案 0 :(得分：5)
这是因为抽象类的add方法正在调用它自己。
@Override
public void add(E e) {
add(e);
}
我想你想要更像的东西：
@Override
public void add(E e) {
add(size, e);
}
答案 1 :(得分：0)
Offcourse它是无限循环，你递归地调用相同的方法。您必须更改比较方法代码块，如下所示：
public static SingleWord compare(SingleWord w1, SingleWord w2, Comparator<String> c) {
if (c.compare(w1.getWord(), w2.getWord()) > 0) {
return w1;
} else {
return w2;
}
}