public void distribueCourrier() {
    synchronized (boiteAuxLettres) {
        for (Courrier<?> c : this.boiteAuxLettres) {
            c.getDestinataire().recoitCourrier(c);
        }
        this.boiteAuxLettres.clear();
    }        
}

if (this.courrierADistribuer())
    this.distribueCourrier();
 
écriture dans l'arraylist

if (!maListe.empty())
    maListe.clear();
 
maListe.add("toto" );

1. public static void main(String[] args) {
2.         List<String> l = new ArrayList();
3.         l.add("hello" );
4.         l.add("world" );
5.         l.add("what's" );
6.         l.add("up?" );
8.         for (String s : l) {
9.             l.remove(3);
10.         }
11.     }

import java.net.*;
import java.io.*;
import java.util.*;
 
public class MonServeurThread
{    
    private List<Socket> connectedClients = new ArrayList<Socket>();
    ServerSocket serverSocket = null;
    
    MonServeurThread() throws IOException {
        this.createServer();
    }
    
    private void createServer() throws IOException {
        boolean listening = true;
        
        // On ouvre une connexion sur le port 4444
        try {
            serverSocket = new ServerSocket(4444);
        } catch (IOException e) {
            System.out.println("Could not listen on port: 4444" );
            System.exit(-1);
        }
    
        while (listening) {
            // On stocke chaque nouveau socket dans une liste pour pouvoir ensuite
            // communiquer avec tout le monde
            connectedClients.add(serverSocket.accept());
            new Thread(new ClientConnectionHandler(
                connectedClients.get(connectedClients.size() - 1), this)).start();
        }
            
        serverSocket.close();
    }
    
    public List<Socket> getConnectedClients() {
        return this.connectedClients;
    }
 
    public static void main(String[] args) throws IOException {
        new MonServeurThread();
    }
}

import java.net.*;
import java.io.*;
import java.util.*;
 
public class ClientConnectionHandler implements Runnable
{
    private Socket socket = null;
    List<Socket> connectedClient = new ArrayList<Socket>();
    MonServeurThread mst = null;
    
    ClientConnectionHandler(Socket socket, MonServeurThread mst) {
        this.socket = socket;
        this.mst = mst;
    }
 
