Array-Problem

[Guest]

Halli Hallo,
ich hab ein kleines Array Problem:
Ich möchte das bei Unterbrechung das Programs mein Array geleert wird. Also so das er keine Elemente mehr erhält!
Auf null setzen kann ich ihn ja nicht sonst ist er ja nicht mehr aktiv wenn ich ihn später wieder brauche!?

Gibt es eine möglichkeit den Array irgendwie anderst zu leeren oder gibt´s noch andere Lösungen?

 

[zd]

weiss nicht ob ich dich richtig verstehe, aber du kannst weder die länge des arrays bei laufzeit ändern, noch die elemente mit null initialisieren.

aber du kannst z.B. bei einem int array recht einfach alle werte auf 0 setzen oder ähnliches.

for (int i = 0; i<array.length; i++) {
      array[i] = 0;
}

falls es mehrdimensional ist einfach verschachtelte for schleifen nehmen.

 

[bygones]

aber du kannst weder die länge des arrays bei laufzeit ändern, noch die elemente mit null initialisieren.

beim ersten stimme ich zu, aber ds zweite ???:L
Wenn du ein Array aus Objekten hast sind die Elemente anfangs immer null und man kann sich während der laufzeit auf null setzen...
???:L

 

[zd]

aber du kannst weder die länge des arrays bei laufzeit ändern, noch die elemente mit null initialisieren.

beim ersten stimme ich zu, aber ds zweite ???:L
Wenn du ein Array aus Objekten hast sind die Elemente anfangs immer null und man kann sich während der laufzeit auf null setzen...
???:L

ok des kann sein, dann kommts auf den arraytyp an.
aber z.b. ein int array kannst du nicht mit null belegen, auch wenn so vorinitalisiert ist.
das frisst der compiler nicht

int[] array = new int[3];
array[0] = null;

 

[bygones]

klar - ich meinte ja auch einen Array aus objekten !

 

[Guest]

hmmmm...hab ein String Array!
Also wenn ich folgendes mach:
for (int i = 0; i<array.length; i++) {
array = "";
}

funktionierts zwar das er leer ist, aber in dem SINNE hat er ja immer noch was drin! Nämlich ne Leerzeile
Irgendeine Idee dazu??

 

[citizen_erased]

was ist mit

= new String();  //   Initializes a newly created String object so that it represents an empty character sequence.

?

 

[bygones]

wie gesagt, für arrays gibt es zwei möglichkeiten:

array = null; // kompletter array ist geleert und noch mehr

for(int i=0; i < array.length; i++) {
array[i] = null;
}

 

[Guest]

mit:

array = null;

ist der Array ja nicht nur geleert sondern er existiert dann nicht mehr oder?
Ich hab halt folgendes Problem:
Array soll geleert werden wenn ein bestimmer Button angeklickt wurde!
So, wenn ein anderer Button betägtigt wird dann soll der gleiche Array wieder GELEERT benutzt werden können!! Also wieder ganz normal ab Position 0 die Elmente wieder aufnehmen!
Wie kann ich das denn dann machen wenn ich den Array vorher auf null gesetzt habe??

 

[bygones]

dann musst du die zweite möglichkeit nehmen...
Kannst du nicht einfach die elemente drin überschreiben ??

 

[Beni]

Dies setzt jeden Eintrag des Arrays auf null:

for(int i=0; i < array.length; i++) {
  array[i] = null;
}

Dies setzt die Referenz auf null:

array = null;

Bei der 1. Variante gilt:
array == null -> false
array == null -> true

Bei der 2. Variante gilt:
array == null -> true
array == null -> NullPointerException

Du benötigst wohl die 1. Variante.

mfg Beni

 

[bygones]

wobei anzumerken ist, Benis 1.Variante ist meine 2. und andersrum :roll: :wink:

 

[Beni]

wobei anzumerken ist, Benis 1.Variante ist meine 2. und andersrum :roll: :wink:

Hm, ok, die Reihenfolge ist schlecht... ich habs auch abgeschrieben... wollte es etwas, hm, "verständlicher" erklären...
:wink:

 

[Guest]

