java实现离散傅里叶变换(附完整源码)

以下是Java实现离散傅里叶变换的代码：

public class DiscreteFourierTransform {
    public static Complex[] dft(double[] x) {
        int N = x.length;
        Complex[] X = new Complex[N];
        for (int k = 0; k < N; k++) {
            X[k] = new Complex(0, 0);
            for (int n = 0; n < N; n++) {
                double angle = 2 * Math.PI * k * n / N;
                Complex c = new Complex(Math.cos(angle), -Math.sin(angle));
                X[k] = X[k].add(c.multiply(x[n]));
            }
        }
        return X;
    }

    public static void main(String[] args) {
        double[] x = {1, 2, 3, 4};
        Complex[] X = DiscreteFourierTransform.dft(x);
        for (int k = 0; k < X.length; k++) {
            System.out.println("X[" + k + "] = " + X[k]);
        }
    }
}

class Complex {
    private double real;
    private double imag;

    public Complex(double real, double imag) {
        this.real = real;
        this.imag = imag;
    }

    public Complex add(Complex other) {
        return new Complex(this.real + other.real, this.imag + other.imag);
    }

    public Complex multiply(Complex other) {
        double real = this.real * other.real - this.imag * other.imag;
        double imag = this.real * other.imag + this.imag * other.real;
        return new Complex(real, imag);
    }

    @Override
    public String toString() {
        return String.format("%.2f + %.2fi", real, imag);
    }
}

代码中，我们定义了一个DiscreteFourierTransform类，用来实现离散傅里叶变换。dft方法接收一个double类型的数组x作为输入，返回一个Complex类型的数组X，表示x的傅里叶变换结果。

在dft方法中，我们首先获取x的长度N，并且定义一个Complex类型的数组X，用来存储变换结果。然后，我们对于每个k值(0<=k<N)，遍历x数组，计算出变换公式中的复数c，并将c和对应的x[n]相乘，累加到X[k]中。最后，返回X数组。

在main方法中，我们定义了一个double类型的数组x，并且调用dft方法计算其傅里叶变换结果。然后，我们遍历X数组，输出每个元素。

需要注意的是，上述代码实现的是一维离散傅里叶变换。如果需要进行多维变换，需要进行一定的改动。此外，在实际应用中，也需要考虑计算效率等问题。