我正在尝试使用数组实现堆栈来反转声音文件。有些东西无限循环，经过几个小时的尝试，我似乎无法弄清楚它是什么。
这是我的堆栈：
import java.util.EmptyStackException;
import java.util.Arrays;
public class ArrayStack
implements DStack {
private int size = 0;
private static int DEFAULT_CAPACITY = 10;
private Double ArraySt[];
public ArrayStack(){
ArraySt = new Double[DEFAULT_CAPACITY];
for(int i = 0; i < DEFAULT_CAPACITY; i++){
ArraySt[i] = 0.0;
}
size = ArraySt.length;
}
public boolean isEmpty(){
boolean empty = true;
if(ArraySt != null) {
empty = false;
}
return empty;
}
public void push(double d){
if(size == ArraySt.length){
increaseCapacity();
}
for(int i = 0; i < size; i++){
ArraySt[i] = d;
}
}
public double pop(){
double popped = 0;
boolean empty = isEmpty();
if(empty == true){
throw new EmptyStackException();
}
for(int i = 0; i > size; i--){
popped = ArraySt[i];
ArraySt[i] = null;
}
return popped;
}
public double peek(){
boolean empty = isEmpty();
if(empty == true){
throw new EmptyStackException();
}
double stackTop = pop();
return stackTop;
}
// private Double[] increaseCapacity(){
// int arrayLength = ArraySt.length;
// int newCapacity = ArraySt.length*2;
// Double[] increaseArray = new Double[newCapacity];
// for(int i = 0; i < arrayLength; i++){
// Double k = ArraySt[i];
// increaseArray[i] = k;
//
// }
// return increaseArray;
// }
private void increaseCapacity(){
int newCapacity = ArraySt.length;
ArraySt = Arrays.copyOf(ArraySt, newCapacity);
}
}
这是客户端程序：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
/**
* Read a .dat file and reverse it.
*
* @version CSE373, 14sp
*/
public class ReverseRedux {
@SuppressWarnings("unused")
public static void main(String[] args) {
if (args.length != 3) {
System.err.println(" Incorrect number of arguments");
System.err.println(" Usage: ");
System.err
.println("\tjava Reverse <stack type> <input file> <output file>");
System.exit(1);
}
boolean useList = true;
if (args[0].compareTo("list") == 0)
useList = true;
else if (args[0].compareTo("array") == 0)
useList = false;
else {
System.err.println("\tSaw " + args[0]
+ " instead of list or array as first argument");
System.exit(1);
}
try {
//
// Set up the input file to read, and the output file to write to
//
BufferedReader fileIn = new BufferedReader(new FileReader(args[1]));
PrintWriter fileOut = new PrintWriter(new BufferedWriter(
new FileWriter(args[2])));
//
// Read the first line of the .dat file to get sample rate.
// We want to store the sample rate value in a variable,
// but we can ignore the "; Sample Rate" part of the line.
// Step through the first line one token (word) at a time
// using the StringTokenizer. The fourth token is the one
// we want (the sample rate).
//
StringTokenizer str;
String oneLine;
int sampleRate;
String strJunk;
oneLine = fileIn.readLine();
str = new StringTokenizer(oneLine);
strJunk = str.nextToken(); // Read in semicolon
strJunk = str.nextToken(); // Read in "Sample"
strJunk = str.nextToken(); // Read in "Rate"
// Read in sample rate
sampleRate = Integer.parseInt(str.nextToken());
//
// Read in the remainder of the file on line at a time.
// The values in the first column are thrown away.
// Place values from the second column on the stack.
// Stop reading if we reach the end of the file.
//
DStack s;
if (useList)
s = new ListStack();
else
s = new ArrayStack();
String timestep;
double data;
int count = 0;
while ((oneLine = fileIn.readLine()) != null) {
if (oneLine.charAt(0) == ';') {
continue;
}
str = new StringTokenizer(oneLine);
// Read in time step value from first column
timestep = str.nextToken();
// Read in data value from second column
data = Double.parseDouble(str.nextToken());
s.push(data);
count++;
}
System.out.println(count + " samples in file");
//
// Print the data values to output .dat file.
// First, output the header line:
// "; Sample Rate <sample rate>"
//
fileOut.println("; Sample Rate " + sampleRate);
// Since the first column consists of numbers which start
// at 0 and increase by 1/sampleRate every time slice, we'll
// just use numSteps to recalculate these numbers.
int numSteps = 0;
// Finally, we print the values in reverse order (by popping
// them off the stack). The first column consists of numbers
// which start at 0 and increase by 1/sampleRate per row, so
// we'll use numSteps/sampleRate to recalculate the appropriate
// values. Print a tab for uniform spacing.
while (!s.isEmpty()) {
fileOut.println((double) numSteps / sampleRate + "\t" + s.pop());
numSteps++;
}
//
// Close the files
//
fileIn.close();
fileOut.close();
} catch (IOException ioe) {
System.err
.println("Error opening/reading/writing input or output file.");
System.exit(1);
} catch (NumberFormatException nfe) {
System.err.println(nfe.toString());
System.err.println("Error in file format");
System.exit(1);
}
}
}
答案 0 :(得分：0)
isEmpty()永远不会返回false。分配给ArraySt的唯一内容位于构造函数（new Double[DEFAULT_CAPACITY]）和increaseCapacity（Arrays.copyOf(ArraySt, newCapacity)）中。我认为两者都不会将其设置为null。
＆＃34;以相反的顺序打印值＆＃34;部分是永远循环，我猜。
答案 1 :(得分：0)
以下代码有问题。它总是返回0.
public double pop(){
double popped = 0;
boolean empty = isEmpty();
if(empty == true){
throw new EmptyStackException();
}
for(int i = 0; i > size; i--){
popped = ArraySt[i];
ArraySt[i] = null;
}
return popped;
}
此外，由于代码中的错误，数组永远不会为null且为空。因此，永远循环。 为什么不使用LinkedList或ArrayList？特别是LinkedList在这里是合适的候选人。