Exercice Java Corrigé pour Débutant | Partie 4

 import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner in = new Scanner(System.in);
        
        // Déclarer des variables pour stocker le nombre octal et 
        // décimal, ainsi qu'un compteur d'index.
        long oct_nbr, dec_nbr = 0;
        int i = 0;
        
        // Inviter l'utilisateur à saisir un nombre octal
        System.out.print("Saisir un nombre octal: ");
        oct_nbr = in.nextLong();
        
        // Convertir le nombre octal en nombre décimal
        while (oct_nbr != 0) {
            dec_nbr = (long)(dec_nbr + (oct_nbr % 10) * Math.pow(8, i++));
            oct_nbr = oct_nbr / 10;
        }
        
        // Afficher le nombre décimal équivalent
        System.out.print("Le nombre décimal est: " + dec_nbr + "\n");
    }
}

Sortie:

Saisir un nombre octal: 888
Le nombre décimal est: 584

Explication:

Dans l’exercice ci-dessus :

• Tout d’abord, l’utilisateur saisit un nombre octal à l’aide de la classe « Scanner » et le stocke dans la variable « oct_nbr ».
• Il initialise une variable « dec_nbr » pour stocker l’équivalent décimal et une autre variable « i » pour suivre la position de chaque chiffre octal.
• Il entre dans une boucle pour effectuer la conversion octal-décimal :
  • À chaque itération, il calcule le reste lorsque « oct_nbr » est divisé par 10 (ce qui donne le chiffre octal le moins significatif).
  • Il multiplie ce reste par 8 élevé à la puissance ‘i’ et l’ajoute à ‘dec_nbr’ pour accumuler la valeur décimale.
  • Pour passer au chiffre octal suivant, il incrémente i.
  • Il met à jour ‘oct_nbr’ en supprimant le chiffre le moins significatif (le plus à droite) en le divisant par 10.
  • La boucle continue jusqu’à ce que ‘oct_nbr’ devienne zéro, convertissant ainsi l’ensemble du nombre octal en nombre décimal.
• Après la boucle, la représentation décimale du nombre octal original stocké dans la variable ‘dec_nbr’ est affichée.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner in = new Scanner(System.in);
        
        // Définir un tableau pour faire correspondre les chiffres 
        // octaux à leurs équivalents binaires
        int[] octal_values = {0, 1, 10, 11, 100, 101, 110, 111};
        
        // Déclarer des variables pour stocker le nombre octal, 
        // le nombre octal temporaire, le nombre binaire et 
        // une valeur de place.
        long octal_nbr, octal_tmp, bin_nbr, place;
        int reste;
        
        // Inviter l'utilisateur à saisir un nombre octal
        System.out.print("Saisir un nombre octal: ");
        octal_nbr = in.nextLong();
        octal_tmp = octal_nbr;
        bin_nbr = 0;
        place = 1;
        
        // Convertir le nombre octal en nombre binaire à l'aide du 
        // tableau de correspondance
        while (octal_tmp != 0) {
            reste = (int)(octal_tmp % 10);
            bin_nbr = octal_values[reste] * place + bin_nbr;
            octal_tmp /= 10;
            place *= 1000;
        }
        
        // Afficher le nombre binaire équivalent
        System.out.print("Le nombre binaire est: "+ bin_nbr);
    }
}

Sortie:

Saisir un nombre octal: 7
Le nombre binaire est: 111

Explication:

Dans l’exercice ci-dessus :

• Tout d’abord, l’utilisateur saisit un nombre octal à l’aide de la classe « Scanner » et le stocke dans la variable « octal_nbr ».
• Il initialise un tableau « octal_values » pour stocker les équivalents binaires des chiffres octaux (0 à 7).
• Il initialise les variables ‘octal_tmp’ pour stocker temporairement le nombre octal, ‘bin_nbr’ pour stocker l’équivalent binaire, ‘place’ pour garder une trace de la position de chaque chiffre octal, et ‘reste’ pour stocker le reste lors de la division de ‘octal_tmp’ par 10.
• Ensuite, il entre dans une boucle pour effectuer la conversion octal-binaire :
  • À chaque itération, il calcule le reste lorsque ‘octal_tmp’ est divisé par 10 (ce qui donne le chiffre octal le moins significatif).
  • Il utilise ‘reste’ pour rechercher l’équivalent binaire dans le tableau ‘octal_values’ et l’ajoute à ‘bin_nbr’, en tenant compte de la valeur de place appropriée.
  • Il divise « octal_tmp » par 10 pour supprimer le chiffre le moins significatif (le plus à droite).
  • Elle met à jour la variable « place » pour passer au groupe suivant de trois chiffres binaires.
  • La boucle continue jusqu’à ce que ‘octal_tmp’ devienne zéro, convertissant ainsi l’ensemble du nombre octal en binaire.
