Arrays, Arrays, Arrays..

[Haskellnoob]

Hallo,

Bin noch ein blutiger Anfänger, was Java angeht.

Hab hier ein 2Dimensionales Array (char[][]) und weiß einfach nicht
wie ich es dynamisch mache - also damit die erste Spalte rausgenommen wird
und dafür hinten eine rangemacht.
Müsste vielleicht in etwa so aussehen

if (y == 0){
array[x][y] = array[x][y+1];
}

etc.. ? Ich weiß nicht genau was zu tun ist, muss ich eine Methode kreiren und
in das vorhandene Array reinkopieren?
Später wird das alles mit ActionListener verbunden werden müssen. Aber
zuerst wäre ich mal froh wenn überhaupt was geht.

Kann einer helfen? Stehe irgendwie auf dem Schlauch. Danke 🙁

 

[Thallius]

Du solltest mal unter ArrayList suchen.

Gruß

Claus

 

[kaoZ]

Wenn du diese Funktionalität selbst implementieren möchtest schau dir mal

System.arrayCopy();

bzw.

Arrays.copy();

oder auch

Arrays.copyOfRange();

an

ansonsten wie schon erwähnt wurde eine Collection verwenden , bei welcher diese Funktionalität bereits implementiert ist.

So könnte man das ganze bei einem Eindimensionalen int Array umsetzen

Spoiler: Foo.java

public class Foo{
	
	private int[] example;
	private int count;
	
	public Foo(int length) {
		this.example = new int[length];
		this.count = 0;
    }
	
	public void add(int i){
		this.count = count + 1;
		
		if (count > example.length) {
	        this.example = Arrays.copyOf(example, example.length + 1);
        }	
	}
	
	public int lenght(){
		return example.length;
	}

	public static void main(String[] args) {
	    Foo f = new Foo(2);
	    
	    f.add(1);
	    f.add(2);
	    System.out.println(f.lenght());  // hier wäre der Datencontainer nun voll.
	    
	    f.add(4); // <<-- das wäre normalerweise nicht möglich !
	    System.out.println(f.lenght()); 
	    
	    /* funktioniert aber da wir beim aufrufen der add() methode
	     * zuerst prüfen ob der counter größer ist als das Array
	     * und falls dem so sein sollte
	     * erweitern wir das array um ein Feld, hier könnte man auch mit einem 
	     * buffer arbeiten der dementsprechend einen puffer von x% hinzufügt anstelle
	     * eines Feldes.
	     */
	    
    }
}

je nachdem wie man an dieser Stelle dann die Bedingung gestaltet

if (count > example.length)

könnte man das Array auch direkt schon erweitern sobald

 count == der länge des Array

ist.

 

[Haskellnoob]

Okay, ich lese mich mal ein :rtfm:

Schön, schon mal ein paar Anhaltspunkte zu haben 😀

 

[kaoZ]

oder man bietet zusätzlich noch einen Konstruktor an der einen weiteren Wert als Parameter enthält mit welchem man denn puffer um welchen das Array erweitert wird festlegt.

public Foo(int length, int bufferSize){....}

 

[Thallius]

oder man bietet zusätzlich noch einen Konstruktor an der einen weiteren Wert als Parameter enthält mit welchem man denn puffer um welchen das Array erweitert wird festlegt.

public Foo(int length, int bufferSize){....}

Es ist aber doch so ziemlich das inperformanteste das es gibt ein Array durch kopieren jedesmal um eins zu verlängern. Ich finde gerade das sollte man den Anfängern direkt vermitteln denn sonst enstehen diese speicherfressenden, schnarch-Applikationen wie wir sie mehr als genug in Java programiert finden können.

Nicht alles was man machen kann macht auch wirklich Sinn.

Gruß

Claus

 

[kaoZ]

Es ist aber doch so ziemlich das inperformanteste das es gibt ein Array durch kopieren jedesmal um eins zu verlängern.

*Hust*

Dir ist aber schon klar das eine ArrayList intern folgenden code beim aufruf der

add();

methode verwendet oder ?

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);  // <<--- sowas aber auch
    }

Klar werden vorher noch unzählige andere Methoden ausgeführt, letzendlich läuft aber alles darauf hinaus das das intern verwendete Object[] array

elementData

, per kopie um eben das gewünschte Feld erweitert wird.

[EDIT]Jetzt würde mich natürlich brennend interessieren wie du diese Funktionalität implementieren würdest 🙂[/EDIT]

 

[Thallius]

Nein das war mir nicht klar.

Ich dachte es wäre tatsächlich eine Liste wie der Name vermuten läßt.

Wie man verkettete Listen programmiert brauch ich Dir sicher nicht erklären oder?

Gruß

Claus

 

[stg]

Es ist ja auch eine Liste, nur eben eine, die intern mit einem Array als Speicher arbeitet. Da ist der Name ArrayList doch recht passend?
Wenn man eine verkettete Liste möchte, dann gibts ja immer noch z.B. eine LinkedList ... wie der Name schon sagt 😀

------------

Aber um auch noch direkt auf die Frage des TE zu antworten: Arrays sind nicht dynamisch und du hast auch keine Möglichkeit daran etwas zu ändern. Das, was du in deiner Frage beschreibst (Vorne etwas wegnehmen und hinten etwas anfügen) klingt für mich sehr nach einer Warteschlange/Queue. Damit funktionieren diese Operationen jeweils in konstanter Zeit, also kein Vergleich zu der irrsinnig teuren Array-Hin-und-her-Kopiererei.

Oder, wenn die Anzahl der Spalten tatsächlich immer gleich bleibt, dann kannst du tatsächlich bei deinem Array bleiben und die Arrayspalten einfach über eine geeignete Permutation ansprechen. Dann musst du nur diese Permutation und nicht das Array direkt "verbiegen".

 

[kaoZ]

Ich dachte es wäre tatsächlich eine Liste wie der Name vermuten läßt.

Ist es ja auch, aber es handelt sich abstrakt gesagt um eine Sammlung, im spezielleren eine Liste, und noch Spezieller um eine Array - Liste aus ( wie der Name schon sagt ) welche dann intern zur umsetzung ein Object Array nutzt und eben über den weg der Kopie, welcher auch der sinnigste und logischste ist realisiert wird.

Ähnlich wie bei HashMap, dort wird letztenendes ein Set verwendet welches sogenannte Entrys beinhaltet.

Das, was du in deiner Frage beschreibst (Vorne etwas wegnehmen und hinten etwas anfügen) klingt für mich sehr nach einer Warteschlange/Queue.

Wenn der TO das vorhat , wäre das in seinem Fall genau die richtige Wahl, ansonsten halt LinkedList, insofern Verkettung notwendig, im Zuge der Weiterbildung könnte man es halt auch einfach selbst implementieren, wenn das Verständnis über diese Vorgänge bereits vorhanden sein sollte kann er auch einfach fertige Klassen aus der API nutzen.

Ich für meinen Teil bin immer bedacht darauf wirklich nachvollziehen zu können was genau dort passiert, klar dauert das länger , allerdings bin ich der Meinung man bekommt mit der Zeit ein recht guten Verständnis dafür wie das Ganze nachher zusammenspielt.