Programme Java pour effectuer la traversée de l’arborescence des post-commandes

Exemple: programme Java pour effectuer une traversée de l’arborescence post-ordre

 class Node {
int item;
Node left, right;

public Node(int key) {
item = key;
left = right = null;
}
}

class Tree {
// Root of Binary Tree
Node root;

Tree() {
root = null;
}

void postorder(Node node) {
if (node == null)
return;

// traverse the left child
postorder(node.left);

// traverse the right child
postorder(node.right);

// traverse the root node
System.out.print(node.item + "->");
}

public static void main(String[] args) {

// create an object of Tree
Tree tree = new Tree();

// create nodes of the tree
tree.root = new Node(1);
tree.root.left = new Node(12);
tree.root.right = new Node(9);

// child nodes of left child
tree.root.left.left = new Node(5);
tree.root.left.right = new Node(6);

// postorder tree traversal
System.out.println("Postorder traversal");
tree.postorder(tree.root);
}
}
 

Java HashMap entrySet ()

La syntaxe du entrySet() la méthode est:

 hashmap.entrySet() 

Ici,hashmapest un objet de la HashMap classe.


Paramètres entrySet ()

le entrySet() La méthode ne prend aucun paramètre.


valeur de retour entrySet ()

  • renvoie unvue d’ensemblede toutes les entrées d’un hashmap

Remarque: La vue d’ensemble signifie que toutes les entrées de la carte de hachage sont vues comme un ensemble. Les entrées ne sont pas converties en un ensemble.


Exemple 1: Java HashMap entrySet ()

 import java.util.HashMap;

class Main {
  public static void main(String[] args) {
    // create an HashMap
    HashMap<String, Integer> prices = new HashMap<>();

    // insert entries to the HashMap
    prices.put("Shoes", 200);
    prices.put("Bag", 300);
    prices.put("Pant", 150);
    System.out.println("HashMap: " + prices);

    // return set view of mappings
    System.out.println("Set View: " + prices.entrySet());
  }
} 

Production

HashMap: {Pantalon = 150, Sac = 300, Chaussures = 200}
Définir la vue: [Pantalon = 150, Sac = 300, Chaussures = 200]

Dans l’exemple ci-dessus, nous avons créé un hashmap nommédes prix. Remarquez l’expression,

 prices.entrySet() 

Ici le entrySet() renvoie une vue d’ensemble de toutes les entrées de la table de hachage.

le entrySet() peut être utilisée avec lapour chaque bouclepour parcourir chaque entrée du hashmap.

Exemple 2: méthode entrySet () dans for-each Loop

 import java.util.HashMap;
import java.util.Map.Entry;

class Main {
    public static void main(String[] args) {

        // Creating a HashMap
        HashMap<String, Integer> numbers = new HashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("HashMap: " + numbers);

        // access each entry of the hashmap
        System.out.print("Entries: ");

        // entrySet() returns a set view of all entries
        // for-each loop access each entry from the view
        for(Entry<String, Integer> entry: numbers.entrySet()) {
            System.out.print(entry);
            System.out.print(", ");
        }
    }
} 

Production

HashMap: {Un = 1, Deux = 2, Trois = 3}
Entrées: un = 1, deux = 2, trois = 3,

Dans l’exemple ci-dessus, nous avons importé le java.util.Map.Entry paquet. le Map.Entry est la classe imbriquée du Map interface. Remarquez la ligne,

 Entry<String, Integer> entry :  numbers.entrySet() 

Ici le entrySet() méthode retourne undéfinir la vue de toutes les entrées. le Entry 

Programme Java pour vérifier si un nombre est pair ou impair

Exemple 1: Vérifiez si un nombre est pair ou impair en utilisant l’instruction if … else

 import java.util.Scanner;

public class EvenOdd {

