在Android上获取FFT的最佳方式是使用Android的AudioRecord类来获取音频数据，然后使用自定义的FFT算法进行变换。

以下是一个示例代码，演示了如何使用Android的AudioRecord类和自定义的FFT算法来获取FFT。

import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.util.Log;

public class FFTExample {

    private static final int SAMPLE_RATE = 44100; // 采样率
    private static final int FFT_SIZE = 1024; // FFT大小
    private static final int BUFFER_SIZE = FFT_SIZE * 2; // 缓冲区大小

    private AudioRecord audioRecord;
    private short[] audioData;
    private FFT fft;

    public FFTExample() {
        // 初始化AudioRecord
        int bufferSize = AudioRecord.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
        audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSize);

        // 初始化音频数据和FFT对象
        audioData = new short[BUFFER_SIZE];
        fft = new FFT(FFT_SIZE);
    }

    public void startRecording() {
        audioRecord.startRecording();

        // 开始录音和处理FFT
        while (true) {
            int numberOfShort = audioRecord.read(audioData, 0, BUFFER_SIZE);
            if (numberOfShort > 0) {
                // 将音频数据传递给FFT对象进行处理
                fft.forward(audioData);

                // 在这里可以进行FFT后的处理，比如获取频谱数据等
                // fft.getSpectrumReal() 获取实部数据
                // fft.getSpectrumImaginary() 获取虚部数据
                // fft.getMagnitudes() 获取幅值谱数据
                // fft.getPhase() 获取相位谱数据
                // ...

                // 示例：计算频谱中最大幅值的频率
                double maxMagnitude = 0;
                double maxFrequency = 0;
                double[] magnitudes = fft.getMagnitudes();
                for (int i = 0; i < magnitudes.length; i++) {
                    if (magnitudes[i] > maxMagnitude) {
                        maxMagnitude = magnitudes[i];
                        maxFrequency = i * SAMPLE_RATE / FFT_SIZE;
                    }
                }
                Log.d("FFTExample", "Max Frequency: " + maxFrequency + " Hz");
            }
        }
    }

    public void stopRecording() {
        audioRecord.stop();
        audioRecord.release();
    }

    // 自定义FFT算法
    private static class FFT {
        private int n;
        private int m;
        private double[] cosTable;
        private double[] sinTable;
        private double[] window;
        private double[] spectrumReal;
        private double[] spectrumImaginary;
        private double[] magnitudes;
        private double[] phase;
        
        public FFT(int n) {
            this.n = n;
            this.m = (int) (Math.log(n) / Math.log(2));
            this.cosTable = new double[n / 2];
            this.sinTable = new double[n / 2];
            this.window = new double[n];
            this.spectrumReal = new double[n / 2];
            this.spectrumImaginary = new double[n / 2];
            this.magnitudes = new double[n / 2];
            this.phase = new double[n / 2];
            
            for (int i = 0; i < n / 2; i++) {
                cosTable[i] = Math.cos(-2 * Math.PI * i / n);
                sinTable[i] = Math.sin(-2 * Math.PI * i / n);
            }
            
            for (int i = 0; i < n; i++) {
                window[i] = 0.54 - 0.46 * Math.cos(2 * Math.PI * i / (n - 1));
            }
        }
        
        public void forward(short[] audioData) {
            for (int i = 0; i < n; i++) {
                int j = Integer.reverse(i) >>> (32 - m);
                spectrumReal[i] = window[i] * audioData[j];
                spectrumImaginary[i] = 0;
            }
            
            for (int i = 0; i < m; i++) {
                int length = 1 << (m - i);
                int halfLength = length / 2;
                double angle = 2 *