• Enfin (après la boucle), il affiche la représentation binaire du nombre octal d’origine stocké dans la variable ‘bin_nbr’.

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        // Déclarer des variables pour stocker les nombres octaux 
        // et leurs équivalents décimaux et hexadécimaux
        String oct_nbr, hex_nbr;
        int dec_nbr;
        
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner in = new Scanner(System.in);
        
        // Inviter l'utilisateur à saisir un nombre octal
        System.out.print("Saisir un nombre octal: ");
        oct_nbr = in.nextLine();
        
        // Convertir le nombre octal en son équivalent décimal 
        // à l'aide de parseInt
        dec_nbr = Integer.parseInt(oct_nbr, 8);
        
        // Convertir le nombre décimal en son équivalent hexadécimal
        hex_nbr = Integer.toHexString(dec_nbr);
        
        // Afficher le nombre hexadécimal équivalent
        System.out.print("Le nombre hexadécimal est: "+ hex_nbr);
    }
}

Sortie:

Saisir un nombre octal: 75
Le nombre hexadécimal est: 3d

Explication:

Dans l’exercice ci-dessus :

• Tout d’abord, l’utilisateur saisit un nombre octal à l’aide de la classe « Scanner » et le stocke sous la forme d’une chaîne dans la variable « oct_nbr ».
• Il utilise la méthode « Integer.parseInt() » pour convertir la chaîne « oct_nbr » en un entier « dec_nbr », en spécifiant la base 8 (octal).
• Il utilise ensuite la méthode « Integer.toHexString() » pour convertir le ‘dec_nbr’ en sa représentation hexadécimale et le stocke dans la chaîne ‘hex_nbr’.
• Enfin, il affiche la représentation hexadécimale du nombre octal d’origine stocké dans la variable ‘hex_nbr’.

public class Main {
    public static void main(String[] args) {
        System.out.println("Version de Java: " + System.getProperty("java.version"));
        System.out.println("Version de Java Runtime: " + System.getProperty("java.runtime.version"));
        System.out.println("Java Home: " + System.getProperty("java.home"));
        System.out.println("Fournisseur de Java: " + System.getProperty("java.vendor"));
        System.out.println("URL du fournisseur Java: " + System.getProperty("java.vendor.url"));
        System.out.println("Chemin d'accès aux classes Java: " + System.getProperty("java.class.path"));
    }
}

Sortie:

Version de Java: 11.0.4
Version de Java Runtime: 11.0.4+10-LTS
Java Home: /opt/jdk/jdk-11.0.4
Fournisseur de Java: Oracle Corporation
URL du fournisseur Java: http://java.oracle.com/
Chemin d'accès aux classes Java: .

Explication:

On utilise System.getProperty() pour accéder à des propriétés spécifiques du système Java et les récupérer.

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        // Créer un objet Scanner pour lire les données de 
        // l'utilisateur
        Scanner sc = new Scanner(System.in);
        int nbr1; // Premier nombre à comparer
        int nbr2; // Deuxième nombre à comparer

        System.out.print("Saisir le premier nombre: ");
        nbr1 = sc.nextInt();

        System.out.print("Saisir le deuxième nombre: ");
        nbr2 = sc.nextInt();

        // Comparer et afficher les résultats
        if (nbr1 == nbr2)
            System.out.printf("%d == %d\n", nbr1, nbr2);
        if (nbr1 != nbr2)
            System.out.printf("%d != %d\n", nbr1, nbr2);
        if (nbr1 < nbr2)
            System.out.printf("%d < %d\n", nbr1, nbr2);
        if (nbr1 > nbr2)
            System.out.printf("%d > %d\n", nbr1, nbr2);
        if (nbr1 <= nbr2)
            System.out.printf("%d <= %d\n", nbr1, nbr2);
        if (nbr1 >= nbr2)
            System.out.printf("%d >= %d\n", nbr1, nbr2);
    }
}

Sortie:

Saisir le premier nombre: 5
Saisir le deuxième nombre: 9
5 != 9
5 < 9
5 <= 9

Explication:

