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();
        }
    }
}

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.*;
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();
    }
}