Wann wird Java 5.0 endlich final?

[Real]

@Gregor: Hast du schon mal eine ArrayList geschrieben, die primitive Typen unterstützt?

Liebe Grüße
Real

[Gregor]

Real schrieb:

@Gregor: Hast du schon mal eine ArrayList geschrieben, die primitive Typen unterstützt?

Nein, aber ich habe schon andere Datenstrukturen für primitive Datentypen geschrieben. Zum Beispiel habe ich mal ne doppelt verkettete Liste für ints geschrieben.

Wenn du soetwas suchst, dann findest du genug entsprechende Klassen im Netz. Zum Beispiel da: http://pcj.sourceforge.net/

Was hat dein anderer Beitrag damit zu tun?!

[Real]

@Gregor: Danke, wenn ich es mal brauchen werde aufgrund Perfomance-Probleme, werde ich mich daran wenden.

Gregor schrieb:

Was hat dein anderer Beitrag damit zu tun?!

Ich bin verzweifelt. Der Fehler will einfach nicht gefunden werden.

Liebe Grüße
Real

[net 0]

Real schrieb:

Ich bin verzweifelt. Der Fehler will einfach nicht gefunden werden.

lass es mal im debugger laufen, einzelschritt.

[Real]

http://www.c-plusplus.net/forum/viewtopic.php?p=599049#599049

[Real]

Jetzt habe ich mich mal herangewagt selbst eine primitive (ganz ganz billige) List zu schreiben.
Ergebnis: ca. 63 mal schneller

Hätte damit nicht gerechnet. Sun hätte das sicher viel effizienter hingekriegt.
Hab das mal schnell runter getippt, darum sind nur wenige Methoden überschrieben.

import java.util.*;

public class NativeList extends LinkedList{
  int index = 1005;
  int i[] = new int[index];
  int copy[];
  int count = -1;
  int last;

  public void add(int i){
    if(++count >= index){
      this.index += 250;
      this.copy = new int[index];
      System.arraycopy(this.i, 0, this.copy, 0, this.i.length);
      this.i = new int[index];
      System.arraycopy(this.copy, 0, this.i, 0, this.copy.length);
    }

    this.i[count] = i;
    last = count;
  }

  public int indexOf(int i){
    return this.i[i];
  }
}

import java.util.*;

public class NativeListTest {
  public static void main(String[] args) {
    long start = System.currentTimeMillis();

    NativeList nl = new NativeList();

    for(int i = 0; i<=10000; i++)
      nl.add(i);

    for(int i = 0; i<= 10000; i++)
      nl.indexOf(i);

    System.out.println(System.currentTimeMillis() - start);    

    start = System.currentTimeMillis();

    LinkedList ll = new LinkedList();

        for(int i = 0; i<=10000; i++)
          ll.add(new Integer(i));

        for(int i = 0; i<= 10000; i++)
          ll.indexOf(new Integer(i));

        System.out.println(System.currentTimeMillis() - start);

  }
}

Die Methode remove() ließ sich nicht überschreiben, da es ja Object zurückgibt. Da müsste man eine eigene Methode erfinden. (remove2() oder so ).

Liebe Grüße
Real

[Gregor]

Real schrieb:

Jetzt habe ich mich mal herangewagt selbst eine primitive (ganz ganz billige) List zu schreiben.
Ergebnis: ca. 63 mal schneller

Was du da geschrieben hast, ist auch nicht das, was man unter einer verlinkten Liste versteht. Das ist somit auch nicht mit einer LinkedList vergleichbar. Die LinkedList hat von der Performance her ganz andere Eigenschaften als deine "Liste".

[Real]

Hmm, ja. Du kannst beispielsweise nicht einfach iterator() verwenden oder Map.Entry, aber solche ähnliche Features die die Methoden und Klassen bieten, wie z.B. hasNext() lassen sich leicht realisieren.

Liebe Grüße
Real

[grenouille_unreg]

Was du geschrieben hast ist grad mal zu 5% ne ArrayList und zu 0% ne LinkedList. Zweitens arbeitest du mit Primitives die sowieso schneller verarbeitet werden als Objekte. Alt bekanntes Java problem was schon tausendmal besprochen wurde. 3. Sinnlose Vererbungshierarchie. 4. Werde dir klar das Arrays und Listen bei unterschiedl. Operationen unterschiedl. Laufzeitverhalten an Tag legen. 5. Ist es schon peinlich was du hier ablieferst(und lachhaft ausserdem), da du von tuten und blassen keine Ahnung hast und durch unwissenheit eine Technologie abschwächst von der dein Wissenstand zur Zeit meilenweit entfernt ist.
Cu

