ENPC - Programmation - Corrections 9

Exercice 1:

import java.util.*;

public class Exo1 {
  // Caractère requis dans les chaînes à conserver 
  final static char C = 'a';

  public static void main(String[] args) {
    // Création d'un ArrayList vide
    ArrayList al = new ArrayList();
    
    for(int i=0; i<args.length; i++) {
      // Si le caractère C est dans la String
      if(args[i].indexOf(C) >= 0)
	// on ajoute à la fin
	al.add(args[i]);
    }
    
    System.out.println("Nombre de chaînes sur la ligne de commande: "
		       + args.length);
    System.out.println("Nombre d'éléments dans la structure ArrayList: "
		       + al.size());
  }
}

Exercice 2:

import java.util.*;

public class Exo2 {
  // Caractère requis dans les chaînes à conserver 
  final static char C = 'a';

  static void affichageBoucle(ArrayList al) {
    for(int i=0; i<al.size(); i++) {
      System.out.println(al.get(i));
    }
  }
  
  static void affichageIterateur(ArrayList al) {
    for(Iterator it = al.iterator(); it.hasNext(); ) {
      System.out.println(it.next());
    }
    // Qui est une forme condensée de 
    // Iterator it = al.iterator();
    // while(it.hasNext()) {
    //   System.out.println(it.next());
    // }
  }
  
  public static void main(String[] args) {
    // Création d'un ArrayList vide
    ArrayList al = new ArrayList();
    
    for(int i=0; i<args.length; i++) {
      // Si le caractère C est dans la String
      if(args[i].indexOf(C) >= 0)
	// on ajoute à la fin
	al.add(args[i]);
    }
    System.out.println("Affichage avec une boucle et la taille:");
    affichageBoucle(al);
    System.out.println("Affichage avec un itérateur:");
    affichageIterateur(al);
  }
}

Exercice 3:

import java.util.*;

public class Exo3 {
  // Caractère requis dans les chaînes à conserver 
  final static char C = 'a';

  // Affichage du contenu de la structure (n'importe quelle AbstractList)
  static void affichageIterateur(AbstractList l) {
    for(Iterator it = l.iterator(); it.hasNext(); ) {
      System.out.println(it.next());
    }
  }

  // Ajout à sa place d'une String dans une AbstractList
  static void addOrdered(AbstractList l, String s) {
    // trouver la position d'insertion i
    int i;
    for(i=0; i < l.size(); i++) {
      
      // Si l'élément est null, on passe au suivant
      if (l.get(i) == null)
	continue;

      // Si l'élément est lexicographiquement inférieur
      // à s, on passe au suivant
      if (((Comparable)l.get(i)).compareTo(s) < 0)
	continue;

      // Sinon, l'élément est lexicographiquement supérieur
      // ou égal à s, alors il faut insérer ici, à l'indice i
      break;
    }
    
    // Il faut donc insérer ici. 
    l.add(i,s);
  }
  
  public static void main(String[] args) {
    // Création d'une LinkedList vide
    LinkedList l = new LinkedList();
    
    for(int i=0; i<args.length; i++) {
      // Si le caractère C est dans la String
      if(args[i].indexOf(C) >= 0)
	// on ajoute à la fin
	addOrdered(l,args[i]);
    }
    System.out.println("Affichage de la structure de liste triée:");
    affichageIterateur(l);
  }
}

Exercice 4:

import java.util.*;

public class Exo4 {
  // Affichage du contenu de la structure (n'importe quelle Collection)
  static void affichageIterateur(Collection c) {
    for(Iterator it = c.iterator(); it.hasNext(); ) {
      System.out.println(it.next());
    }
  }
  
  public static void main(String[] args) {
    // Création d'un ensemble vide
    Set s = new HashSet();
    
    for(int i=0; i<args.length; i++) {
      if(!s.add(args[i]))
	System.out.println("Le mot " + args[i] + " est en doublon.");
    }
    System.out.println("Affichage de la structure d'ensemble:");
    affichageIterateur(s);
  }
}

Exercice 5:

import java.util.*;

public class Exo5 {
  // Affichage du contenu de la structure (n'importe quelle Collection)
  static void affichageIterateur(Collection c) {
    for(Iterator it = c.iterator(); it.hasNext(); ) {
      System.out.println(it.next());
    }
  }
  
  public static void main(String[] args) {
    // Création d'un ensemble ordonné vide
    SortedSet s = new TreeSet();
    
    for(int i=0; i<args.length; i++) {
      if(!s.add(args[i]))
	System.out.println("Le mot " + args[i] + " est en doublon.");
    }
    System.out.println("Affichage de la structure d'ensemble triée:");
    affichageIterateur(s);
  }
}

Exercice 6:

import java.util.*;

public class Exo6 {
  // Affichage du contenu de la structure (n'importe quelle Collection)
  static void affichageIterateur(Collection c) {
    for(Iterator it = c.iterator(); it.hasNext(); ) {
      System.out.println(it.next());
    }
  }

  // Classe interne définissant le comparateur de String sur le nombre
  // de caractères qu'elles contiennent
  // Ici, cette classe interne est statique car on n'a pas d'objet englobant 
  static class NbChar implements Comparator {
    public int compare(Object o1, Object o2) {
      String s1 = (String) o1;
      String s2 = (String) o2;
      int l1 = s1.length();
      int l2 = s2.length();
      if (l1 == l2)
	return ((Comparable) o1).compareTo(o2);
      return l1 - l2;
    }
  }
    
  public static void main(String[] args) {
    // Création d'une instance de notre comparateur 
    Comparator c = new NbChar();
    
    // Création d'un ensemble ordonné vide avec notre propre comparateur
    SortedSet s = new TreeSet(c);

    for(int i=0; i<args.length; i++) {
      if(!s.add(args[i]))
	System.out.println("Le mot " + args[i] + " est en doublon.");
    }
    System.out.println("Affichage de la structure d'ensemble triée:");
    affichageIterateur(s);
  }
}

Exercice 7:

import java.util.*;

public class TableauIter {
  Object [] tab;
  int index;
  public TableauIter(int capacity) {
    tab = new Object[capacity];
    index = -1;
  }

  // Retourne vrai s'il est vide, faux sinon
  public boolean isEmpty() {
    return (index < 0);
  }

  // Retourne l'élément à l'indice i
  public Object get(int i) {
    return tab[i];
  }

  // Ajoute à la fin du tableau
  public void add(Object o) {
    tab[index+1] = o;
    index++;
  }

  // Retourne une itération du tableau
  public Iterator iterator() {
    return new TableauIterator();
  }

  class TableauIterator implements Iterator {
    int i = 0;
    int max = index;
    public boolean hasNext() {
      return (i<=index);
    }
    public Object next() {
      if (!(hasNext()))
	throw new NoSuchElementException();
      Object o = tab[i];
      i++;
      return o;
    }
    public void remove() {
      throw new UnsupportedOperationException();
    }
  }
  public static void main(String[] args) {
    TableauIter t = new TableauIter(5);
    t.add("a");
    t.add("b");
    t.add("c");
    t.add("d");
    t.add("e");
    for(Iterator it = t.iterator(); it.hasNext(); )
      System.out.println(it.next());
  }
}

Etienne.Duris[at]univ-mlv.fr - © École Nationale des Ponts et Chaussées - Janvier 2002 - http://www-igm.univ-mlv.fr/~duris/ENPC/