transparents

interface List
public interface List extends Collection {
// Positional Access
Object get(int index);
Object set(int index, Object element);
void add(int index, Object element);
Object remove(int index);
abstract boolean addAll(int index, Collection c);
// Optional
// Optional
// Optional
// Optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator listIterator();
ListIterator listIterator(int index);
// Range-view
List subList(int from, int to);
}
List : implémentations
ArrayList
• maintenue dans un tableau
• l'accès à un élément par son indice RAPIDE
• insertion LENTE (surtout si elle a lieu au début de la liste)
LinkedList
• formée de cellules liées par des références
• insertion d'éléments RAPIDE
• l'accès à un élément par son indice LENT
• intéressante si on compte effectuer beaucoup d'insertions et de suppression
Vector
• similaire à ArrayList
• utilisé dans l'API 1.0 et 1.1
import java.util.*;
import java.util.*;
class Cat {
private int catNumber;
Cat(int i) { catNumber = i; }
void print() {
System.out.println("Cat #" + catNumber);
}
}
// classes Cat et Dog comme dans l'exemple
précédent
class Dog {
private int dogNumber;
Dog(int i) { dogNumber = i; }
void print() {
System.out.println("Dog #" + dogNumber);
}
}
class CatList {
private ArrayList list = new ArrayList();
public void add(Cat c){
list.add(c);
}
public Cat get(int index){
return ((Cat)list.get(index));
}
public int size(){
return (list.size());
}
}
public class CatsAndDogs {
public class CatsAndDogs2 {
public static void main(String[] args) {
public static void main(String[] args) {
ArrayList cats = new ArrayList();
CatList cats = new CatList();
for(int i = 0; i < 7; i++){
cats.add(new Cat(i));
}
cats.add(new Dog(7));
for(int i = 0; i < 7; i++){
cats.add(new Cat(i));
}
cats.add(new Dog(7));
// erreur détectée pendant la compilation
for(int i = 0; i < cats.size(); i++){
((Cat)cats.get(i)).print();
//exception lors de l'exécution
}
for(int i = 0; i < cats.size(); i++){
((Cat)cats.get(i)).print();
}
}
}
}
}
Pile (Stack) avec une LinkedList
import java.util.*;
public class Pile {
private LinkedList l = new LinkedList();
public void ajouter(Object o){
l.addFirst(o);
}
public Object retirer(){
return l.removeFirst();
}
public Object sommet(){
return l.getFirst();
}
public static void main(String[] args){
Pile p = new Pile();
p.ajouter(…);
…
}
}
File (Queue) avec une LinkedList
import java.util.*;
public class Queue {
private LinkedList l = new LinkedList();
public void ajouter(Object o){
l.addFirst(o);
}
public Object retirer(){
return l.removeLast();
}
public boolean estVide(){
return l.isEmpty();
}
public static void main(String[] args){
Queue q = new Queue();
q.ajouter(…);
…
}
}
Interface : Set
public interface Set {
// Basic Operations
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element);
boolean remove(Object element);
Iterator iterator();
// Bulk Operations
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
void clear();
// Optional
// Optional
// Optional
// Optional
// Optional
// Optional
// Array Operations
Object[] toArray();
Object[] toArray(Object a[]);
}
Set : implémentations
HashSet
• implantation par table de hachage
• ajout d'élément RAPIDE
• test d'appartenance très rapides
TreeSet
• les éléments sont placés dans un arbre de recherche binaire équilibré
• les éléments sont triés
import java.util.*;
public class TrouveDoublons {
public static void main(String args[]) {
Set s = new HashSet();
for (int i=0; i<args.length; i++){
if (!s.add(args[i])) System.out.println("Doublon :" +
args[i]); }
System.out.println(s.size()+" mots differents : "+s);
}
}
Set : implémentations
java TrouveDoublons salut bonjour tcho tcho hello
⇒ Doublon : tcho
⇒ mots differents : [tcho, hello, salut, bonjour]
si on utilise un TreeSet
⇒ Doublon : tcho
⇒ mots differents : [bonjour, hello, salut, tcho]
Opérations sur les ensembles
s1.containsAll(s2):
teste l'inclusion de s2 dans s1
s1.addAll(s2)
union de s1 et s2
s1.retainAll(s2)
intersection de s1 et s2
s1.removeAll(s2)
différence entre s1 et s2
s1.removeAll(s2) ne donne pas le même résultat que s2.removeAll(s1)
Pour effectuer ces opérations sans destruction, utiliser un ensemble supplémentaire
exemple :
Set union = new HashSet(s1);
union.add(s2);
import java.util.*;
public class TrouveDoublons2 {
public static void main(String args[]) {
Set uniques = new HashSet();
Set doublons = new HashSet();
for (int i=0; i<args.length; i++){
if (!uniques.add(args[i])){
doublons.add(args[i]);
}
}
uniques.removeAll(doublons); // Destructive set-difference
System.out.println("Mots uniques : " + uniques);
System.out.println("Doublons : " + doublons);
}
}
java TrouveDoublons2 salut bonjour tcho tcho hello
Mots uniques : [hello, salut, bonjour]
Doublons : [tcho]
Interface : Map
public interface Map {
// Basic Operations
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
// Bulk Operations
void putAll(Map t);
void clear();
// Collection Views
public Set keySet();
public Collection values();
public Set entrySet();
// Interface for entrySet elements
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
}
Map : implémentations
HashMap
• implantation par table de hachage
• RAPIDE
TreeMap
• arbre de recherche binaire équilibré
• trié
Générer la table de fréquence des mots en input
import java.util.*;
public class Freq {
private static final Integer ONE = new Integer(1);
public static void main(String args[]) {
Map m = new HashMap();
// Initialize frequency table from command line
for (int i=0; i<args.length; i++) {
Integer freq = (Integer) m.get(args[i]);
m.put(args[i], (freq==null ? ONE : new
Integer(freq.intValue() + 1)));
}
System.out.println(m.size()+" distinct words detected:");
System.out.println(m);
}
}
Générer la table de fréquence des mots en input
java Freq if it is to be it is up to me to delegate
8 distinct words detected:
{up=1, delegate=1, it=2, me=1, be=1, is=2, if=1, to=3}
avec un TreeMap
{be=1, delegate=1, if=1, is=2, it=2, to=3, up=1}
Attention aux types d'objets stockés !
HashSet et HashMap (pour les clés/keys)
⇒ si vous utilisez une classe que vous avez créée vous mêmes, il faut implémenter les
méthodes hashCode() et equals()
TreeSet et TreeMap
⇒ cf comparator dans tableaux
La classe Collections
(similaire à la classe Arrays)
fournit des méthodes pour :
•
•
•
•
•
•
•
trier (sort)
mélanger (schuffle)
inverser l'ordre des éléments (reverse)
remplir (fill)
copier (copy)
rechercher un élément (binarySearch)
trouver les valeurs extrêmes (min, max)
! Certaines de ces méthodes ne peuvent être utilisées que sur des Collections de type liste.
import java.util.*;
public class Donne {
public static List distribueMain(List jeuCartes, int n) {
int nbTotalCartes = jeuCartes.size();
List mmainVue = jeuCartes.subList(nbTotalCartes-n,
nbTotalCartes);
List mmain = new ArrayList(mmainVue);
mmainVue.clear();
return mmain;
}
public static void main(String args[]) {
int nombreMains = Integer.parseInt(args[0]);
int cartesParMain = Integer.parseInt(args[1]);
// jeu de 52 cartes
String[] couleurs = new String[] {"trefle", "coeur",
"carreau", "pique"};
String[] numeros = new String[]
{"as","2","3","4","5","6","7","8","9","10","vallet",
"reine","roi"};
List jeuCartes = new ArrayList();
for (int i=0; i<couleurs.length; i++){
for (int j=0; j<numeros.length; j++){
jeuCartes.add(numeros[j] + " de " + couleurs[i]);
}
}
Collections.shuffle(jeuCartes);
for (int i=0; i<nombreMains; i++){
System.out.println(distribueMain(jeuCartes,
cartesParMain));
}
}
}
java Donne 4 3
[4 de pique, 9 de
[2 de pique, 8 de
[vallet de coeur,
[roi de trefle, 5
trefle, vallet de pique]
trefle, 3 de carreau]
reine de trefle, roi de pique]
de trefle, 10 de trefle]