Méthode Java Long Reverse Bytes

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser la méthode reverseBytes() de la classe Long en Java, qui est utilisée pour inverser l'ordre des octets de la représentation binaire à complément à deux de la valeur long passée.

Créer une classe Java

Tout d'abord, nous devons créer une classe Java dans le répertoire ~/projet. Appelons-la ReverseBytesDemo.java.

public class ReverseBytesDemo {

}

Ajouter la méthode principale

Ensuite, nous devons ajouter la méthode main à notre classe. Celle-ci sera le point d'entrée de notre programme.

public static void main(String[] args) {

}

Utilisation de la méthode reverseBytes()

Maintenant, utilisons la méthode reverseBytes() pour inverser les octets d'une valeur long.

long a = 342;
long reversedValue = Long.reverseBytes(a);

System.out.println("Valeur d'origine : " + a);
System.out.println("Valeur inversée : " + reversedValue);

Ce code produira la sortie suivante :

Valeur d'origine : 342
Valeur inversée : 6197234562238513152

Utilisation de l'entrée de l'utilisateur

Nous pouvons également prendre l'entrée de l'utilisateur et inverser les octets de la valeur d'entrée. Modifions notre code pour prendre l'entrée de l'utilisateur.

Scanner scanner = new Scanner(System.in);

System.out.print("Entrez un nombre : ");
long userInput = scanner.nextLong();

long reversedValue = Long.reverseBytes(userInput);

System.out.println("Valeur d'origine : " + userInput);
System.out.println("Valeur inversée : " + reversedValue);

Ce code invite l'utilisateur à entrer un nombre puis inverse les octets de la valeur d'entrée. Exécutez le code en utilisant la commande javac ReverseBytesDemo.java && java ReverseBytesDemo.

Gérer les exceptions

Nous pouvons gérer toute exception qui peut se produire lors de la saisie d'entrée utilisateur en utilisant un bloc try-catch.

Scanner scanner = new Scanner(System.in);

try {
    System.out.print("Entrez un nombre : ");
    long userInput = scanner.nextLong();

    long reversedValue = Long.reverseBytes(userInput);

    System.out.println("Valeur d'origine : " + userInput);
    System.out.println("Valeur inversée : " + reversedValue);
} catch (InputMismatchException e) {
    System.out.println("Entrée invalide. Veuillez entrer un nombre valide.");
}

Ce code utilise un bloc try-catch pour gérer toute exception qui peut se produire lorsque l'utilisateur entre une entrée invalide.

Tester la valeur négative

Essayons la méthode reverseBytes() avec un nombre négatif.

long a = -23;
long reversedValue = Long.reverseBytes(a);

System.out.println("Valeur d'origine : " + a);
System.out.println("Valeur inversée : " + reversedValue);

Ce code produira la sortie suivante :

Valeur d'origine : -23
Valeur inversée : -1585267068834414593

Sortie de la représentation binaire

Nous pouvons également afficher la représentation binaire des valeurs d'origine et inversée en utilisant la méthode Long.toBinaryString().

System.out.println("Valeur d'origine en binaire : " + Long.toBinaryString(a));
System.out.println("Valeur inversée en binaire : " + Long.toBinaryString(reversedValue));

Ce code produira la sortie suivante :

Valeur d'origine en binaire : 1111111111111111111111111111111111111111111111111111111111101001
Valeur inversée en binaire : 1010101100000000000000000000000000000000000000000000000000000000

Remarque : la représentation binaire de la valeur inversée est la représentation binaire d'origine avec chaque groupe de 8 bits inversé.

Utilisation de la fonction définie par l'utilisateur

Écrivons une fonction définie par l'utilisateur pour encapsuler la méthode reverseBytes().

public class ReverseBytesDemo {

    public static long reverseBytes(long value) {
        return Long.reverseBytes(value);
    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        try {
            System.out.print("Entrez un nombre : ");
            long userInput = scanner.nextLong();

            long reversedValue = reverseBytes(userInput);

            System.out.println("Valeur d'origine : " + userInput);
            System.out.println("Valeur inversée : " + reversedValue);

            System.out.println("Valeur d'origine en binaire : " + Long.toBinaryString(userInput));
            System.out.println("Valeur inversée en binaire : " + Long.toBinaryString(reversedValue));

        } catch (InputMismatchException e) {
            System.out.println("Entrée invalide. Veuillez entrer un nombre valide.");
        }

    }
}

Exécution de la fonction définie par l'utilisateur

Maintenant que nous avons configuré notre fonction définie par l'utilisateur, nous pouvons la tester en exécutant à nouveau la méthode main() modifiée.

Scanner scanner = new Scanner(System.in);

try {
    System.out.print("Entrez un nombre : ");
    long userInput = scanner.nextLong();

    long reversedValue = reverseBytes(userInput);

    System.out.println("Valeur d'origine : " + userInput);
    System.out.println("Valeur inversée : " + reversedValue);

    System.out.println("Valeur d'origine en binaire : " + Long.toBinaryString(userInput));
    System.out.println("Valeur inversée en binaire : " + Long.toBinaryString(reversedValue));

} catch (InputMismatchException e) {
    System.out.println("Entrée invalide. Veuillez entrer un nombre valide.");
}

Exécutez le code en utilisant la commande javac ReverseBytesDemo.java && java ReverseBytesDemo.

Résumé

Dans ce laboratoire, nous avons appris sur la méthode reverseBytes() de la classe Long en Java, qui est utilisée pour inverser l'ordre des octets de la représentation binaire à complément à deux de la valeur long passée. Nous avons également appris à utiliser l'entrée utilisateur, à gérer les exceptions, à afficher la représentation binaire et à encapsuler la méthode dans une fonction définie par l'utilisateur. En suivant ces étapes, vous devriez maintenant être en mesure d'utiliser la méthode reverseBytes() dans vos propres programmes Java.