Possibilité d'avoir deux flux de sorties standards

Bonjour à tous !

Je me posais une question : est-il possible d'avoir deux flux de sorties standards ?

Je sais comment rediriger les flux standards (par exemple dans des fichiers) :
Code:

1 2 System.setOut(new PrintStream(new FileOutputStream("std.out"))); System.setErr(new PrintStream(new FileOutputStream("std.err")));
Mais est-il possible d'afficher par exemple le Out sur la console, et dans le même temps de l'écrire dans un fichier ?

Merci d'avance

avec apache common io:

Code:

1
2
3
4
5
6
7
8
9
public class App 
{
    public static void main( String[] args ) throws FileNotFoundException
    {
    	FileOutputStream fos = new FileOutputStream(new File("d:\\test.txt"));
    	System.setOut(new PrintStream(new TeeOutputStream(fos, System.out)));
        System.out.println( "Hello World!" );
    }
}

Merci tchize_ !

En fait, c'est assez facile si on ne veux pas rajouter apache common io. Il suffit d'écrire sa propre classe qui hérite d'OutputStream. Voici un exemple (trouvé ici et un peu modifié par mes soins) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class MultiOutputStream extends OutputStream {
 
	private List<OutputStream> outs;
 
	public MultiOutputStream(List<OutputStream> outs) {
		this.outs = new ArrayList<OutputStream>();
		if (outs == null)
			throw new NullPointerException();
		if (outs.size() == 0)
			outs.add(System.out);
		for (OutputStream out : outs) {
			if (out == null)
				throw new NullPointerException();
			this.outs.add(out);
		}
	}
 
	@Override
	public void write(int b) throws IOException {
		for (OutputStream out : outs) {
			out.write(b);
		}
	}
 
	@Override
	public void write(byte[] b) throws IOException {
		for (OutputStream out : outs) {
			out.write(b);
		}
	}
 
	@Override
	public void write(byte[] b, int off, int len) throws IOException {
		for (OutputStream out : outs) {
			out.write(b, off, len);
		}
	}
 
	@Override
	public void close() throws IOException {
		for (OutputStream out : outs) {
			out.close();
		}
	}
 
	@Override
	public void flush() throws IOException {
		for (OutputStream out : outs) {
			out.flush();
		}
	}
}

Avec cette classe, on peut rajouter n'importe combien de flux de sortie standard. Et ça s'utilise assez facilement :

Code:

1
2
3
4
5
6
7
8
FileOutputStream fos = new FileOutputStream(stdOut);
List<OutputStream> outs = new ArrayList<OutputStream>();
outs.add(fos);
outs.add(System.out);
 
System.setOut(new PrintStream(new MultiOutputStream(outs)));
 
System.out.println("Hello world");