    public static void main(String[] args) {

        Scanner reader = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int num = reader.nextInt();

        if(num % 2 == 0)
            System.out.println(num + " is even");
        else
            System.out.println(num + " is odd");
    }
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez un nombre: 12
12 est pair

Dans le programme ci-dessus, un Scanner objet, reader est créé pour lire un nombre sur le clavier de l’utilisateur. Le numéro saisi est ensuite stocké dans une variablenum.

Maintenant, pour vérifier sinumest pair ou impair, nous calculons son reste en utilisant % opérateur et vérifiez s’il est divisible par 2 ou pas.

Pour cela, nous utilisons if...else déclaration en Java. Sinumest divisible par 2 , nous imprimonsnumest même. Sinon, nous imprimonsnumest impair.

Nous pouvons également vérifier sinumest pair ou impair en utilisant l’opérateur ternaire en Java.


Exemple 2: vérifier si un nombre est pair ou impair à l’aide de l’opérateur ternaire

 import java.util.Scanner;

public class EvenOdd {

    public static void main(String[] args) {

        Scanner reader = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int num = reader.nextInt();

        String evenOdd = (num % 2 == 0) ? "even" : "odd";

        System.out.println(num + " is " + evenOdd);

    }
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez un nombre: 13
13 est étrange

Dans le programme ci-dessus, nous avons remplacé if...else instruction avec opérateur ternaire (? :) .

Ici, sinumest divisible par 2,  "even" est retourné. Autre, "odd" 

Programme Kotlin pour vérifier si un nombre est pair ou impair

Exemple 1: Vérifiez si un nombre est pair ou impair en utilisant l’instruction if … else

