Dreidimensionales int Array erweitern/verkleinern

[Vehementis]

Hallo :meld:
Bei meinem aktuellen Projekt bin ich auf ein Problem gestoßen...
und zwar hab ich ein Dreidimensionales int Array bei dem 2 größen fest sind aber eine sich dauernd Ändert? (Anfangs wird es gefüllt mit immer neuen werten, später sollen einzelne werte wieder eliminiert werden)
also: z.B. arr[a][x] (a und b sind unveränderlich)
hierbei wird x anfangs unbestimmt groß und entspricht außerdem der anzahl an Variationen die ich dann in der 3. Dimension speichere.
Einige Variationen werden dann später ausgeschlossen... diese möchte ich dann auch aus dem Array entfernen damit mir arr[a].length() immer die aktuelle anzahl der Variationen ausgibt...
Die Werte die ich in b speicher liegen zwischen 0 und 2, desweiteren ist für jedes a das x unterschiedlich groß.
ein weiteres Problem ist, dass ich eine möglichst effektive variante suche das Array zu erweitern bzw. verkleinern, da es in einer Schleife läuft und häufig aufgerufen wird...

ich hab auch schon an eine ArrayList gedacht... jedoch habe ich da keine Erfahrung mit und weiß nicht ob das umsetzbar/besser ist. :bahnhof:

ich hoffe ihr könnt mir einen Tipp geben damit ich da weiter komme...
Google war mir leider keine große Hilfe

 

[SilverClaw]

Wenn man nun wüsste, wofür das ganze gut sein sollte, wäre es ja einfacher, darauf zu eine gute Antwort zu geben...aber prinzipiell läst sich ein Array nunmal nicht in der Größe ändern.
Aber:

1. Wie du erwähnt hast kann man eine ArrayList benutzen...wie die Performance dabei aussieht, hängt alleridngs davon ab, was du mit deinem 3-Dimensionalen Konstrukt vor hast. Im Zweifel wohl nicht viel schlechter als bei den anderen Möglichkeiten und es wäre bei weitem die einfachste Lösung.
ArrayList<ArrayList<DatenTyp>> list = new ArrayList<>(); geht wunderbar und müsste sich beliebig schachteln lassen.

2. Man könnte Platzhalter benutzen, also z.B. manche Stellen im Array zwischendurch auf null oder einen anderen "leer"-Wert setzen. Ob das Sinn macht, hängt aber davon ab, was genau du vorhast.

3. Anstatt die Größe eines Arrays zu verändern kann man höchstens einen neuen Anlegen, der ihn ersetzt. Man müsste dann über ArrayCopy (nur sinnvoll, wenn am Anfang oder Ende gelöscht wrd) oder eine Schleife die noch benutzten Werte umkopieren.

 

[Vehementis]

ich hatte vorhin nicht so viel zeit das ausführlich zu erklären da ich los musste.
ich versuch ein Programm zur Lösung von Nonogrammen zu schreiben...
ich bin mir nicht sicher ob das klappt aber nen versuch ist es wert...
bis jetzt habe ich mir ein bestimmtes nonogramm rausgesucht (10x10) und die Spalten und Zeilen Besetzung in ein zweidimensionales array geschrieben:

int s[][] = {{3,1},{2,1,1},{1,2,1},{2,3,1},{1,1,3},{1,1,1},{2,4,1},{1,2,3},{2,1,1},{3,1}};
int z[][] = {{4},{3,3},{2,2},{1,1},{1,6,1},{3,3},{1,1},{1,2},{1,1},{10}};

nun will ich alle möglichen Besetzungen in ein dreidimensionales array bringen

also int S[Spaltenzahl][anzahl Möglichkeiten][Zeilenzahl]
hier würde ich dann z.B. durch S[0].length() die anzahl der Möglichkeiten in der ersten spalte bekommen
und durch S[1].length() von der 2. usw.

durch vergleichen der Möglichkeiten in spalten und Zeilen und festsetzen von Feldern die bei allen gleich sind könnte ich dann nach und nach einzelne Möglichkeiten ausschließen und so hoffentlich auf die Lösung kommen...

nur leider scheine ich mit arrays da nicht wirklich weiter zu kommen...

 

[SilverClaw]

Musste mir jetzt erstmal anschauen, was Nonogramme sind...bin also nicht grade der Experte darin.
Aber wenn es dir nur darum geht, Möglichkeiten auszuschließen, würde es ja reichen, ausgeschlossene einfach auf "null" zu setzen und die restlichen durchzählen zu lassen...oder - was performance-sparender wäre - einfach runterzuzählen, wenn eine Option ausgeschlossen wird.
Ansonsten wären, wie bereits erwähnt, ArrayLists das Mittel der Wahl.
Ob das ganze überhaupt der richtige Ansatz zum Lösen des Problems ist, bleibt eine andere Frage.

 

[Vehementis]

Ich hab es hinbekommen...
das mit den ArrayLists hat sehr gut funktioniert...

hier nochmal ein beispiel wie ich ich es gemacht hab für alle die eventuell das selbe Problem haben.

ArrayList<ArrayList<Integer[]>> S = new ArrayList<>();

for (int i=0;i<10;i++)
{
    S.add(getList(5,3));
}

private ArrayList<Integer[]> getList(int anz, int x)
{
    ArrayList<Integer[]> Arr = new ArrayList<>();
    for (int i=0; i<anz; i++)
    {
        Arr.add(new Integer[x]);
        for (int j=0; j<x; j++)
        {
            int b =(int) (Math.random()*5);
            Arr.get(i)[j] = b;
        }
    }
    return Arr;
}

und schon hat mein ein [10][5][3] Array gefüllt mit Zufallszahlen von 0 bis 5

zum löschen von Einträgen einfach

S.get(3).remove(1);

Die Werte hinter [3][1] rutschen nach, so dass man mit

S.get(3).size()

nun eine 4 bekommt