Java SE 7

Nouveautés

Frédéric Renout Novembre 2011

 Introduction
 Java GUI
 Java « core »
 Java dynamic binding
 Java Concurrent


Déploiement Client graphique

Collections Langage
Réseau
Sécurité

Dynamique Concurrent I/O


Client Graphique
Déploiement


Client graphique
 Nouveau Look and Feel : Nimbus
 Transparence , gradient et formes libres pour les
fenêtres swing
 Interactions graphiques améliorées entre awt et swing

Déploiement
 Amélioration de JNLP
 Embeddable
 Signature partielle


 Collection
 Sécurité
 Réseau
 Langage


 Interface de Queue bloquante (LinkedTranferQueue)
 Dérive de Blocking
 Permet d’attendre qu’un item envoyé soit consommé
 Méthodes:
 hasWaitingConsumer / getWaitingConsumerCount
 transfer : bloquant
 tryTransfer : bon bloquant et paramétrable

 Démo


 Nouveaux algo basés sur ECC (Elliptic Curve
Cryptography)
 Possibilité de désactiver l’utilisation d’algos « faibles »
durant l’utilisation de TLS (=SSL)


Courbe elliptique :
y2mod p =x3+ax+b mod p
Ici : y2=x3-5x+3

Courbe ayant des propriétés de
calcul « simples » pour +


Algorithme :
A et B choisissent publiquement une courbe C et un point P de
cette courbe
A choisi secrètement un entier dA
B choisi secrètement un entier dB
A envoie publiquement dAP = P+P+…dA fois…+P
B envoie publiquement dBP = P+P+…dB fois…+P
A et B peuvent calculer dA(dBP) = dB(dAP) = (dBdA)P qui est leur
clé de chiffrement secrète
Un espion E doit pouvoir retrouver dA et dB et aujourd’hui le
temps nécessaire pour résoudre ce problème est très long
Plus d’infos :
http://www.apprendre-en-ligne.net/crypto/moderne/elliptique.html
http://fr.wikipedia.org/wiki/Cryptographie_sur_les_courbes_elliptiques


 UrlClassLoader.close
 Fermer le classLoader pour libérer les ressources
chargées et les remplacer
 Socket Direct Protocol
 Solaris & Linux
 Utilisé par infiniBand qui permet de faire des accès
mémoire entre machine sans passer par l’OS


Projet Coin

coin something :
to invent a new word or phrase that other people
then begin to use

Modification mineure du langage visant à rendre le code
plus facile à écrire et à maintenir


L’utilisation de varargs de types paramétrés génère des
warnings à l’utilisation des méthodes
Java 7 permet de
Générer un warning à la déclaration : possible heap
pollution
Supprimer ces warnings
 @SafeVarargs
 Retire tout warnings
 @SuppressWarnings(« unchecked », »varargs »)
 Retire les warnings à la déclaration
 -Xlint:-varargs


Possibilité de séparer les nombres par des _
5000000 = 5_000_000
Limite les erreurs de lecture

Possibilité de représenter un nombre sous sa forme
binaire
42 = 0b101010
Facilite la représentation des bitmasks…


… ou d’une bitmap
public static final short[] HAPPY_FACE = {
(short)0b0000011111100000;
(short)0b0000100000010000;
(short)0b0001000000001000;
(short)0b0010000000000100;
(short)0b0100000000000010;
(short)0b1000011001100001;
(short)0b1000011001100001;
(short)0b1000000000000001;
(short)0b1000000000000001;
(short)0b1001000000001001;
(short)0b1000100000010001;
(short)0b0100011111100010;
(short)0b0010000000000100;
(short)0b0001000000001000;
(short)0b0000100000010000;
(short)0b0000011111100000; }


On peut switcher sur
 des types primitif (ou leurs wrappers)
 des enums
 des Strings


List<IndexOutOfBoundsException> dictionnaire = new
ArrayList<IndexOutOfBoundsException >();