jup jetzt versteh ich das auch!
Vielen Dank euch beiden!

 

[Ytak]

Hallo zusammen!

Wollte nur kurz anmerken, dass dies eine ziemlich langsame Lösung darstellt, einen Array zu leeren. Bei grossen Arrays kann dies zu langen Laufzeiten führen und ist unnötig kompliziert. Wenn doch nur alle Elemente des Arrays gelöscht werden müssen (ob object, int, double was auch immer das array für einen typ hat) kann doch einfach eine neue Referenz angelegt werden - ist am einfachsten, ist modular verwendbar (wenn der datentyp geändert wird, bleibt der algorithmus derselbe und die Rechenzeit ist statt O(n) O(1) --> bei 100'000 elementen im Array ist das 0-Setzen dieser 100'000 mal schneller!

In Java würde dies folgendermassen aussehen:
--------------------------------------------------------------------------------------------------------------------

    int array[] = new int[1000];
    
// array wird mit elementen gefüllt
    for (int i=0; i < array.length; i++) {
     array[i] = 5;
    }
    
    System.out.println(array[10]); // out: 5
    
//alle elemente des Arrays löschen --> wir erzeugen einfach eine neue Referenz für dieses Array. Der GarbageCollector von Java wird das alte array-Object(gefüllt mit 5-Werten) nach kurzer Zeit aus dem Speicher entfernen und die Referenz wird einfach auf das neue Array gelegt:
    
    array = new int[1000];
    System.out.println(array[10]); // out: 0   , weil int-arrays bei der Initialisierung immer gefüllt mit 0-Werten
    
    
// that's all folkz! :-)
// Das ganze ginge jetzt natürlich auch mit Object-Arrays (String, Integer, Double etc.)
// z.b.  Object array[] = new Object[5];
// test[0] = new String("Hallo");
// System.out.println(test[0]);  // out: Hallo

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

Grüsse

 

[Guest]

. Wenn doch nur alle Elemente des Arrays gelöscht werden müssen (ob object, int, double was auch immer das array für einen typ hat) kann doch einfach eine neue Referenz angelegt werden - ist am einfachsten, ist modular verwendbar (wenn der datentyp geändert wird, bleibt der algorithmus derselbe und die Rechenzeit ist statt O(n) O(1) --> bei 100'000 elementen im Array ist das 0-Setzen dieser 100'000 mal schneller!

Halt ich für ein Gerücht.

    System.out.println(array[10]); // out: 0   , weil int-arrays bei der Initialisierung immer gefüllt mit 0-Werten

Aha. Und diese automatische Initialisierung mit 0-Werten braucht also keine Zeit?
Das wird ebenfalls eine Komplexität von O(n) haben. Ganz sicher sogar.

 

[Guest]

Aha. Und diese automatische Initialisierung mit 0-Werten braucht also keine Zeit?
Das wird ebenfalls eine Komplexität von O(n) haben. Ganz sicher sogar.

Och...bei der Initialisierung einer Variable als auch eines neuen Array-Objects wird im Hauptspeicher, für die zu speichernden Elemente in diesem Array, ein definierter Platz eingeräumt (weil arrays während der Laufzeit weder ihre Grösse, noch ihren Datentyp ändern können). Wenn nun an keinem Index des Arrays bisher ein Object bzw. ein "Wert" abgelegt wurde, dann ist an jeder Stelle im alloziierten Array halt einfach auch nichts da. Nichts bedeutet im Sinne von ADTs "null", bei integrierten Typen wie "int" oder "double" ist dies "0". Ein Object in den Speicher legen bzw. ein neues Object alloziierenhat eine O-Notation von 1 ( O(1) ) da hier weder eine Schleife, noch irgendwelche Verschachtelungen (grosse Konstanten) zum Tragen kommen.

Bei ausgeklügelten Algorithmen wird sehr darauf geachtet, dass die Laufzeit niedrig gehalten werden kann. Eine traversierung des ganzen Arrays bedeutet IMMER O(n) - also eine Laufzeit abhängig von n-Elementen im array. Dies ist der schlechteste Zustand eines Algorithmus. Wenn man das einfach vermeiden kann (die JVM hat ja zum Glück einen voll automatischen GarbageCollector - man muss demnach das null-referenzierte Object nicht manuell aus dem Speicher entfernen) dann sollte man auch wo immer möglich. Zudem ist die neu-allokation des selben Objects der einfachste Weg in der Programmierung. FOR-Schleife = 3 Zeilen Code, Allokation = 1 Zeile code und zudem ist die FOR-Schleife anfälliger. Sollte der Typ des Arrays während der Programmierung mal verändert werden (bsp. anstelle von Int-Werten soll das Array nun Integer-Objects aufnehmen) dann ist u.Umständen eine aufwändige Programmänderung notwendig; die allokation ist für alle Object-Type gleich, der typ kann global definiert werden (in einer Basisklasse oder sogar in einem Interface)

Fact ist: Für ein kleines Java-Programm ist's scheissegal ob man ein neues Object alloziiert oder eine For-Schleife programmiert; aber warum denn nicht von anfang an den einfachsten Weg suchen?

Greetz[/quote]

 

[DrZoidberg]

Aha. Und diese automatische Initialisierung mit 0-Werten braucht also keine Zeit?
Das wird ebenfalls eine Komplexität von O(n) haben. Ganz sicher sogar.

Och...bei der Initialisierung einer Variable als auch eines neuen Array-Objects wird im Hauptspeicher, für die zu speichernden Elemente in diesem Array, ein definierter Platz eingeräumt (weil arrays während der Laufzeit weder ihre Grösse, noch ihren Datentyp ändern können). Wenn nun an keinem Index des Arrays bisher ein Object bzw. ein "Wert" abgelegt wurde, dann ist an jeder Stelle im alloziierten Array halt einfach auch nichts da. Nichts bedeutet im Sinne von ADTs "null", bei integrierten Typen wie "int" oder "double" ist dies "0". Ein Object in den Speicher legen bzw. ein neues Object alloziierenhat eine O-Notation von 1 ( O(1) ) da hier weder eine Schleife, noch irgendwelche Verschachtelungen (grosse Konstanten) zum Tragen kommen.

Dieses "Nichts" ist aber nicht automatisch da. Die Nullen müssen erst noch in den Speicher geschrieben werden. Das macht die Java VM, wenn das Array initialisiert wird. Und dieses Schreiben der Nullen hat natürlich die Komplexität O(n) und nicht O(1). In C++ sähe das anders aus. Dort würde das Array nicht automatisch mit Nullen gefüllt werden, sondern es wird lediglich der Speicher reserviert, der dann natürlich zufällige Werte enthält. Da hat man dann tatsächlich O(1).

Abgesehen davon ist das Erstellen eines neuen Arrays aber keine schlechte Idee.

 

[Ytak]

Hallo!
Du hast recht, ich habe das ganze mal gecoded und ausprobiert - tatsächlich reserviert die VM nicht nur den Speicher sondern füllt gleichzeitig das ganze Array mit 0-Werten (bzw. null)

Dies erklärt auch, warum die Laufzeit bei der Neu-Allokation sogar etwas langsamer ist als die Initialisierung des bestehenden Arrays mit 0-Werten. Habe ich mich tatsächlich getäuscht... aber... aus Fehlern lernt man ;-)

package testproject;

public class test {
  public static void main(String[] args) {
    long start1, start2, start3, end1, end2, end3;

    start1 = System.currentTimeMillis();
    long array1[] = new long[10];
    end1 = System.currentTimeMillis();
    
    start2 = System.currentTimeMillis();
    long array2[] = new long[999999];
    end2 = System.currentTimeMillis();
    
    start3 = System.currentTimeMillis();
    for (int i=0; i < array2.length; i++) {
      array2[i] = 1;
    }
    end3 = System.currentTimeMillis();
    
    System.out.println("Array1: " +(end1 - start1) + " Array2: " +(end2 - start2) +" Array3: " +(end3 - start3));
  }
}

out:  Array1: 0 Array2: 30 Array3: 20

Grüsse und thx für die Info - ich werde das mal meinem Lehrer weitergeben gucken ob er das weiss