[grenouille_unreg]

6. Wie der Name es schon sagt liefert indexOf den Index des gesuchten Par. und nicht andersherum.

[Gregor]

Real schrieb:

Hmm, ja. Du kannst beispielsweise nicht einfach iterator() verwenden oder Map.Entry, aber solche ähnliche Features die die Methoden und Klassen bieten, wie z.B. hasNext() lassen sich leicht realisieren.

Es geht bei diesen Datenstrukturen eigentlich nicht so sehr darum, welche Schnittstelle sie haben. Die ist bei vielen Datenstrukturen ähnlich. Es geht um den inneren Aufbau.

[Gregor]

Ich habe die LinkedList mal für ints nachgebaut und ein paar Methoden implementiert, die diese eigentlich anbieten sollte. Es ist eigentlich noch viel zu wenig da, so dass man es noch nicht als verlinkte Liste bezeichnen sollte, aber ein paar Methoden kann man schon benchmarken, was ich auch gleich mal gemacht habe:

import java.util.*;

public class IntList
{
   private Node header;
   private int size;

   public IntList()
   {
      header = new Node(null,null,0);
      header.next = header;
      header.previous = header;
      size = 0;
   }

   public void add(final int value)
   {
      final Node node = new Node(header.previous,header,value);
      header.previous.next = node;
      header.previous = node;
      ++size;
   }

   public int removeFirst()
   {
      if(size == 0) throw new NoSuchElementException();
      final int value = header.next.value;
      header.next.next.previous = header;
      header.next = header.next.next;
      --size;
      return value;
   }

   public int removeLast()
   {
      if(size == 0) throw new NoSuchElementException();
      final int value = header.previous.value;
      header.previous.previous.next = header;
      header.previous = header.previous.previous;
      --size;
      return value;
   }

   public int size()
   {
      return size;
   }

   private static class Node
   {
      public Node previous;
      public Node next;
      public int value;

      public Node (final Node previous, final Node next, final int value)
      {
         this.previous = previous;
         this.next = next;
         this.value = value;
      }
   }

   public static void main (String[] args)
   {
      LinkedList<Integer> linkedList = new LinkedList<Integer>();
      ArrayList<Integer> arrayList = new ArrayList<Integer>();
      IntList intList = new IntList();

      // Testlauf
      for(int i = 0 ; i < 100000 ; ++i)
      {
         linkedList.add(i);
      }
      for(int i = 0 ; i < 100000 ; ++i)
      {
         linkedList.removeFirst();
      }

      // LinkedList

      long time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         linkedList.add(i);
      }
      time = System.nanoTime() - time;
      System.out.println("LinkedList - add : " + time);
      System.out.println(linkedList.size());

      time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         linkedList.removeFirst();
      }
      time = System.nanoTime() - time;
      System.out.println("LinkedList - removeFirst : " + time);
      System.out.println(linkedList.size());

      // ArrayList

      time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         arrayList.add(i);
      }
      time = System.nanoTime() - time;
      System.out.println("ArrayList - add : " + time);
      System.out.println(arrayList.size());

      time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         arrayList.remove(0);
      }
      time = System.nanoTime() - time;
      System.out.println("ArrayList - remove(0) : " + time);
      System.out.println(arrayList.size());

      // IntList

      time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         intList.add(i);
      }
      time = System.nanoTime() - time;
      System.out.println("IntList - add : " + time);
      System.out.println(intList.size());
      time = System.nanoTime();
      for(int i = 0 ; i < 100000 ; ++i)
      {
         intList.removeFirst();
      }
      time = System.nanoTime() - time;
      System.out.println("IntList - removeFirst : " + time);
      System.out.println(intList.size());
   }
}

(Kann sein, dass das noch buggy ist.) Ich habe diese Liste sehr ähnlich aufgebaut, wie java.util.LinkedList aufgebaut ist. ...also etwas tricky.
Hier die Ergebnisse des Benchmarks:

