将包含带有字段的 class 的列表转换为多个 arrays 的最快方法是什么？ -

Question

I just want to have a confirm if this is the only fastest way to turn the class Data fields into arrays, or this can be done better.

First I have a class called Data and it contains lot of fields. The class Data is generated into a List<Data> called selectedData and I want to extract all the fields from Data into Float[] arrays.

Can this be done in a faster way?

// Fill the values for the plot
int selectedSamples = selectedData.size();
Float[] A0 = new Float[selectedSamples];
Float[] A1 = new Float[selectedSamples];
Float[] A2 = new Float[selectedSamples];
Float[] A3 = new Float[selectedSamples];
Float[] SA0 = new Float[selectedSamples];
Float[] SA1 = new Float[selectedSamples];
Float[] SA1D = new Float[selectedSamples];
Float[] SA2D = new Float[selectedSamples];
Float[] SA3D = new Float[selectedSamples];
Float[] PWM0 = new Float[selectedSamples];
Float[] PWM1 = new Float[selectedSamples];
Float[] PWM2 = new Float[selectedSamples];
Float[] PWM3 = new Float[selectedSamples];
Float[] PWM4 = new Float[selectedSamples];
Float[] PWM5 = new Float[selectedSamples];
Float[] PWM6 = new Float[selectedSamples];
Float[] PWM7 = new Float[selectedSamples];
Float[] PWM8 = new Float[selectedSamples];
Float[] DAC0 = new Float[selectedSamples];
Float[] DAC1 = new Float[selectedSamples];
Float[] DAC2 = new Float[selectedSamples];
for(int i = 0; i < selectedSamples; i++){
    Data data = selectedData.get(i);
    A0[i] = data.getA0();
    A1[i] = data.getA1();
    A2[i] = data.getA2();
    A3[i] = data.getA3();
    SA0[i] = data.getSa0();
    SA1[i] = data.getSa1();
    SA1D[i] = data.getSa1d();
    SA2D[i] = data.getSa2d();
    SA3D[i] = data.getSa3d();
    PWM0[i] = (float) data.getP0();
    PWM1[i] = (float) data.getP1();
    PWM2[i] = (float) data.getP2();
    PWM3[i] = (float) data.getP3();
    PWM4[i] = (float) data.getP4();
    PWM5[i] = (float) data.getP5();
    PWM6[i] = (float) data.getP6();
    PWM7[i] = (float) data.getP7();
    PWM8[i] = (float) data.getP8();
    DAC0[i] = (float) data.getD0();
    DAC1[i] = (float) data.getD1();
    DAC2[i] = (float) data.getD2();
}

Edit

