Hilf mir, das nachzuholen, was ich seit Java 1.4.2 verpasst habe.

Ich bin kurz davor, meine erste berufliche Karriere als Softwareentwickler zu beginnen, und ich werde wahrscheinlich viel Java-Code schreiben. Ich weiß nicht so viel darüber, was genau ich schreiben werde, und außerdem habe ich ziemlich breite Interessen, wenn es sowieso um Code geht.

Aus Gründen, die es nicht wert waren, besprochen zu werden, ließ ich mich bei meinem letzten Praktikum nur auf die Java 1.3 und 1.4 SDKs programmieren. Außerdem konzentrierte sich meine Universitätsausbildung hauptsächlich auf Algorithmen, Datenstrukturen und andere Theorien, nicht auf Sprachmerkmale oder Bibliotheken.

In Anbetracht der obigen Ausführungen lohnt es sich also, nachzusehen, welche Funktionen, Klassen usw. in der aktuellen Java-Version (auf welcher Nummer sind wir jetzt überhaupt?) Und warum. Was habe ich seit 1.4.2 verpasst, das dir das Leben als Programmierer erleichtert?

Beispiele und Geschichten darüber, wie Sie ein bestimmtes Paket oder ein solches entdeckt und verwendet haben, wären ebenfalls großartig.

Die Änderungen, die ich für am wichtigsten halte, sind:

• Generika (zB typisierte Sammlungen, wie Set)

• Erweiterte for-Schleife (für (String s: set) {...})

• Autoboxing / Unboxing (automatisch zwischen Typen wie Integer in int und umgekehrt konvertieren)

• Typesichere Aufzählungen (Aufzählung ist jetzt ein Schlüsselwort, Typen können aus Aufzählungen erstellt werden)

• Varargs (für die Funktion printf () ist eine variable Anzahl von Argumenten zulässig)

• Statischer Import (kann jetzt statische Methoden einer Klasse wie java.lang.Math importieren)

• Anmerkungen

• java.util.concurrent (Demonstriert die gleichzeitige Verwendung von Java)

Lesen Sie auch, welches Java Sie anstreben. , um die drei Versionen besser zu verstehen.

Die wichtigste Veränderung in Ihrem täglichen Programmierleben ist die Einführung von Generika die höchstwahrscheinlich in jedem neuen Modul verwendet werden, zu dem Sie aufgefordert werden, und es ist eine verwirrende neue Syntax.

Generics ist der Mechanismus, mit dem z. B. a ListStrings anstelle von nackten Objekten enthalten kann, wobei der Compiler erzwingt, dass ein Element, das in die Liste aufgenommen werden soll, ein String ist, und er weiß, dass es ein String ist, wenn Sie ein Element aus einer Liste entfernen .

Dies sorgt für bessere Programme, da Sie die explizite Umwandlung der Laufzeit in den Zieltyp vermeiden (was häufig zu Fehlern führt, wenn Sie einen Fehler machen) und die IDE Ihnen dabei helfen kann, die ganze Drecksarbeit zu erledigen, da sie viel mehr über Ihren Code weiß als es geschah, als es nur eine Liste von Objekten war.

Joshua Bloch hat eine gute Einführung in Generics geschrieben, die als Beispielkapitel unter http://java.sun.com/docs/books/effective/ verfügbar ist.

Autoboxing ist eine nette Funktion, die mit Java 5 eingeführt wurde. Genau wie in C # führt der Compiler jetzt eine automatische Konvertierung zwischen den primitiven (Basis-) Typen und ihren entsprechenden Objektumhüllungsklassen (int zu Integer usw.) und wieder zurück durch. Das macht die Arbeit mit Java Collections viel einfacher.

For-each- Looping war auch in Java 5 neu, denke ich. Dies erleichtert die Iteration über Arrays (und Auflistungen), da die üblichen Probleme beim Einrichten und Verwalten einer Indexvariablen oder von Iteratoren weitgehend vermieden werden. Am Beispiel:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}

Aufzählungen , um endgültige Statiken und Konstanten zu ersetzen und Verweise auf Zeichenfolgen und magische Zahlen zu entfernen. Ein Beispiel von den guten Leuten bei sun / oracle :

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

und

public static void main(String[] args) {
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }

java.util.concurrent wurde in 1.5 eingeführt. Die beste Ressource zum Erlernen ist (wahrscheinlich) das Java Concurrency in Practice- Buch. Die IMHO-Parallelität ist Javas wichtigster Wettbewerbsvorteil im Vergleich zu allem anderen.