LinkedList - add :          123420000
LinkedList - removeFirst :   10996000
ArrayList - add :            90372000
ArrayList - remove(0) :   11275050000
IntList - add :              37939000
IntList - removeFirst :       9485000

Du siehst also, dass sich die ArrayList hier vollkommen anders verhält als die LinkedList, IntList.

Interessanterweise hat es garnicht sooo viel gebracht, direkt eine Liste für ints zu schreiben. Richtig viel bringt das erst, wenn Cache-Effekte ins Spiel kommen. Da bei den Wrapperobjekten hier pro Listenelement (also Int-Wrapper + Node) doppelt so viel Speicherplatz benötigt wird, wird der Cache auch doppelt so schnell gefüllt. Wenn der voll ist, dann geht es mit der Performance aber rapide abwärts.

[Real]

Hi,

grenouille_unreg schrieb:

Zweitens arbeitest du mit Primitives die sowieso schneller verarbeitet werden als Objekte. Alt bekanntes Java problem was schon tausendmal besprochen wurde.

Genau wegen dem Geschwindigkeitsvorteil habe ich primitives verwendet.

3. Sinnlose Vererbungshierarchie.

Wollte eigentlich, dass man sich aussuchen kann, ob man nun ein Objekt hinzufuegt oder int.

5. Ist es schon peinlich was du hier ablieferst(und lachhaft ausserdem), da du von tuten und blassen keine Ahnung hast und durch unwissenheit eine Technologie abschwächst von der dein Wissenstand zur Zeit meilenweit entfernt ist.

Jo, du hast mich durch deine Unfreundlichkeit und Arroganz vollkommen ueberzeugt (das du meine Zeit verschwendet hast).
Erzaehl, was soll das geflame? Glaubst du, du bist mir so irgendwie behilflich oder leistest irgendetwas produktives?

Liebe Gruesse
Real

[stevg]

Um das mal weiter zu spinnen:
Hat schon jemand von euch versucht das über JNI zu implementieren?

[Sgt. Nukem]

Gregor schrieb:

Ende September kommt nämlich die finale Netbeans 4.0 Version

Tja, geschissen, was?!

[Gregor]

Sgt. Nukem schrieb:

Gregor schrieb:

Ende September kommt nämlich die finale Netbeans 4.0 Version

Tja, geschissen, was?!

Man sollte sich wohl nie auf irgendwelche "Roadmaps" oder so verlassen. ...aber zumindest stimmte die Aussage bezüglich Java 5.0 final.

[Gast]

Ich hätte freiwillig auch länger gewartet. Rumspielen hat man ja damit eh schon können und dann hätten sie meinen Bug fixen können.
Außerdem hab ich von einem Memory Leak im Zusammenhang mit AWT gerüchteweise gehört. Wenn das stimmt, dann wär das sogar mal kein unwesentlicher Bug.
Auch find ich die Aussage von Sun "wir können nicht alle Bugs fixen, aber das ist der stabilste Release aller Zeiten und darauf sind wir stolz" etwas seltsam. Zumindest alle bekannten Bugs hätte man IMHO schon fixen müssen, auch wenn es 2 Monate länger dauert.

just my 2 cents.

Ist es eigentlich geplant, in absehbarer Zeit ein Eclipse für Java 5.0 zu veröffentlichen? Ohne Generics macht mir Java keinen Spaß mehr.

[Anfaenger]

The changes to the Java tools to support J2SE 5.0 (aka 1.5) are proceeding nicely. The Eclipse Java compiler now handles generics, enhanced for loops, and hexadecimal floating point literals (at this point we're passing 96.8% of the JCK1.5 compliance tests). The other language additions - enumerations, annotations, static imports, varargs, autoboxing - make it past the parser, but are not yet being processed any deeper than that. Support for these other new language features will be introduced in future 3.1 milestones.

In order to work with any of the new language features you must set the Java project's compiler compliance level to 1.5 (Java Compiler > Compliance and Classfiles > Compiler compliance level > 1.5) and configure the Java build path with the system libraries from an installed 1.5 JRE.

(http://download2.eclipse.org/downloads/drops/S-3.1M2-200409240800/eclipse-news-M2.html)

Könnte also wohl noch ne ganze Weile dauern, bis die das endlich mal fertig haben ...