Can this be an alternative?

    SeriesThread a0Thread = new SeriesThread(selectedData, A0, "A0");
    a0Thread.start();
    SeriesThread a1Thread = new SeriesThread(selectedData, A1, "A1");
    a1Thread.start();
    SeriesThread a2Thread = new SeriesThread(selectedData, A2, "A2");
    a2Thread.start();
    SeriesThread a3Thread = new SeriesThread(selectedData, A3, "A3");
    a3Thread.start();
    SeriesThread sa0Thread = new SeriesThread(selectedData, SA0, "SA0");
    sa0Thread.start();
    SeriesThread sa1Thread = new SeriesThread(selectedData, SA1, "SA1");
    sa1Thread.start();
    SeriesThread sa1dThread = new SeriesThread(selectedData, SA1D, "SA1D");
    sa1dThread.start();
    SeriesThread sa2dThread = new SeriesThread(selectedData, SA2D, "SA2D");
    sa2dThread.start();
    SeriesThread sa3dThread = new SeriesThread(selectedData, SA3D, "SA3D");
    sa3dThread.start();
    SeriesThread pwm0Thread = new SeriesThread(selectedData, PWM0, "P0");
    pwm0Thread.start();
    SeriesThread pwm1Thread = new SeriesThread(selectedData, PWM1, "P1");
    pwm1Thread.start();
    SeriesThread pwm2Thread = new SeriesThread(selectedData, PWM2, "P2");
    pwm2Thread.start();
    SeriesThread pwm3Thread = new SeriesThread(selectedData, PWM3, "P3");
    pwm3Thread.start();
    SeriesThread pwm4Thread = new SeriesThread(selectedData, PWM4, "P4");
    pwm4Thread.start();
    SeriesThread pwm5Thread = new SeriesThread(selectedData, PWM5, "P5");
    pwm5Thread.start();
    SeriesThread pwm6Thread = new SeriesThread(selectedData, PWM6, "P6");
    pwm6Thread.start();
    SeriesThread pwm7Thread = new SeriesThread(selectedData, PWM7, "P7");
    pwm7Thread.start();
    SeriesThread pwm8Thread = new SeriesThread(selectedData, PWM8, "P8");
    pwm8Thread.start();
    SeriesThread dac0Thread = new SeriesThread(selectedData, DAC0, "D0");
    dac0Thread.start();
    SeriesThread dac1Thread = new SeriesThread(selectedData, DAC1, "D1");
    dac1Thread.start();
    SeriesThread dac2Thread = new SeriesThread(selectedData, DAC2, "D2");
    dac2Thread.start();
    // Wait until all threads are not alive
    while(a0Thread.isAlive() || 
            a1Thread.isAlive() || 
            a2Thread.isAlive() || 
            a3Thread.isAlive() ||
            sa0Thread.isAlive() || 
            sa1Thread.isAlive() || 
            sa1dThread.isAlive() || 
            sa2dThread.isAlive() || 
            sa3dThread.isAlive() || 
            pwm0Thread.isAlive() ||
            pwm1Thread.isAlive() ||
            pwm2Thread.isAlive() ||
            pwm3Thread.isAlive() ||
            pwm4Thread.isAlive() ||
            pwm5Thread.isAlive() ||
            pwm6Thread.isAlive() ||
            pwm7Thread.isAlive() ||
            pwm8Thread.isAlive() ||
            dac0Thread.isAlive() ||
            dac1Thread.isAlive() ||
            dac2Thread.isAlive()) {}

Where the thread class is:

public class SeriesThread extends Thread {
    
    private List<Data> selectedData;
    private Float[] seriesData;
    private String fieldName;

    public SeriesThread(List<Data> selectedData, Float[] seriesData, String fieldName) {
        this.selectedData = selectedData;
        this.seriesData = seriesData;
        this.fieldName = fieldName;
    }

    @Override
    public void run() {
        int i = 0;
        switch(fieldName) {
        case "A0":
            for(Data data : selectedData)
                seriesData[i++] = data.getA0();
            break;
        case "A1":
            for(Data data : selectedData)
                seriesData[i++] = data.getA1();
            break;
        case "A2":
            for(Data data : selectedData)
                seriesData[i++] = data.getA2();
            break;
        case "A3":
            for(Data data : selectedData)
                seriesData[i++] = data.getA3();
            break;
        case "SA0":
            for(Data data : selectedData)
                seriesData[i++] = data.getSa0();
            break;
        case "SA1":
            for(Data data : selectedData)
                seriesData[i++] = data.getSa1();
            break;
        case "SAD1":
            for(Data data : selectedData)
                seriesData[i++] = data.getSa1d();
            break;
        case "SAD2":
            for(Data data : selectedData)
                seriesData[i++] = data.getSa2d();
            break;
        case "SAD3":
            for(Data data : selectedData)
                seriesData[i++] = data.getSa3d();
            break;
        case "P0":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP0();
            break;
        case "P1":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP1();
            break;
        case "P2":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP2();
            break;
        case "P3":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP3();
            break;
        case "P4":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP4();
            break;
        case "P5":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP5();
            break;
        case "P6":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP6();
            break;
        case "P7":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP7();
            break;
        case "P8":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getP8();
            break;
        case "D0":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getD0();
            break;
        case "D1":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getD1();
            break;
        case "D2":
            for(Data data : selectedData)
                seriesData[i++] = (float) data.getD2();
            break;
        
        }
    }
}

Answer 1

I did a simple test of 1 million entries. Using Float[] arrays took about 2.5 seconds to copy the data. Using float[] arrays took about .38 seconds. This was a basic test and didn't use anything as sophisticated as JMH but the delta is such that using primitive arrays is significantly faster. I expect this is due to the overhead of boxing and unboxing of the the data.

Answer 2

You may use reflection ( getCLass().getFields() and then iterate over them ) - it will be more generic but not really faster.