JAVA année 2017 CP 2 – série n°2 Exercice 1
publicité
JAVA année 2017
CP 2 – série n°2
Exercices sur les méthodes statiques et les tableaux
En JAVA une fonction est une méthode STATIC.
La signature d'une méthode static en java est la suivante :
public static typeDuRésultat NomDeLaMéthode (liste des paramètres)
{
déclarations de variables (locales à cette méthode)
instructions de résolution du probléme
retourne valeurRésultat; //au moins 1 fois
}
La méthode est dite « static » car elle ne s'applique pas sur des objets. Les méthodes static ne sont
pas les méthodes les plus utilisées en Java. Les méthodes static sont souvent utilisées comme des
fonctions outils. Lorsqu'elles sont déclarées dans un autre fichier que le fichier qui l'utilise, on
utilise le nom du fichier qui contient la méthode comme préfixe. Par exemple, la méthode Math.sqrt
indique que la fonction static sqrt est dans le fichier Math.
Exercice 1
La méthode des rectangles permet d’approximer l’intégrale d’une fonction f continue. Cette
méthode consiste à découper en n intervalles [ai, ai+1], de longueur identique m, l’intervalle [a,b] sur
lequel on veut intégrer la fonction f, puis à additionner l’aire des rectangles de hauteur
a+a
f ( i i + 1 ) et de largeur m. L’aire A, approximation de l’intégrale f sur l’intervalle [a,b] aura
2
pour valeur :
n
A=∑ m× f (
i=1
Illustration :
a i+ ai+ 1
)
2
Programmez en Java une fonction (méthode static) qui calcule l’intégrale de la fonction cosinus sur
un intervalle [a,b]. Testez votre méthode, par exemple, sur l’intervalle [0,/2].
Exercice 2
Écrire une classe DateEntiere qui comprend un ensemble de méthodes statiques permettant la
manipulation de dates au format entier (jour sur 2 chiffres 01 à 31, mois sur deux chiffres 01 à 12 et
année sur 4 chiffres).
•
DateValide qui retourne vrai si la chaîne passée en paramètre est valide. Il faudra prendre en
compte le problème du maximum des jours de mois à 30,3= 31, 28 ou 29 jours). Vous
pouvez consulter la classe String
https://docs.oracle.com/javase/8/docs/api/java/lang/String.html pour apprendre comment
récupérer une sous-chaîne de caractère. La classe Integer
https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html comporte des méthodes
statiques permettant de transformer un String en entier ;
•
public static int getJour(String s) qui retourne le numéro entier de la date si elle au format
entier de date, sinon retourne -1 ;
•
public static int getMois(String s) et static int getAnnée(String s) même chose pour le
mois et l'année ;
•
public static String enLettres(String s) retourne la date sous forme textuelle jour mois en
toute lettre et année en chiffre, retourne la chaîne vide si la date n'est pas au format ;
•
écrire une classe MainDate qui demande à l'utilisateur d'entrer une date et affiche cette date
en toute lettre si elle est valide ou affiche date invalide dans le cas contraire (cf ci-dessous)
java MainDate
Entrez une date 14022017
14 février 2017
Entrez une date 34012017
La date 34012017 est invalide
public class DateEntiere {
public static boolean dateValide(String s){
if (s.length() != 8)
return false;
int jour;
jour = Integer.parseInt(s.substring(0,2));
if ((jour < 1) || (jour > 31))
return false;
int mois = Integer.parseInt(s.substring(2,4));
if ((mois < 1) || (mois > 12))
return false;
int année;
année = Integer.parseInt(s.substring(4,s.length()));
if ((année < 1000) || (année > 9999))
return false;
return true;
}
public static int getJour(String s){
if (dateValide(s)){
int jour;
jour = Integer.parseInt(s.substring(0,2));
return jour;
}
}
return -1;
public static int getMois(String s){
if (dateValide(s)){
int mois = Integer.parseInt(s.substring(2,4));
return mois;
}
return -1;
}
public static int getAnnée(String s){
if (dateValide(s)){
int année;
année = Integer.parseInt(s.substring(4,s.length()));
return année;
}
}
return -1;
public static String entouteLettre(String s){
String res="";
if (dateValide(s)){
int jour = getJour(s);
int mois = getMois(s);
int année = getAnnée(s);
res = jour + " ";
switch(mois){
case 1:
res = res + "janvier ";
break;
case 2:
res = res + "février ";
break;
case 3:
res = res + "mars ";
break;
}
res = res + année;
return res;
}
}
return "";
}
import java.util.Scanner;
public class MainDate {
public static void main(String [] args){
String date;
Scanner sc = new Scanner(System.in);
System.out.print("Entrez une date ");
date = sc.next();
if (DateEntiere.dateValide(date))
System.out.println(DateEntiere.entouteLettre(date));
else
System.out.println("La date " + date + " est invalide");
}
}
Exercice 3 - Classe java.util.Arrays
Écrivez une classe TestArrays dont la méthode main
1.crée un tableau de 150 nombres entiers et le remplit avec des nombres tirés au hasard entre
1 et 200 (pensez à utiliser la classe Random) ;
2.affiche les valeurs du tableau en utilisant la classe Arrays ;
3.trie ce tableau par ordre croissant en utilisant la classe Arrays ;
4.affiche à nouveau les valeurs du tableau (pour vérifier le tri) ;
5.tire 20 nombres au hasard et indique s'ils appartiennent au tableau (et en ce cas, donne la
position dans le tableau) en utilisant la recherche dichotomique (voir classe Arrays).
import java.util.Random;
import java.util.Arrays;
public class Ex0211 {
public static final int MAX = 150;
public static void main(String [] args){
Random r = new Random();
int [] tab = new int[MAX];
// génération de nombres aléatoires
for(int i = 0; i < tab.length; i++)
tab[i] = r.nextInt(200) + 1;
// affichage
System.out.println(Arrays.toString(tab));
// trie du tableau
Arrays.sort(tab);
// affichage
System.out.println("\n tableau trié " + Arrays.toString(tab));
// recherche de 20 valeurs
for(int i = 0; i < 20; i++){
int val = r.nextInt(200) + 1;
System.out.print("recherche de " + val);
if (Arrays.binarySearch(tab,val) > 0)
System.out.println(" trouvé à la position " +
Arrays.binarySearch(tab,val));
else
System.out.println(" non trouvé");
}
}
}
Exercice 4
Écrire une classe TestTableau dont la méthode main :
• crée un tableau de 100 nombres entiers et le remplit avec des valeurs aléatoires entre 100 et
200 ;
• affiche les valeurs du tableau (classe Arrays)
• affiche la plus petite valeur du tableau, la plus grande et la moyenne des éléments du tableau
• affiche l’élément le plus fréquent dans le tableau et affiche sa fréquence d’apparition. Pour
ce dernier point vos écrirez une fonction de signature public static int frequence(int [] t,
val) qui retourne la fréquence de val dans le tableau t
import java.util.Random;
import java.util.Arrays;
public class Ex0212 {
public static final int MAX = 100;
public static void main(String [] args){
Random r = new Random();
int [] tab = new int[MAX];
// génération de nombres aléatoires
for(int i = 0; i < tab.length; i++)
tab[i] = r.nextInt(100) + 101;
// affichage
System.out.println(Arrays.toString(tab));
System.out.println("plus petite valeur " + min(tab));
System.out.println("plus grande valeur " + max(tab));
System.out.println("moyenne " + moyenne(tab));
// calcul de la fréquence pour tout le tableau
int maxFrequence = frequence(tab,tab[0]);
int val = tab[0];
int f;
for(int i = 1; i < tab.length; i++){
f = frequence(tab,tab[i]);
if (f > maxFrequence){
maxFrequence = f;
val = tab[i];
}
}
System.out.println("le nombre le plus fréquent est " + val + " présent "
+ maxFrequence + " fois");
}
public static int min(int [] t){
int valMin = t[0];
for(int i = 0; i < t.length; i++)
if (t[i] < valMin)
valMin = t[i];
}
return valMin;
public static int max(int [] t){
int valMax = t[0];
for(int i = 0; i < t.length; i++)
if (t[i] > valMax)
valMax = t[i];
}
return valMax;
public static double moyenne(int [] t){
double m = 0.0;
for(int i = 0; i < t.length; i++)
m += (double) t[i];
}
return m / (double) t.length;
/* retourne la fréquence de val dans le tableau t */
public static int frequence(int [] t, int val){
int f = 0;
for(int i = 0; i < t.length; i++)
if (t[i] == val)
f++;
return f;
}
}
Exercice 5
Écrire un programme permettant de représenter un histogramme sur un écran (cf. la figure cidessous) à partir d'un tableau H de 10 entiers.
Vous commencerez par générer un tableau de 10 entiers dont chaque élément prend une valeur
comprise entre -6 et +6.
*
*
*
*
*
+ + + + + *
* *
*
*
*
*
*
*
* *
* *
+ + + +
* *
*
Chaque colonne i contient un nombre d'étoiles égal à la valeur de H[i]. L'axe des abscisses sera
représenté comme une ligne de '+' mais si H[i] = 0, on affichera une '*'.
H -1 -3 2 -2 3 0 4 2 -2 -1
Remarque : on fait l'hypothèse que le tableau H est compatible avec la taille de l'écran.
import java.util.Random;
import java.util.Arrays;
public class Ex0213 {
public static void main(String [] args){
final int TAILLE_TABLEAU = 10;
Random r = new Random();
int [] h = new int[TAILLE_TABLEAU];
/*--- création de valeurs aléatoires entre -6 et + 6 pour le tableau
---*/
int val;
for(int i = 0; i < h.length; i++){
val = r.nextInt(7);
if (r.nextBoolean())
h[i] = val;
else
h[i] = -val;
}
/*--- affichage des valeurs du tableau ---*/
System.out.println(Arrays.toString(h));
/*--- création de l'histogramme ---*/
/*--- partie positive ---*/
for(int i = 6; i > 0; i--){
for(int j = 0; j < h.length; j++)
if (h[j] >= i)
System.out.print("* ");
else
System.out.print(" ");
System.out.println("");
}
/*--- axe des abscisses ---*/
for(int i = 0; i < h.length; i++)
System.out.print("++");
System.out.println("");
/*--- partie négative ---*/
for(int i = -1; i > -7; i--){
for(int j = 0; j < h.length; j++)
if (h[j] <= i)
System.out.print("* ");
else
System.out.print(" ");
System.out.println("");
}
}
}