Ici, on effectue une série de comparaisons à l'aide des instructions if et affiche les résultats à l'aide de System.out.printf().

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Définir une chaîne de test
        String str = "Rue 45, Quartier Sain Denis:France";
        
        // Appeler la méthode count pour analyser les caractères 
        // dans str
        count(str);
    }

    public static void count(String str) {
        // Convertir la chaîne d'entrée en un tableau de caractères
        char[] ch = str.toCharArray();
        
        // Initialiser les compteurs de lettres, d'espaces, 
        // de chiffres et d'autres caractères
        int lettre = 0;
        int espace = 0;
        int chiffre = 0;
        int autre = 0;
        
        // Parcourir le tableau de caractères pour catégoriser 
        // les caractères
        for (int i = 0; i < str.length(); i++) {
            // Vérifier si le caractère est une lettre
            if (Character.isLetter(ch[i])) {
                lettre++;
            }
            // Vérifier si le caractère est un chiffre (nombre)
            else if (Character.isDigit(ch[i])) {
                chiffre++;
            }
            // Vérifier si le caractère est un espace
            else if (Character.isSpaceChar(ch[i])) {
                espace++;
            }
            // Si aucune des conditions ci-dessus n'est remplie.
            else {
                autre++;
            }
        }
        
        System.out.println(str);
        System.out.println("Lettre: " + lettre);
        System.out.println("Espace: " + espace);
        System.out.println("Chiffre: " + chiffre);
        System.out.println("Autre: " + autre);
    }
}

Sortie:

Rue 45, Quartier Sain Denis:France
Lettre: 26
Espace: 4
Chiffre: 2
Autre: 2

Explication:

Dans l'exercice ci-dessus :

• La chaîne de caractères à analyser est stockée dans la variable 'str'.
• La méthode « count() » prend une chaîne de caractères « str » comme paramètre.
• Dans la méthode « count() », la méthode « toCharArray() » est utilisée pour convertir la chaîne d'entrée str en un tableau de caractères 'ch'.
• Quatre variables (lettre, espace, chiffre et autre) sont initialisées à zéro. Ces variables seront utilisées pour compter les types respectifs de caractères dans la chaîne.
• Une boucle for parcourt chaque caractère du tableau « ch ».
• À l'intérieur de la boucle, elle vérifie le type de chaque caractère à l'aide de diverses méthodes de la classe « Character » telles que isLetter(), isDigit() et isSpaceChar(). En fonction du type, il incrémente la variable compteur correspondante (lettre, espace, chiffre ou autre).
• Enfin, il affiche la chaîne de caractères originale et le nombre de chaque type de caractère.

import java.io.Console;

public class Main {
    public static void main(String[] args) {
        // Déclarez une variable Console 'cons'.
        Console cons;

        // Vérifiez si la console du système est disponible.
        if ((cons = System.console()) != null) {
            // Déclarez un tableau de caractères 'psw' pour stocker 
            // le mot de passe.
            char[] psw = null;

            try {
                // Inviter l'utilisateur à saisir son mot de passe.
                psw = cons.readPassword("Saisir votre mot de passe:");

                // Afficher le mot de passe dans la console.
                System.out.println("Votre mot de passe est: "+ new String(psw));
            } finally {
                // Assurez-vous que le tableau des mots de passe est 
                // bien effacé.
                if (psw != null) {
                    java.util.Arrays.fill(psw, ' ');
                }
            }
        } else {
            throw new RuntimeException("Impossible de récupérer le mot de passe... Pas de console");
        }
    }
}

Sortie:

Saisir votre mot de passe:
Votre mot de passe est: @lex!o

public class Main {
    public static void main(String[] args) {
        System.out.println("Lorem ipsum dolor sit amet, \n\tconsectetur adipiscing elit facilisi \n\t\tneque ad lacus velit, \n\t\thac suscipit suspendisse. \ntempor mi imperdiet et dis montes, \n\tdonec cubilia maximus vulputate!\n\n");
    }
}

Sortie:

Lorem ipsum dolor sit amet, 
	consectetur adipiscing elit facilisi 
		neque ad lacus velit, 
		hac suscipit suspendisse. 
tempor mi imperdiet et dis montes, 
	donec cubilia maximus vulputate!

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Parcourir les nombres de 1 à 10
        for (int i = 1; i <= 10; i++) {
            // Vérifier si le nombre est impair
            if (i % 2 != 0) {
                // Afficher le nombre impair
                System.out.println(i);
            }
        }
    }
}

Sortie:

1
3
5
7
9