Hat StringBuildermir geholfen, mein Programm zu beschleunigen. Es entspricht der StringBufferFadensicherheit ohne Gewinde.

Ich werde helfen, indem ich die hilfreiche Antwort von @ykombinator kategorisiere. Seine Liste ist eine Liste der Elemente, die Sie täglich verwenden, wenn Sie eine "allgemeine" Java-Entwicklung durchführen.

Geringer Aufprall und geringer Schwierigkeitsgrad:

• Erweiterte for-Schleife (für (String s: set) {...})
• Autoboxing / Unboxing (automatisch zwischen Typen wie Integer in int und umgekehrt konvertieren)
• Varargs (für die Funktion printf () ist eine variable Anzahl von Argumenten zulässig)
• Statischer Import (kann jetzt statische Methoden einer Klasse wie java.lang.Math importieren)

High Impact und mittlerer Schwierigkeitsgrad:

• Typesichere Aufzählungen (Aufzählung ist jetzt ein Schlüsselwort, Typen können aus Aufzählungen erstellt werden)

Hohe Auswirkung und hoher Schwierigkeitsgrad:

• Anmerkungen
• Generika

Geringe Auswirkung und hohe Schwierigkeit (wird nur verwendet, wenn Sie fortgeschrittenes Einfädeln durchführen)

• java.util.concurrent (Demonstriert die gleichzeitige Verwendung von Java)

Ich würde daher vorschlagen, dass Sie die Dokumentation / Hilfe zu Teilen mit geringen Auswirkungen und geringen Schwierigkeitsgraden durchlesen - sie sind leicht zu erlernen. Verbringen Sie viel Zeit mit Anmerkungen und Generika - Anmerkungen sind sehr nützlich, und Generika können ziemlich kompliziert werden.

Sehen Sie sich den neuen Inhalt der Parallelität nur an, wenn Sie Threading ausführen müssen.

Da ich keinen Kommentar abgeben kann, da ich unter 50 bin, hinterlasse ich eine Antwort. Es wurde bereits erwähnt, aber ich werde es noch einmal wiederholen: Anmerkungen! Diese Art von Metadaten wurde das Wichtigste in meiner jahrelangen Erfahrung mit Java. Es wird gut verwendet, wie es einige Frameworks tun, wodurch der Code viel präziser und sauberer wird. Anmerkungen können zum Beispiel:

• Konvertieren Sie ein Objekt in eine Entität @Entity
• Konvertieren Sie eine Methode in einen REST-Service @GET
• Erklären Sie, dass eine Methode niemals null zurückgibt @nonnull zurückgibt
• Setzen Sie ein Objekt auf ein Feld für die Abhängigkeitsinjektion @inject

Natürlich können Sie auch Ihre eigenen Anmerkungen erstellen und wissen, ob eine Methode, eine Klasse oder ein Feld durch Reflektion mit Anmerkungen versehen ist.

Lernen am Beispiel funktioniert bei mir

Hier ist ein kurzes Beispiel für Java 6

public class Main {
  public static void main(String[] args) {
    // Shows a list forced to be Strings only
    // The Arrays helper uses generics to identify the return type
    // and takes varargs (...) to allow arbitary number of arguments
    List<String> genericisedList = Arrays.asList("A","B","C");

    // Demonstrates a for:each loop (read as for each item in genericisedList)
    for (String item: genericisedList) {
      System.out.printf("Using print formatting: %s%n",item);
    }

    // Note that the object is initialised directly with a primitive (autoboxing)
    Integer autoboxedInteger = 1;
    System.out.println(autoboxedInteger);

  }
}

Mach dir keine Sorgen mit Java5, es ist in Bezug auf Java6 veraltet.

Nächster Schritt, Anmerkungen. Diese definieren lediglich Aspekte für Ihren Code, mit denen Anmerkungsleser die Kesselplatinen-Konfiguration für Sie ausfüllen können. Stellen Sie sich einen einfachen Webdienst vor, der die JAX-RS-Spezifikation verwendet (sie versteht RESTful-URIs). Sie wollen sich nicht die Mühe machen, die fiese WSDL zu machen und mit Axis2 usw. herumzuspielen, sondern ein schnelles Ergebnis erzielen. Richtig, mach das:

// Response to URIs that start with /Service (after the application context name)
@Path("/Service")
public class WebService {