Map<String,Map<String,String>> i18nDictionnaire = new
HashMap<String,Map<String,String>>();


List<IndexOutOfBoundsException> dictionnaire = new
ArrayList<>();

Map<String,Map<String,String>> i18nDictionnaire = new
HashMap<>();


 Multiple catch
 Re-throw precis


try { try {
File input = new File("input.txt"); File input = new File("input.txt");
FileReader fr = new FileReader(input); FileReader fr = new FileReader(input);
File output = new File("output.txt"); File output = new File("output.txt");
FileWriter fw = new FileWriter(output); FileWriter fw = new FileWriter(output);
int readed; int readed;
while ((readed = fr.read()) != -1) { while ((readed = fr.read()) != -1) {
fw.write(readed); fw.write(readed);
} }
fw.flush(); fw.flush();
fw.close(); fw.close();
fr.close(); fr.close();
} catch (FileNotFoundException e) { } catch (FileNotFoundException | IOException e) {
log(e); log(e);
}catch (IOException e) { }
log(e); }
}
}


public void copy() throws FileNotFoundException , IOException { public void copy() throws FileNotFoundException , IOException {
try { try {
File input = new File("input.txt"); File input = new File("input.txt");
FileReader fr = new FileReader(input); FileReader fr = new FileReader(input);
File output = new File("output.txt"); File output = new File("output.txt");
FileWriter fw = new FileWriter(output); FileWriter fw = new FileWriter(output);
int readed; int readed;
while ((readed = fr.read()) != -1) { while ((readed = fr.read()) != -1) {
fw.write(readed); fw.write(readed);
} }
fw.flush(); fw.flush();
fw.close(); fw.close();
fr.close(); fr.close();
} catch (FileNotFoundException e) { } catch (Exception e) {
log(e); log(e);
throw e; throw e;
}catch (IOException e) { }
log(e); }
throw e; }
}
}
}


 Nouvelle interface : AutoClosable
 On passe les ressources au try
 En sortie les ressources sont fermées dans le sens
inverse de la déclaration
 En cas d’exception dans le try les exceptions du à la
fermeture sont supprimées mais accessibles via
Throwable.getSuppressed
 Démo


InvokeDynamic


Quels langages tournent sur une JVM?

Groovy
Scala
Jython
Java
Erjang Rhino

JRuby
Et pleins d’autres...


Beaucoup de ces langages sont des langages
dynamiques
Java est fortement typé. Les traitements dynamiques
doivent être « émulés » et sont couteux.
Nouvelle instruction au niveau du bytecode :
invokeDynamic
Nouvelle API de réflection : java.lang.invoke
CallSite
MethodHandle
Démo

 ThreadLocaleRandom
 Phaser
 Fork/join


 Utilisation de nombre aléatoires dans des threads ou
des ForkJoinTask
 Garanti que chaque Thread à son propre Random


Permet de synchroniser de traitements, de gérer des
phases :
1. Enregistrer le nombre d’entités se synchronisant sur
le Phaser
2. Démarrer les Threads
3. Se synchroniser avec arriveAndAwaitAdvance()
4. Attendre une phase : awaitAdvance(#phase)

Démo


Fork : diviser un tache en sous-taches
Join : combiner les résultats des sous-tâches


 Utiliser efficacement plusieurs processeurs
 WorkStealing : les threads inutilisés prennent des
tâches à ceux occupés.
 Similaire à Map/Reduce de Google mais avec une
granularité différente (on peut définir des seuils de
fork) et une scalabilité différente : MapReduce
fonctionne sur des clusters, fork/join sur une JVM et sa
machine


 Déclenchements
 Synchrone -> invoke
 Asynchrone -> execute
 Asynchrone et future ->submit


ForkJoinPool

ForkJoinTask
invocation compute()

compute()


A Jean-Michel 


Java SE 7

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Java SE 7

Similaire à Java SE 7 (20)

Plus de Lorraine JUG

Plus de Lorraine JUG (13)

Java SE 7