    public void run() {    
        PrintWriter out = null;
        PrintWriter outAll = null; // outAll is to send a message to all the clients
        BufferedReader in = null;
        String inputLine = null;
    
        try {
            out = new PrintWriter(socket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(
                                        socket.getInputStream()));
                                        
            String clientHostname = 
                        ((InetSocketAddress) socket.getRemoteSocketAddress())
                            .getAddress().getHostName(); // get client hostname                            
                                            
            out.println(clientHostname + " is online." );    
                                            
            while (true) {
                inputLine = in.readLine();
            
                if (inputLine.equalsIgnoreCase("bye" )) {
                    System.out.println("Connexion avec le client fermée !" );
                    break;
                }
                //else {                
                    for (Socket s : mst.getConnectedClients()) {
                        outAll = new PrintWriter(s.getOutputStream(), true);
                        outAll.println(clientHostname +": " + inputLine);
                    }
                //}
            }    
            socket.close();         
            out.close();
            in.close();
                  
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
 
public class Client
{
    public static void main(String[] args) throws IOException {
        Socket socket = null;
        PrintWriter out = null;
        BufferedReader input;
 
        try {
            socket = new Socket("koskoz-laptop", 4444);
            out = new PrintWriter(socket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host: hostname." );
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for the connection to: hostname." );
            System.exit(1);
        }
        
        input = new BufferedReader (new InputStreamReader (
                                        new FileReader(socket.getInputStream())));
            
        new Thread (new BufferReaderHandler ()).start();
 
    }
}

import java.io.*;
 
public class BufferReaderHandler implements Runnable
{
    BufferedReader input;    
    
    BufferReaderHandler (BufferedReader input) {
        this.input = input;
    }
    
    public void run () { 
        while (true) {
            try {
                String line = input.readLine(); 
                System.out.println("Server sent: " + line);
            }
            catch (IOException e) {
                e.printStackTrace();
            }    
        }
    }
}

import java.io.*;
import java.net.*;
 
public class MulticastServerThread implements Runnable 
{
    protected DatagramSocket socket = null;
    
    public void run() {
        String in = null;
        try {
            while (true) {
                byte[] buf = new byte[256];
                
                String toSend = "Salut !";
                buf = toSend.getBytes();
 
                socket = new DatagramSocket(2678);
                InetAddress groupAdress = InetAddress.getByName("224.0.0.1" );
                DatagramPacket packet = new DatagramPacket(buf, buf.length, 
                                                            groupAdress, 7654);                                            
                                                                
                socket.send(packet);
            }
            //socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
 
 
public class Recepteur {    //le serveur reçoit
    final static int NUMPORT = 2000;
    /**
     * Methode statique d'envoi
     * @param nomfichier chemin du fichier
     * @param port, port de transfert
     */
    public static void recevoir(String nomfichier,int port) throws Exception {
        //duree d'attente du sleep
        final int DUREEATTENTE = 1;
        
        //Le recepteur doit creer un ServerSocket et attendre une demande de connexion par l'emetteur
        ServerSocket server = new ServerSocket(port);
        Socket socket = server.accept();
        
        //Pour emettre et recevoir des donnees d'un Socket, il faut utiliser les flux 
        //entrant et sortant des Socket (methodes getInputStream() et getOutputStream()).
        InputStream istrsocket = socket.getInputStream();
        FileOutputStream fos = new FileOutputStream(nomfichier);
        byte[] buf;
        //Une fois que le recepteur a recu la demande de connexion (passage de methode accept())
        //et a recupere le Socket lui permettant de communiquer avec l'emetteur, il faut attendre
        //que les premieres donnees soient arrivees (utilisation de la methode avaible)
        int taille = istrsocket.available();
        //boucle attendant que quelque chose soit dispo
        while(taille == 0){
            taille = istrsocket.available();
            Thread.sleep(DUREEATTENTE);
        }
        
        while(taille != 0){
            Thread.sleep(DUREEATTENTE);
            buf = new byte[taille];
            if(istrsocket.read(buf) != -1){
                fos.write(buf);
            }
            taille = istrsocket.available();
        }
        fos.close();
        istrsocket.close();
        socket.close();//fermeture des ports et fichiers
    }
    
    /**
     * 
     * @param args[0] nom du fichier
     * @param args[1] numero du port
     */
    public static void main(String args[]){
        try {
            long tps = System.nanoTime();
            recevoir("./ImageTransferee.jpg",NUMPORT);
            //recevoir(args[0],Integer.valueOf(args[1]));
            //System.out.println("Temps de reception : "+(System.nanoTime() - tps)+" nano secondes" );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
 
 
public class Emetteur {    //le client envoie, le serveur recoit
    
    /**
     * @param pathname nom du fichier
     * @param port numero du port a utiliser
     * @param ip, String sur laquelle on envoie les fichiers
     */
    public static void envoit(String pathname,int port,String ip) throws Exception{
        final int TAILLEPAQUET = 65000;    //taille maximale du paquet pour le tableau de bytes
        
        Socket socket = new Socket(InetAddress.getByName(ip),port);
        FileInputStream file = new FileInputStream(pathname);
        
        byte[] tbyte = new byte[TAILLEPAQUET];
        OutputStream out = socket.getOutputStream();
        
        int nombre = file.read(tbyte);
        out.write(tbyte);
        
        while(nombre > 0){    //boucle pour gerer les gros fichiers
            nombre = file.read(tbyte);
            out.write(tbyte);
        }
        
        file.close();
        out.close();
        socket.close();
    }
    
    public static void main(String args[]){
        try {
                int tps = (int) System.nanoTime();
                envoit("./Photo2Mo.jpg", 2000, "localhost" );
                //System.out.println("Temps de transmission : "+(System.nanoTime() - tps)+" nano secondes" );
                System.out.println(System.nanoTime() - tps);
 
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public static void sendFile(String path_name, int port, String ip) throws Exception {
            // Input stream, source is the file.
            FileInputStream fis = new FileInputStream(path_name);
            
            // Output stream, destination is the socket.
            Socket socket = new Socket(InetAddress.getByName(ip), port);
            OutputStream os = socket.getOutputStream();
            
            // Preparing the transmition buffer.
            final int BUFFER_SIZE = 1024; // 1kB is good, even for short MTU.
            byte[] buffer = new byte[BUFFER_SIZE];
            
                        // Sending the file content...
            while ((int bytesRead = fis.read(buffer)) != -1) {
                os.write(buffer, 0, bytesRead);
            }
            
            // Closing input stream.
            fis.close();
            
            // Closing output stream.
            os.close();
            socket.close();
        }

public static void receiveFile(String filename, int port) throws Exception {
    // Creating server socket.
    ServerSocket ss = new ServerSocket(port);
    Socket socket = server.accept();
 
    // Input stream, source is the socket.
    InputStream is = socket.getInputStream();
 
    // Output stream, destination is the file.
    FileOutputStream fos = new FileOutputStream(filename);
 
    // Preparing the transmition buffer.
    final int BUFFER_SIZE = 1024;
            byte[] buffer = new byte[BUFFER_SIZE];
 
    while ((int bytesReceived = is.read(buffer)) != -1) {
        fos.write(buf, 0, bytesReceived);
    }
 
    // Closing output stream.
    fos.close();
 
    // Closing input stream and socket.
    is.close();
    socket.close();
}

import java.io.*;
import java.net.*;
 
/**
 * 
 * @author Antibug
 * Cette classe est a lancer en deuxieme
 * Le client envoie, le serveur recoit
 */
public class Emetteur {
    public final static int TAILLEPAQUET = 65000;    //taille maximale du paquet pour le tableau de bytes
    
    /**
     * @param pathname nom du fichier
     * @param port numero du port a utiliser
     * @param ip, String sur laquelle on envoie les fichiers
     */
    public static void envoit(String pathname,int port,String ip) throws Exception{
        
        
        Socket socket = new Socket(InetAddress.getByName(ip),port);
        FileInputStream file = new FileInputStream(pathname);
        
        byte[] tbyte = new byte[TAILLEPAQUET];
        OutputStream out = socket.getOutputStream();
        
        int nombre;
        do{
            nombre = file.read(tbyte);
            out.write(tbyte);
        } while(nombre > 0);
 
        out.flush();
        file.close();
        out.close();
        socket.close();
    }
    
    public static void main(String args[]){
        try {
            long tps = System.nanoTime();
            envoit("./Photo10Mo.jpg", 2000, "localhost" );
            //System.out.println("Temps de transmission : "+(System.nanoTime() - tps)+" nano secondes" );
            System.out.println(System.nanoTime() - tps);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
 
/**
 * 
 * @author Antibug
 * Cette classe est a lancer en premier 
 *
 */
public class Recepteur {    //le serveur reçoit
    public final static int NUMPORT = 2000;
    public final static int DUREEATTENTE = 50;//duree d'attente du sleep
    
    /**
     * Methode statique d'envoi
     * @param nomfichier chemin du fichier
     * @param port, port de transfert
     */
    public static void recevoir(String nomfichier,int port) throws Exception {
        //Le recepteur doit creer un ServerSocket et attendre une demande de connexion par l'emetteur
        ServerSocket server = new ServerSocket(port);
        Socket socket = server.accept();
        
        //Pour emettre et recevoir des donnees d'un Socket, il faut utiliser les flux 
        //entrant et sortant des Socket (methodes getInputStream() et getOutputStream()).
        InputStream istrsocket = socket.getInputStream();
        FileOutputStream fos = new FileOutputStream(new File(nomfichier));
        byte[] buf;
        
        //Une fois que le recepteur a recu la demande de connexion (passage de methode accept())
        //et a recupere le Socket lui permettant de communiquer avec l'emetteur, il faut attendre
        //que les premieres donnees soient arrivees (utilisation de la methode avaible)
        int taille;
        
        //boucle attendant que quelque chose soit dispo
        while((taille = istrsocket.available()) == 0){
            //Thread.sleep(DUREEATTENTE);
        }
        String res = "";        
        while((taille = istrsocket.available()) != 0){
            buf = new byte[Emetteur.TAILLEPAQUET];
            
            int tmp = istrsocket.read(buf);
            if(tmp != -1 && tmp != 0){
                res+=tmp+"\n";
                fos.write(buf);
                Thread.sleep(DUREEATTENTE);
            }
        }
        //fermeture des ports et fichiers
        fos.close();
        istrsocket.close();
        socket.close();
    }
    
    /**
     * 
     * @param args[0] nom du fichier
     * @param args[1] numero du port
     */
    public static void main(String args[]){
        try {
            long tps = System.nanoTime();
            recevoir("TEST10M.jpg",NUMPORT);
            //recevoir(args[0],Integer.valueOf(args[1]));
            //System.out.println("Temps de reception : "+(System.nanoTime() - tps)+" nano secondes" );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.*;
import java.util.*;
 
public class MulticastClient 
{
    public static void main(String[] args) throws IOException {
    
        MulticastSocket socket = new MulticastSocket(7654);
        InetAddress address = InetAddress.getByName("224.0.0.1" );
        socket.joinGroup(address);
 
        DatagramPacket packet;
        boolean connected = true;
        
        while (connected) {
            byte[] buf = new byte[256];
            packet = new DatagramPacket(buf, buf.length);
            socket.receive(packet);
        
            String received = new String(packet.getData());
            System.out.println("Message reçu : " + received);
            
            if (!socket.isConnected())
                connected = false;
        }
        socket.leaveGroup(address);
        socket.close();
    }
}