  // Respond to GET requests within the /Service selection
  @GET
  // Specify a path matcher that takes anything and assigns it to rawPathParams
  @Path("/{rawPathParams:.*}")
  public Response service(@Context HttpServletRequest request, @PathParam("rawPathParams") String rawPathParams) {
    // Do some stuff with the raw path parameters 

    // Return a 200_OK
    return Response.status(200).build();
  }
}

Knall. Mit ein wenig Konfigurationsmagie in Ihrer web.xml können Sie loslegen. Wenn Sie mit Maven bauen und das Jetty-Plugin konfiguriert haben, verfügt Ihr Projekt über einen eigenen kleinen Webserver (ohne dass Sie mit JBoss oder Tomcat herumspielen müssen), und der obige Code reagiert auf URIs der bilden:

GET http://localhost:8080/contextName/Service/the/raw/path/params

Job erledigt.

Wow, das war eine Explosion aus der Vergangenheit! Ich habe seit 4 Jahren kein Java mehr verwendet - und in dieser Zeit hat sich überhaupt nichts geändert!

Es gibt eine Liste der Funktionen nach Version , aber hier ist der wichtige Teil (natürlich plagiiert) ...

J2SE 5.0 (30. September 2004)

• Generics: Bietet Sicherheit beim Kompilieren (statischer Typ) für Sammlungen und macht die meisten Typumwandlungen überflüssig (Typkonvertierung).
• Metadaten: Auch Annotationen genannt; Ermöglicht die Kennzeichnung von Sprachkonstrukten wie Klassen und Methoden mit zusätzlichen Daten, die dann von Dienstprogrammen verarbeitet werden können, die Metadaten berücksichtigen.
• Autoboxing / Unboxing: Automatische Konvertierungen zwischen primitiven Typen (wie Int) und primitiven Wrapper-Klassen (wie Integer).
• Aufzählungen: Mit dem Schlüsselwort enum wird eine typsichere, geordnete Liste von Werten erstellt (z. B. Day.MONDAY, Day.TUESDAY usw.). Zuvor konnte dies nur durch nicht typsichere konstante Ganzzahlen oder manuell erstellte Klassen (typsichere Aufzählungsmuster) erreicht werden.
• Swing: Neues Erscheinungsbild, genannt Synth.
• Varargs: Der letzte Parameter einer Methode kann jetzt mit einem Typnamen gefolgt von drei Punkten deklariert werden (zB void drawtext (String ... lines)). Im aufrufenden Code kann eine beliebige Anzahl von Parametern dieses Typs verwendet werden, die dann in einem Array abgelegt werden, das an die Methode übergeben wird. Alternativ kann der aufrufende Code ein Array dieses Typs übergeben.
• Verbessert für jede Schleife: Die for-Schleifensyntax wurde um eine spezielle Syntax erweitert, mit der jedes Mitglied eines Arrays oder einer beliebigen Iterable, z.

Java SE 6 (11. Dezember 2006)

• Unterstützung für ältere Win9x-Versionen eingestellt. Inoffiziell ist Java 6 Update 7 die letzte Java-Version, die für diese Windows-Versionen geeignet ist. Dies ist vermutlich auf die wesentlichen Änderungen in Update 10 zurückzuführen.
• Skriptsprachenunterstützung: Allgemeine API für die enge Integration in Skriptsprachen und die integrierte Integration von Mozilla JavaScript Rhino
• Dramatische Leistungsverbesserungen für die Kernplattform und Swing.
• Verbesserte Webdienstunterstützung durch JAX-WS
• JDBC 4.0-Unterstützung.
• Java-Compiler-API Eine API, mit der ein Java-Programm einen Java-Compiler programmgesteuert auswählen und aufrufen kann.
• Upgrade von JAXB auf Version 2.0: Einschließlich Integration eines StAX-Parsers.
• Unterstützung für steckbare Anmerkungen
• Viele GUI-Verbesserungen, wie die Integration von SwingWorker in die API, das Sortieren und Filtern von Tabellen und die echte Swing-Doppelpufferung (Beseitigung des Grauzoneneffekts).
• Zu den JVM-Verbesserungen gehören: Optimierungen der Synchronisations- und Compilerleistung, neue Algorithmen und Upgrades vorhandener Garbage Collection-Algorithmen sowie die Startleistung von Anwendungen.

Das ist alles. Java SE 7.0 sieht interessanter aus, ist aber noch nicht veröffentlicht.

Wenn man bedenkt, wie viele neue Sprachfunktionen und APIs in den letzten 4 Jahren zu C # hinzugefügt wurden, bin ich ziemlich erstaunt. Was ist bei Sun / Oracle los?