Reihen aus einem 2-dim. Array 'löschen'

[Stinner]

Hallo,
habe hier eine Performance frage.
Ich will bestimmte Daten aus einem zwei-dim. Array löschen.
Momentan mache ich es so:

public void rowDelete(int[] rows, String [][] data) {
		String[][] tmp;
		int k = 0;
		if (data != null && data[0] != null) {
			tmp = new String[data.length - rows.length][data[0].length];
			for (int i = 0; i < data.length; i++) {
				if (!indexInArray(i, rows)) {
					for (int j = 0; j < data[0].length; j++) {
						tmp[k][j] = data[i][j];
					}
					k++;
				}
			}
			data = tmp;
		}
	}

Dabei ist die indexInArray Methode auch relativ simpel:

private boolean indexInArray(int i, int[] rows) {
		for (int j = 0; j < rows.length; j++) {
			if (i == rows[j])
				return true;
		}
		return false;
	}

Diese Lösung funktioniert, aber ich denke es dauert bei großen Daten zu lange.
Habe jetzt diesen unfertigen (nicht funktionsfähigen) Ansatz:

public void rowDelete(int[] rows, String [][]data) {
		//Hier ist das Problem, dass data 2 dim. hat
                List list = Arrays.asList(data)
                for(int i; i<rows.length; i++){
                list.remove(i);
                    }
                data = list.toArray();
	}

Das müsste klappen, Problem ist aber dass ich ein 2 dim. habe. Was kann ich da tun?

Denke auch nur, dass es schneller ist, da ich mir viele Schleifen spare. Kann natürlich aber sein, dass die Konvertierungen viel teurer sind.
Was meint ihr dazu, bzw. wie könnte ich das rausfinden?

GRuß, Stinner

 

[Marco13]

Eigentlich funktioniert keiner der beiden Ansätze: "data" wird verändert, aber das ist immer nur die Lokale Variable - d.h. der Ergebnisarray müßte zurückgegeben werden, so dass der Aufruf sein könnte
[c]String newData[][] = rowDelete(rows, initialData);[/c]

Der zweite funktioniert nicht, weil die "List" auf einem Array basiert, und deswegen unmodifiable ist.

Die erste wird bei vielen zu löschenden Daten extrem langsam, weil er SEHR oft den resamten "rows"-Array durchlaufen muss, nur um festzustellen, dass er die aktuelle Zeile NICHT löschen muss.

Es gibt da verschiedene Möglichkeiten. Einer wäre vielleicht sowas wie hier in der "rowDelete1": Den Eingabearray in ein Set umwandeln, aus dem Set alle zu löschenden rows löschen, und den Set dann wieder zurückverwandeln in einen Array...

import java.util.*;

class RowDelete
{
    public static void main(String args[])
    {
        //test();
        bench();
    }

    private static void bench()
    {
        for (int rows = 10000; rows <= 100000; rows += 10000)
        {
            int numToDelete = rows / 10;
            int toDelete[] = createRowsToDelete(rows, numToDelete);
            long before = 0;
            long after = 0;

            String input[][] = createInputData(rows, 5);

            before = System.nanoTime();
            String result0[][] = rowDelete0(toDelete, input);
            after = System.nanoTime();
            System.out.println(result0.length+" "+rows+" array based "+((after-before)/1000000));

            before = System.nanoTime();
            String result1[][] = rowDelete1(toDelete, input);
            after = System.nanoTime();
            System.out.println(result1.length+" "+rows+" set   based "+((after-before)/1000000));
        }

    }



    private static void test()
    {
        String input[][] = createInputData(10, 4);
        int toDelete[] = createRowsToDelete(10, 3);

        System.out.println("input");
        print(input);

        System.out.println("result0");
        String result0[][] = rowDelete0(toDelete, input);
        print(result0);

        System.out.println("result1");
        String result1[][] = rowDelete1(toDelete, input);
        print(result1);
    }



    private static int[] createRowsToDelete(int rows, int numToDelete)
    {
        Random random = new Random(0);
        Set<Integer> result = new HashSet<Integer>();
        while (result.size() < numToDelete)
        {
            result.add(random.nextInt(rows));
        }
        int array[] = new int[numToDelete];
        int index = 0;
        for (Integer i : result)
        {
            array[index] = i;
            index++;
        }
        return array;
    }



    private static String[][] createInputData(int rows, int columns)
    {
        String result[][] = new String[rows][columns];
        for (int i=0; i<rows; i++)
        {
            for (int j=0; j<columns; j++)
            {
                result[i][j] = "String"+i+","+j;
            }
        }
        return result;
    }

    private static void print(String s[][])
    {
        for (int i=0; i<s.length; i++)
        {
            for (int j=0; j<s[i].length; j++)
            {
                System.out.print(s[i][j]+", ");
            }
            System.out.println("");
        }
    }



    public static String[][] rowDelete1(int[] rows, String [][] data)
    {
        LinkedHashSet<String[]> set = new LinkedHashSet<String[]>(Arrays.asList(data));
        for (int i=0; i<rows.length; i++)
        {
            set.remove(data[rows[i]]);
        }
        return (String[][])set.toArray(new String[set.size()][]);
    }


    public static String[][] rowDelete0(int[] rows, String [][] data) {
        String[][] tmp = data;
        int k = 0;
        if (data != null && data[0] != null) {
            tmp = new String[data.length - rows.length][data[0].length];
            for (int i = 0; i < data.length; i++) {
                if (!indexInArray(i, rows)) {
                    for (int j = 0; j < data[0].length; j++) {
                        tmp[k][j] = data[i][j];
                    }
                    k++;
                }
            }
            data = tmp;
        }
        return tmp;
    }

    private static boolean indexInArray(int i, int[] rows) {
        for (int j = 0; j < rows.length; j++) {
            if (i == rows[j])
                return true;
        }
        return false;
    }
}

 

[Stinner]

Hi,
das data Array ist eigntlich ein Feld. Deshalb funktioniert der erste Ansatz.

Werde jetzt aber deinen Vorschlag ungetestet (also auf Zeit) übernehmen. Müsste ja schneller laufen.

Gruß