 import java.util.*

fun main(args: Array<String>) {

    val reader = Scanner(System.`in`)

    print("Enter a number: ")
    val num = reader.nextInt()

    if (num % 2 == 0)
        println("$num is even")
    else
        println("$num is odd")
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez un nombre: 12
12 est pair

Dans le programme ci-dessus, un Scanner objet, reader est créé pour lire un nombre sur le clavier de l’utilisateur. Le numéro saisi est ensuite stocké dans une variablenum.

Maintenant, pour vérifier sinumest pair ou impair, nous calculons son reste en utilisant % opérateur et vérifiez s’il est divisible par 2 ou pas.

Pour cela, nous utilisons if...else déclaration en Java. Sinumest divisible par 2 , nous imprimonsnumest même. Sinon, nous imprimonsnumest impair.

Nous pouvons également vérifier sinumest pair ou impair en utilisant if … else comme expression.


Exemple 2: Vérifiez si un nombre est pair ou impair en utilisant l’expression if … else

 import java.util.*

fun main(args: Array<String>) {

    val reader = Scanner(System.`in`)

    print("Enter a number: ")
    val num = reader.nextInt()

    val evenOdd = if (num % 2 == 0) "even" else "odd"

    println("$num is $evenOdd")
} 

Lorsque vous exécutez le programme, la sortie sera:

Entrez un nombre: 13
13 est étrange

Contrairement à Java, dans Kotlin, les instructions if … else sont également des expressions. Ainsi, vous pouvez stocker la valeur de retour de if...else déclaration à un variable . Ceci est un substitut de l’opérateur ternaire de Java (? :) à Kotlin.

Voici le code équivalent en Java: Vérifiez si un nombre est pair ou impair en Java

Dans le programme ci-dessus, sinumest divisible par 2,  "even" est retourné. Autre, "odd" est retourné. La valeur renvoyée est stockée dans une variable chaînemême bizarre.

Ensuite, le résultat est imprimé sur l’écran en utilisant println() 

C isprint ()

Les caractères qui occupent l’espace d’impression sont appelés caractères imprimables.

Les caractères imprimables sont juste l’opposé des caractères de contrôle qui peuvent être vérifiés en utilisant iscntrl ().


Prototype C isprint ()

int isprint (int arg);

La fonction isprint () prend un seul argument sous la forme d’un entier et renvoie une valeur de type int .

Même si isprint () prend un entier comme argument, le caractère est passé à la fonction. En interne, le caractère est converti en sa valeur ASCII pour le contrôle.

Si un caractère passé à isprint () est un caractère imprimable, il renvoie un entier différent de zéro, sinon il retourne 0.

Il est défini dansEn tête de fichier.


Exemple: fonction C isprint ()

 #include <ctype.h>
#include <stdio.h>

int main()
{
    char c;

    c = 'Q';
    printf("Result when a printable character %c is passed to isprint(): %d", c, isprint(c));

    c = '\n';
    printf("\nResult when a control character %c is passed to isprint(): %d", c, isprint(c));

    return 0;
} 

Production

Résultat lorsqu'un caractère imprimable Q est passé à isprint (): 1
Résultat lorsqu'un caractère de contrôle
 est passé à isprint (): 0

Exemple: Programme C pour lister tous les caractères imprimables à l’aide de la fonction isprint ().

 
#include <ctype.h>
#include <stdio.h>
int main()
{
int c;
for(c = 1; c <= 127; ++c)
if (isprint(c)!= 0)
printf("%c ", c);
return 0;
}
 

Classe OutputStream Java

le OutputStream classe de la java.io package est une superclasse abstraite qui représente un flux de sortie d’octets.

Puisque OutputStream est une classe abstraite, elle n’est pas utile en soi. Cependant, ses sous-classes peuvent être utilisées pour écrire des données.


Sous-classes de OutputStream

Afin d’utiliser la fonctionnalité de OutputStream , nous pouvons utiliser ses sous-classes. Certains d’entre eux sont:

  • FileOutputStream
  • ByteArrayOutputStream
  • ObjectOutputStream

Subclasses of Java OutputStream are FileOutputStream, ByteArrayOutputStream and ObjectOutputStream.

Nous en apprendrons davantage sur toutes ces sous-classes dans le prochain tutoriel.


Créer un OutputStream

Afin de créer un OutputStream , nous devons importer le java.io.OutputStream paquet en premier. Une fois le package importé, voici comment créer le flux de sortie.

 // Creates an OutputStream
OutputStream object = new FileOutputStream();
 

Ici, nous avons créé un objet de flux de sortie en utilisant FileOutputStream . C’est parce que OutputStream est une classe abstraite, nous ne pouvons donc pas créer un objet de OutputStream .

Remarque: Nous pouvons également créer le flux de sortie à partir d’autres sous-classes du OutputStream classe.


Méthodes de OutputStream

le OutputStream La classe fournit différentes méthodes implémentées par ses sous-classes. Voici quelques méthodes:

  •  write() – écrit l’octet spécifié dans le flux de sortie
  •  write(byte[] array) – écrit les octets du tableau spécifié dans le flux de sortie
  •  flush() – force à écrire toutes les données présentes dans le flux de sortie vers la destination
  •  close() – ferme le flux de sortie

Exemple: OutputStream à l’aide de FileOutputStream

Voici comment nous pouvons mettre en œuvre OutputStream en utilisant le FileOutputStream classe.

 import java.io.FileOutputStream;
import java.io.OutputStream;

public class Main {

    public static void main(String args[]) {
        String data = "This is a line of text inside the file.";

        try {
            OutputStream out = new FileOutputStream("output.txt");

            // Converts the string into bytes
            byte[] dataBytes = data.getBytes();

            // Writes data to the output stream
            out.write(dataBytes);
            System.out.println("Data is written to the file.");

            // Closes the output stream
            out.close();
        }

        catch (Exception e) {
            e.getStackTrace();
        }
    }
}
 

Dans l’exemple ci-dessus, nous avons créé un flux de sortie en utilisant le FileOutputStream classe. Le flux de sortie est maintenant lié au fichieroutput.txt.

 OutputStream out = new FileOutputStream("output.txt");
 

Pour écrire des données dansoutput.txtfile, nous avons implémenté ces méthodes.

 output.write();      // To write data to the file
output.close();      // To close the output stream
 

Lorsque nous exécutons le programme, leoutput.txtLe fichier contient le contenu suivant.

 This is a line of text inside the file.
 

C ++ snprintf ()

Contrairement à sprintf (), le nombre maximum de caractères pouvant être écrits dans le tampon est spécifié dans snprintf() .

prototype snprintf ()

int snprintf (char * buffer, size_t buf_size, const char * format, ...);

le snprintf() function écrit la chaîne pointée par format surtampon. Le nombre maximum de caractères pouvant être écrits est (buf_size-1) .

Une fois les caractères écrits, un caractère nul de fin est ajouté. Sibuf_sizeest égal à zéro, rien n’est écrit et le tampon peut être un pointeur nul.

Il est défini dansEn tête de fichier.

Paramètres snprintf ()

  • tampon: Pointeur vers le tampon de chaîne pour écrire le résultat.
  • buf_size: Spécifiez le nombre maximum de caractères à écrire dans la mémoire tampon qui estbuf_size-1.
  • format: Pointeur vers une chaîne terminée par null qui est écrite dans le flux de fichiers. Il se compose de caractères avec des spécificateurs de format facultatifs commençant par%.

    Les spécificateurs de format sont remplacés par les valeurs des variables respectives qui suivent la chaîne de format.

    Le spécificateur de format comprend les parties suivantes:

    • Un signe% en tête
    • Drapeaux: Un ou plusieurs indicateurs facultatifs qui modifient le comportement de conversion.
      • -: Justifiez à gauche le résultat dans le champ. Par défaut, il est justifié à droite.
      • +: Le signe du résultat est attaché au début de la valeur, même pour les résultats positifs.
      • Espace: s’il n’y a pas de signe, un espace est attaché au début du résultat.
      • #: Une autre forme de conversion est effectuée.
      • 0: Il est utilisé pour les nombres entiers et flottants. Les zéros non significatifs sont utilisés pour compléter les nombres au lieu de l’espace.
    • Largeur: Valeur facultative * ou entière utilisée pour spécifier un champ de largeur minimale.
    • Précision: Un champ facultatif composé d’un. suivi de * ou entier ou rien pour spécifier la précision.
    • Longueur: Un modificateur de longueur facultatif qui spécifie la taille de l’argument.
    • Prescripteur: Un spécificateur de format de conversion. Les spécificateurs de format disponibles sont les suivants:
      Spécificateur de format La description
      % Impressions%
      c Écrit un seul caractère
      s Écrit une chaîne de caractères
      d ou i Convertit un entier signé en représentation décimale
      o Convertit un entier non signé en représentation octale
      X ou x Convertit un entier non signé en représentation hexadécimale
      u Convertit un entier non signé en représentation décimale
      F ou f Convertit un nombre à virgule flottante en représentation décimale
      E ou e Convertit un nombre à virgule flottante en notation d’exposant décimal
      Un ou un Convertit un nombre à virgule flottante en exposant hexadécimal
      G ou g Convertit un nombre à virgule flottante en notation d’exposant décimal ou décimal
      n Renvoie le nombre de caractères écrits jusqu’à présent par cet appel à la fonction. Le résultat est écrit sur la valeur pointée par l’argument
      p Écrit une séquence de caractères définie par l’implémentation définissant un pointeur.

      Ainsi, le format général du spécificateur de format est: %[flags][width][.precision][length]specifier 

  • …: Autres arguments supplémentaires spécifiant les données à imprimer. Ils se produisent dans une séquence selon le spécificateur de format.

snprintf () Valeur de retour

En cas de succès, le snprintf() La fonction renvoie le nombre de caractères qui auraient été écrits pour un tampon suffisamment grand à l’exclusion du caractère nul de fin. En cas d’échec, il renvoie une valeur négative.

La sortie est considérée comme écrite complètement si et seulement si la valeur renvoyée est non négative et inférieure àbuf_size.

Exemple: fonctionnement de la fonction snprintf ()

 #include <cstdio>
#include <iostream>

using namespace std;

int main()
{
char buffer[100];
int retVal, buf_size = 100;
char name[] = "Max";
int age = 23;

retVal = snprintf(buffer, buf_size, "Hi, I am %s and I am %d years old", name, age);
if (retVal > 0 && retVal < buf_size)
{
cout << buffer << endl;
cout << "Number of characters written = " << retVal << endl;
}
else
cout << "Error writing to buffer" << endl;

return 0;
}
 

Java Math copySign ()

La syntaxe du copySign() la méthode est:

 Math.copySign(arg1, arg2) 

Ici, copySign() est une méthode statique. Par conséquent, nous accédons à la méthode en utilisant le nom de la classe, Math .


Paramètres de copySign ()

le copySign() La méthode prend deux paramètres.

  • arg1– premier argument dont le signe doit être remplacé
  • arg2– deuxième argument dont le signe est copié dansarg1

Remarque: Les types de donnéesarg1etarg2devrait être soit float ou double .


copySign () Valeurs de retour

  • renvoie le premier argument,arg1avec signe du deuxième argument,arg2

Remarque: Pour les arguments(arg1, -arg2), la méthode retourne-arg1.


Exemple: Java Math.copySign ()

 class Main {
  public static void main(String[] args) {

    // copy sign of double arguments
    double x = 9.6d;
    double y = -6.45;
    System.out.println(Math.copySign(x, y));  // -9.6

    // copy sign of float arguments
    float a = -4.5f;
    float b = 7.34f;
    System.out.println(Math.copySign(a, b));  // 4.5

  }
} 

Ici, comme vous pouvez le voir copySign() 

Programme Kotlin pour afficher les caractères de A à Z en utilisant la boucle

Exemple 1: affichage de A à Z en majuscules

 fun main(args: Array<String>) {
    var c: Char

    c = 'A'
    while (c <= 'Z') {
        print("$c ")
        ++c
    }
} 

Lorsque vous exécutez le programme, la sortie sera:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 

Comme Java, vous pouvez parcourir A à Z en utilisant une boucle for car ils sont stockés sous forme de caractères ASCII dans Kotlin.

Ainsi, en interne, vous parcourez 65 à 90 pour imprimer les alphabets anglais.

Voici le code Java équivalent: Programme Java pour afficher les alphabets anglais

Avec une petite modification, vous pouvez afficher les alphabets en minuscules comme indiqué dans l’exemple ci-dessous.


Exemple 2: affichage de a à z en minuscules

 fun main(args: Array<String>) {
var c: Char

c = 'a'
while (c <= 'z') {
print("$c ")
++c
}
}
 

Programme Kotlin pour convertir un nombre octal en nombre décimal et vice-versa

Exemple 1: programme pour convertir le décimal en octal

 fun main(args: Array<String>) {
    val decimal = 78
    val octal = convertDecimalToOctal(decimal)
    println("$decimal in decimal = $octal in octal")
}

fun convertDecimalToOctal(decimal: Int): Int {
    var decimal = decimal
    var octalNumber = 0
    var i = 1

    while (decimal != 0) {
        octalNumber += decimal % 8 * i
        decimal /= 8
        i *= 10
    }

    return octalNumber
} 

Lorsque vous exécutez le programme, la sortie sera:

78 en décimal = 116 en octal

Cette conversion a lieu comme:

8 | 78
8 | 9 -- 6
8 | 1 -- 1
8 | 0 -- 1
(116)

Exemple 2: programme pour convertir octal en décimal

 fun main(args: Array<String>) {
val octal = 116
val decimal = convertOctalToDecimal(octal)
println("$octal in octal = $decimal in decimal")
}

fun convertOctalToDecimal(octal: Int): Int {
var octal = octal
var decimalNumber = 0
var i = 0

while (octal != 0) {
decimalNumber += (octal % 10 * Math.pow(8.0, i.toDouble())).toInt()
++i
octal /= 10
}

return decimalNumber
}