Discussion :

[ranell]

bonsoir a tous,
voici le code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
class temps
{int heure ,minute , seconde;
 
String convertToString()
{String dp=":";
StringBuffer sb=new StringBuffer();
sb.append(heure+dp+minute+dp+seconde;
String forme=sb.toString();
return(forme);}}

heure minute et seconde seront saisi au clavier ,lu comme des char convertit en string, puis en entiers.( j'ai defini une fonction keyboard pour effectuer ces conversions)
ma question est: est ce que c'est fesable de mettre dans StringBuffer des entiers et des chars ensemble??? et comment ca se fait sachant que ma fonction s'execute correctement et me retourne un string de la forme heure:minute:seconde.

merci pour votre aide.

[gifffftane]

Il est tout à fait étonnant que le code que tu nous as donné fonctionne. Il est donc difficile de te répondre, à part des généralités.

Java est un langage dit typé, c'est à dire que chaque variable a un type définit explicitement. Il y a de nombreuses exceptions, qui ne sont qu'apparentes, qui facilitent l'écriture, mais qui perturbent le débutant.

Donc si tu mets des int (par exemple) à la place de char, de string ou de choses, il faut que tu gardes à l'esprit que la variable d'origine est un int (et que probablement cela risque de ne pas compiler ou fonctionner à un moment ou à un autre).

Dans ton problème il me semble qu'il y a quelques-unes de ces facilités d'écriture qui perturbent le débutant.

Lorsque tu reçois du clavier 123456, il ne s'agit pas d'un nombre au sens java. Au sens java, c'est une série de caractères, conservée dans un String. Cette chose a les propriétés d'un String, non celle d'un entier : tu ne pourras pas faire d'addition dessus, par exemple.

Pour obtenir un entier à partir d'un String, il faut par exemple utiliser la méthode Integer.parseInt. Pour obtenir un String à partir d'un entier, utiliser la méthode Integer.toString.

Ainsi tu peux, si tu veux, tout mettre en un StringBuffer, à condition de savoir convertir ce que tu veux y mettre en chaine de caractères ou String.

Si ces explications ne te permettent pas de comprendre aussi bien que tu le voudrais, redonnes-nous un code correct et utilises la balise code, ce sera plus facile pour nous.

[OButterlin]

Pour faire plus dans l'esprit de StringBuffer tu devrais coder ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
StringBuffer sb = new StringBuffer();
sb.append(heures).append(":").append(minutes).append(":").append(secondes);

A+

[adiGuba]

Salut,

Pour faire plus dans l'esprit de StringBuffer tu devrais coder ceci :

Ou plus directement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return heures + ":" + minutes + ":" + secondes;

Ce qui revient strictement au même

a++

[xv-mnt]

Juste pour info, n'y a t-il pas des problèmes de performances à utiliser des strings ? ou bien le JDK est-il capable d'optimiser le code pour avoir des performances comparables entre String et StringBuffer.
Il me semble que l'utilisation des StringBuffer (et maintenant StringBuilder depuis 1.5) était bcp plus performant que la concaténation de String.
Est-ce toujours vrai ?

[OButterlin]

Ou plus directement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return heures + ":" + minutes + ":" + secondes;

Ce qui revient strictement au même

Tout à fait d'accord

Avec ta méthode, (il se disait qu') on passe par un nombre de variables intermédiaires String... (donc sur de la grosse concat, plus lent)...
C'est encore d'actualité ?

[xv-mnt]

Un petit test qui montre que la concaténation de String est TRES mauvaise au niveau temps :
Résultat :
Time taken using Strings 17078 milli seconds
Time taken using StringBuffer : 16 milli seconds
Time taken using StringBuilder : 0 milli seconds

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
package test.performance;
 
/**
 * This class shows the time taken for creation of String literals and String objects.
 */
 
public class StringTest1 {
 
    public static void main(String[] args) {
 
        // create String literals
        long startTime = System.currentTimeMillis();
        String s1 = "hello";
 
        for (int i = 0; i < 20000; i++) {
            s1 = s1 + ":" + "hello";
        }
 
        long endTime = System.currentTimeMillis();
        System.out.println("Time taken using Strings " + (endTime - startTime) + " milli seconds");
 
 
        // create StringBuffer objects using 'new' keyword
        long startTime1 = System.currentTimeMillis();
 
        StringBuffer s2 = new StringBuffer();
        for (int i = 0; i < 20000; i++) {
            s2.append(":").append("hello");
        }
 
        long endTime1 = System.currentTimeMillis();
        System.out.println("Time taken using StringBuffer : " + (endTime1 - startTime1) + " milli seconds");
 
 
        // create StringBuffer objects using 'new' keyword
        long startTime2 = System.currentTimeMillis();
 
        StringBuilder s3 = new StringBuilder();
        for (int i = 0; i < 20000; i++) {
            s3.append(":").append("hello");
        }
 
        long endTime2 = System.currentTimeMillis();
        System.out.println("Time taken using StringBuilder : " + (endTime2 - startTime2) + " milli seconds");
 
    }
 
}

[®om]

Juste pour info, n'y a t-il pas des problèmes de performances à utiliser des strings ? ou bien le JDK est-il capable d'optimiser le code pour avoir des performances comparables entre String et StringBuffer.
Il me semble que l'utilisation des StringBuffer (et maintenant StringBuilder depuis 1.5) était bcp plus performant que la concaténation de String.
Est-ce toujours vrai ?

Oui, StringBuilder est plus performant que des concaténation de String dans des boucles par exemple.

Mais par contre, si tu écris "en ligne":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

machin + ":" + truc

ça va être remplacé par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

new StringBuilder().append(machin).append(":").append(truc);

l'optimisation est faite...

Attention à ne pas tomber dans une erreur classique lors des append:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Random random = new Random();
StringBuilder builder = new StringBuilder();
for(int i = 0; i < 5000; i++) {
    builder.append(random.nextDouble() + ":");
    // il faut mettre builder.append(random.nextDouble().append(":"));
}

En effet, ceci sera remplacé par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Random random = new Random();
StringBuilder builder = new StringBuilder();
for(int i = 0; i < 5000; i++) {
    builder.append(new StringBuilder().append(random.nextDouble().append(":"));
}

[®om]

Un petit test qui montre que la concaténation de String est TRES mauvaise au niveau temps

Oui, dans une boucle c'est normal

A partir de Java 1.5, StringBuffer n'a aucune raison d'être utilisé.

Pour les versions inférieures, à la place de ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
StringBuffer buffer = new StringBuffer();
for(int i = 0; i < 20000; i++) {
    buffer.append(i);
}

il vaut mieux faire ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
StringBuffer buffer = new StringBuffer();
synchronized(buffer) {
    for(int i = 0; i < 20000; i++) {
        buffer.append(i);
    }
}

(ça évite de prendre et de relâcher le verrou 20000 de suite, on le fait qu'une fois).

[xv-mnt]

Merci pour les précisions !

[adiGuba]

Oui, dans une boucle c'est normal

En effet il ne faut pas utiliser l'opérateur '+' au sein d'une boucle (ou sur un grand nombre de lignes), mais ce n'est pas pour autant qu'il ne faut jamais l'utiliser...

Dans ce cas précis l'opérateur + génèrera un bytecode équivalent à celui qui utiliserait un StringBuffer/StringBuilder... tout en restant bien plus lisible...


Je suis en train d'écrire un article où je parle de cela... en cas de besoin je pourrais poster le brouillon...

A partir de Java 1.5, StringBuffer n'a aucune raison d'être utilisé.

Oui : pour la compatibilité ! Il y a encore quelques classes qui attendent des StringBuffer et qui n'accepte pas de StringBuilder. Je pense en particulier à Matcher).


a++

[®om]

Oui : pour la compatibilité ! Il y a encore quelques classes qui attendent des StringBuffer et qui n'accepte pas de StringBuilder. Je pense en particulier à Matcher).


a++

Ouais, d'ailleurs je me demande pourquoi ils n'ont pas rajouté la possibilité d'utiliser un StringBuilder dans Matcher...
Ou encore mieux, ils auraient dû faire une abstraction (une interface) commune aux deux...

[sinok]

Bah si elles ont une interface commune: CharSequence

[®om]

Bah si elles ont une interface commune: CharSequence

Oui mais une interface "intermédiaire", non commune avec String. Par exemple "BufferedString". Comme ça dans Matcher au lieu de prendre un StringBuffer, il pourrait prendre un BufferedString

[adiGuba]

Il y a bien AbstractStringBuilder dont hérite StringBuffer et StringBuilder et qui comporte le code en commun de ces deux classes...

Mais cette classe n'est pas publique (package-private). Elle ne peut donc pas être utilisé pour le moment (voir BugID 6476646).

a++

[ranell]

bonsoir a tous,
voila le code :
*fichier keyboard.java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class keyboard
	{private static char unchar()
		{char c='\0';
		try
			{c=(char)System.in.read();}
		catch(Exception e)
			{System.out.println("erreur de saisie");}
			return c;
		}
	private static String unString()
		{StringBuffer sb=new StringBuffer();
		char c;
		do
			{c=unchar();
			if(c!='\n'&&c!='\r')  sb.append(c);}
		while(c!='\n'&&c!='\0');
		String s=sb.toString();
		return s;
		}
	public static int unEntier()
		{return ((int)Integer.parseInt(unString()));}}

fichier Date.java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
class Date
{int heure,minute,seconde; 
 
Date(int heure,int minute,int seconde)
{this.heure=heure;
this.minute=minute;
this.seconde=seconde;}
 
Date()
{this(01,01,49);}
 
int getheure()//methode accesseur getheure
{return(heure);}
 
int getminute()//methode accesseur getminute
{return(minute);}
 
int getseconde()//methode accesseur getseconde
{return(seconde);}
 
void setheure(int heure)
{this.heure=heure;}
 
void setminute(int minute)
{this.minute=minute;}
 
void setseconde(int seconde)
{this.seconde=seconde;}
 
void setDate(int heure,int minute,int seconde)
{setheure(heure);
  setminute(minute);
 setseconde(seconde);}
 
void affiche()
{System.out.println("heure:"+getheure()+"\nminute:"+getminute()+"\nseconde:"+getseconde());}
 
String convertToString()
{String dp=":";
StringBuffer sb=new StringBuffer();
sb.append(heure+dp+minute+dp+seconde);
String forme=sb.toString();
return(forme);
}}

fichier testDate.java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class testDate
{public static void main(String [] args)
{keyboard key= new keyboard();
System.out.println("on va determiner la date d1:entrer heure minute seconde separe par enter");
Date d1= new Date(key.unEntier(),key.unEntier(),key.unEntier());
Date d2= new Date();
System.out.println("D2 est par defaut :"+d2.convertToString()+",On va modifier d2, entrer heure minute seconde :");
d2.setDate(key.unEntier(),key.unEntier(),key.unEntier());
System.out.println("La date d1:"+d1.convertToString());
System.out.println("La date d2:"+d2.convertToString());
}}

[nicgando]

Je crois qu'en fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
StringBuffer buffer = new StringBuffer();
synchronized(buffer) {
    for(int i = 0; i < 20000; i++) {
        buffer.append(i);
    }
}

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
StringBuffer buffer = new StringBuffer();
synchronized(buffer) {
    for(int i = 0; i < 20000; i++) {
        buffer.append(i);
    }
}

C'est pareil car ta variable étant locale elle ne peut être accessible par aucun autre Thread du coup la JVM ne synchronise pas sur buffer

Source: à partir des slides 34 sur un ppt de Javapolis 2006; je l'ai mis ici (bon faut attendre 20s avant d'avoir le lien de download en bas de la page )

J'avoue j'ai jamais testé mais c'est à faire

[®om]

ça c'est sûr c'est strictement identique, t'as mis le même code

Sinon j'ai compris ce que tu voulais dire, mais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void main(String... args) {
        final int NB_ITER = 1000000;
 
        long t;
 
        t = System.nanoTime();
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < NB_ITER; i++) {
            buffer.append(i);
        }
        System.out.println(System.nanoTime() - t);
 
        t = System.nanoTime();
        buffer = new StringBuffer();
        synchronized(buffer) {
            for (int i = 0; i < NB_ITER; i++) {
                buffer.append(i);
            }
        }
        System.out.println(System.nanoTime() - t);
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
628062784
237040182

[ranell]

tout ca c un peu compliqué pour moi mais bon ma question c t : est-ce que c'est possible de stocker dans un stringbuffer des entier et des char, Gifffftane a dit que c'est etonnant que sa fonctionne , et justement sa focntion et je comprend pas exactement comment ca se passe...
merci pour votre aide

[gifffftane]

J'ai dit qu'il était étonnant que ton code fonctionne, et non pas que ça fonctionne (enfin, "sa", excusez-moi).

Sinon, à la question Est-ce qu'il est possible de mettre dans un StringBuffer des entiers et des chars, la réponse Java est non pour les entiers, oui pour les chars.

Pour le reste, consulte les tutoriaux, c'est la meilleure chose que tu puisses faire. Ils expliquent pas à pas les notions, et il est beaucoup plus efficace de procéder ainsi plutôt que de partir d'un bout de code plus ou moins correct et de s'en expliquer le pourquoi du comment.