Types de données Java (avec exemples)

Java possède de nombreux types de données et opérations, ce qui le rend adapté à diverses tâches de programmation. Celles-ci sont très utiles dans tous les aspects de Java, que vous écriviez un programme simple ou que vous développiez une application ou un logiciel complexe. En Java, les données des deux principales catégories de types incluent les données primitives et les types de données qui ne sont pas primitifs.

Types de données Java

Les variables de Java doivent être d'un type de données spécifique. Il existe deux groupes de types de données :

• Octet
• court
• entier
• longue
• flotter
• doubler
• booléen, et
• car

La liste ci-dessus contient des exemples de types de données primitifs. D'autre part, les chaînes, les tableaux et les classes sont des exemples de types de données non primitifs.

Types de données primitives

Un type de données primitif détermine à la fois les types de valeurs variables et la taille, qui n'a pas de fonctions supplémentaires. En Java, les types de données primitifs sont au nombre de huit :

Type de données	Taille des données	Explication
octet	1 octet	a des nombres entiers de -128 à 127
court	2 octets	a des nombres entiers de -32 768 à 32 767
entier	4 octets	a des nombres entiers de -2 147 483 648 à 2 147 483 647
longue	8 octets	a des nombres entiers de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
flottant	4 octets	a des nombres qui sont des fractions. Assez pour stocker entre 6 et 7 chiffres décimaux
doubler	8 octets	Stocke les nombres fractionnaires. Suffisant pour stocker 15 chiffres décimaux
booléen	1 bit	Stocke les valeurs vraies ou fausses
caractère	2 octets	Stocke un seul caractère/lettre ou des valeurs ASCII

Numéros

Il existe deux sortes de types de nombres primitifs :

• Les types entiers stockent des entiers entiers, positifs ou négatifs, tels que 123 ou -456.
• Byte, short, int et long sont tous des types valides.

La valeur numérique détermine le type que vous devez choisir. Les types à virgule flottante représentent des nombres avec une partie fractionnaire et une ou plusieurs décimales. Float et double sont les deux types.

Même si Java a plusieurs types numériques, les plus couramment utilisés pour les nombres sont int (pour les nombres entiers) et double pour les nombres à virgule flottante. Cependant, nous passerons en revue chacun en détail au fur et à mesure de votre lecture.

Types entiers

Octet

De -128 à 127, le type de données byte peut contenir des valeurs entières. Lorsque vous savez que la valeur sera comprise entre -128 et 127, vous pouvez l'utiliser à la place de int ou d'autres types d'entiers pour économiser de la mémoire :

byte numVal = 113;
System.out.println(numVal);

Court

Les nombres complets -32768 à 32767 peuvent être stockés dans le type de données court :

short numVal = 4389;
System.out.println(numVal);

Entier

Les nombres entiers entre -2147483648 et 2147483647 peuvent être stockés dans le type de données int. Par conséquent, lors de la création de variables avec une valeur numérique, le type de données int est le type de données idéal en général.

int numVal = 100000;
System.out.println(numVal);

Longue

De -9223372036854775808 à 9223372036854775807, le type de données long peut stocker des nombres entiers. Lorsque int est insuffisant pour stocker la valeur, ceci est utilisé. Il est important de noter que la valeur doit se terminer par un "L":

long numVal = 15000000000L;
System.out.println(numVal);

Types de virgules flottantes

Il serait préférable d'utiliser un type à virgule flottante lorsque vous avez besoin d'un nombre décimal, tel que 9,99 ou 3,14515.

Flottant

Les nombres fractionnaires entre 3.4e-038 et 3.4e+038 peuvent être stockés à l'aide du type de données float. Il est important de noter que la valeur doit se terminer par un "f":

float floatVal = 6.85f;
System.out.println(floatVal);

Double

Les nombres fractionnaires entre 1,7e-308 et 1,7e+308 peuvent être stockés dans le type de données double. Il est important de noter que la valeur doit se terminer par un "d":

Vaut-il mieux utiliser float ou double ?

La précision d'une valeur à virgule flottante est le nombre de chiffres suivant la virgule décimale que la valeur peut avoir. La précision des variables flottantes n'est que de six ou sept chiffres décimaux, mais la précision des variables doubles est d'environ 15 chiffres.
Par conséquent, il est plus sûr d'utiliser le double pour la plupart des calculs.

Les chiffres en sciences

Un nombre scientifique avec un "e" pour représenter la puissance de dix peut aussi être un nombre à virgule flottante :

float floatVal = 35e3f;
double doubleVal = 12E4d;
System.out.println(floatVal);
System.out.println(doubleVal);

Booléens

Le mot-clé booléen permet de spécifier un type de données booléen, qui ne peut prendre que les valeurs vrai ou faux :

boolean isCodeUnderscoredLegit = true;
boolean isCodeEasy = false;
System.out.println(isCodeUnderscoredLegit); // Outputs true
System.out.println(isCodeEasy); // Outputs false

Les tests conditionnels utilisent largement les valeurs booléennes, sur lesquelles vous en apprendrez plus plus tard.

Personnages

Un seul caractère est stocké dans le type de données char.
Des guillemets simples, tels que "Z" ou "b", doivent entourer le caractère :

char studentScore = 'A';
System.out.println(studentScore);

Vous pouvez également utiliser des valeurs ASCII pour afficher des caractères spécifiques :

char myVar1 = 65, myVar2 = 66, myVar3 = 67;
System.out.println(myVar1);
System.out.println(myVar2);
System.out.println(myVar3);

La référence de table ASCII contient une liste complète de toutes les valeurs ASCII.

Chaînes

Une séquence de caractères est stockée à l'aide du type de données String (texte). En outre, utilisez des guillemets doubles pour entourer les valeurs de chaîne :

String helloCode = "Hello Codeunderscored";
System.out.println(helloCode);

Étant donné que le type String est si largement utilisé et intégré à Java, il est parfois appelé "le neuvième type spécial".

Ne vous inquiétez pas si vous n'êtes pas familier avec le terme "objet". Il se rapporte à un objet, une chaîne en Java est un type de données non primitif. Les méthodes de l'objet String sont utilisées pour exécuter diverses opérations sur les chaînes.

Types de données non primitives

Parce qu'ils font référence à des objets, les types de données non primitifs sont appelés types de référence. Voici les distinctions fondamentales entre les types de données primitifs et non primitifs :

• En Java, les types primitifs sont prédéfinis (c'est-à-dire qu'ils ont déjà été déclarés). Java ne spécifie pas les types non primitifs, que le programmeur construit à l'exception de string.
• Les types non primitifs, en revanche, peuvent être utilisés pour appeler des méthodes qui effectuent des actions spécifiques, contrairement aux types primitifs.
• Les types non primitifs peuvent être nuls, alors que les types primitifs ont toujours une valeur.
• Une lettre minuscule commence par un type primitif, tandis qu'une lettre majuscule commence par un type non primitif.
• La taille d'un type primitif est déterminée par le type de données, alors que les types non primitifs ont tous la même taille.

Les chaînes, les tableaux, les classes, les interfaces et d'autres types non primitifs en sont des exemples.

Interfaces

Les interfaces sont une autre approche pour implémenter l'abstraction en Java. Une interface est une "classe abstraite" utilisée pour assembler des fonctions liées avec des corps vides :

// interface
interface Human {
  public void humanSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

L'interface doit être "implémentée" (un peu comme héritée) par une autre classe avec le mot clé implements pour accéder aux fonctions d'interface (au lieu d'extends). La classe "implémenter" fournit le corps de la méthode d'interface :

// Interface
interface Human {
  public void humanSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Lady "implements" the Human interface
class Lady implements Human {
  public void humanSound() {
    // The body of humanSound() is provided here
    System.out.println("The lady screams: wee wee");
  }
  public void sleep() {
    // The body 's sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Lady theLady = new Lady();  // Create a Lady object
    theLady.humanSound();
    theLady.sleep();
  }
}

Remarques sur l'interface

Les interfaces, comme les classes abstraites, ne peuvent pas être utilisées pour construire des objets. Par exemple, dans l'exemple ci-dessus, il n'est pas possible de créer un objet "Humain" dans MyMainClass.

La classe "implémenter" fournit le corps des méthodes d'interface qui n'en ont pas. Cela aiderait à remplacer toutes les méthodes d'une interface lors de sa mise en œuvre. Par défaut, les méthodes d'interface sont abstraites et publiques. De plus, par défaut, les attributs d'interface sont public, static et final. Un constructeur n'est pas non plus autorisé dans une interface car il ne peut pas créer d'objets.

Quand devez-vous utiliser les interfaces ?

1) Pour augmenter la sécurité, masquez certaines informations et n'affichez que les aspects les plus critiques d'un objet (interface).

2) "L'héritage multiple" n'est pas pris en charge en Java (une classe ne peut hériter que d'une superclasse).
Cependant, comme la classe peut implémenter de nombreuses interfaces, cela peut être fait avec des interfaces.
Remarque :Pour utiliser plusieurs interfaces, utilisez une virgule pour les séparer (voir exemple ci-dessous).

interface InterfaceOne {
  public void interfaceOneMethod(); // interface method
}

interface InterfaceTwo {
  public void interfaceTwoMethod(); // interface method
}

// InterfaceClass "implements" InterfaceOne and  InterfaceTwo
class InterfaceClass implements InterfaceOne, InterfaceTwo {
  public void interfaceOneMethod() {
    System.out.println("Some text..");
  }
  public void interfaceTwoMethod() {
    System.out.println("Some other text...");
  }
}

class Main {
  public static void main(String[] args) {
    InterfaceClass theObj = new InterfaceClass();
    theObj.interfaceOneMethod ();
    theObj.interfaceTwoMethod ();
  }
}

Objets et classes Java

L'objectif principal de Java en tant que langage informatique est les objets.

En Java, tout est lié aux classes et aux objets et à leurs caractéristiques et méthodes.
Un ordinateur, par exemple, est un objet dans la vie réelle. L'ordinateur a des caractéristiques comme le poids et la couleur et des procédures comme le démarrage et l'arrêt.

Une classe fonctionne de la même manière qu'un constructeur d'objet ou un "plan" pour construire des choses.

Créer une classe

Utilisez le terme classe pour créer une classe :

# Main.java
# Creation of a class named "Main" with a variable a:

public class Main {
  int a = 20;
}

Rappelez-vous des concepts de la syntaxe Java qu'une classe doit toujours commencer par une lettre majuscule et que le nom du fichier Java doit être le même que le nom de la classe.

Créer un nouvel objet

Une classe en Java est utilisée pour construire un objet. Nous avons déjà créé la classe Main, nous pouvons donc maintenant créer des objets. Pour créer un objet Main, saisissez le nom de la classe, puis le nom de l'objet, suivi du mot-clé new :

Exemple :Créez un objet "theObj" et imprimez la valeur de a :

public class Main {
  int a = 20;

  public static void main(String[] args) {
    Main theObj = new Main();
    System.out.println(theObj.a);
  }
}

Objets en Multiples

Vous pouvez créer plusieurs objets du même type :

public class Main {
  int a = 20;

  public static void main(String[] args) {
    Main theOneObj = new Main();  // Object 1
    Main theTwoObj = new Main();  // Object 2
    System.out.println(theOneObj.a);
    System.out.println(theTwoObj.a);
  }
}

Exemple :créer deux objets principaux à l'aide de plusieurs classes

Vous pouvez également créer un objet de classe et l'utiliser dans une classe différente. Il est fréquemment utilisé pour organiser les classes (une classe contient toutes les propriétés et méthodes, tandis que l'autre a la fonction main() (code à exécuter)).

Gardez à l'esprit que le fichier java doit avoir le même nom que la classe. Nous avons créé deux fichiers dans le même répertoire/dossier dans cet exemple :

// Main.java

public class Main {
int a = 5;
}

// Second.java

class Second {
  public static void main(String[] args) {
    Main theObj = new Main();
    System.out.println(theObj.a);
  }
}

javac Main.java
javac Second.java

Lorsque vous aurez terminé de compiler les deux fichiers, vous pourrez régler le fichier Second.java comme suit :

java Second.java

Tableaux en Java

Les tableaux stockent de nombreuses valeurs dans une seule variable au lieu de définir des variables distinctes pour chaque élément. Pour déclarer un tableau, utilisez des crochets pour déterminer le type de la variable :

String[] computers;

Nous avons maintenant déclaré une variable qui contiendra un tableau de chaînes. De plus, nous pouvons utiliser un tableau littéral pour lui ajouter des valeurs en plaçant les éléments dans une liste séparée par des virgules à l'intérieur d'accolades :

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};

Vous pouvez créer un tableau d'entiers comme suit.

int[] numVal = {30, 40, 50, 60};

Accès aux éléments d'un tableau

Le numéro d'index est utilisé pour accéder à un élément du tableau. Dans le tableau de l'ordinateur ci-dessus, cette instruction obtient la valeur du premier élément :

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
System.out.println(computers[0]);
// Outputs HP

Notez que les index de tableau commencent à 0. Par conséquent, le premier élément est [0]. Le deuxième élément est [1], et ainsi de suite.

Apporter une modification à un élément de tableau

Reportez-vous au numéro d'index pour modifier la valeur d'un certain élément :

computers[0] = "IBM";

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
computers[0] = "IBM";
System.out.println(computers[0]);
// Now outputs IBM instead of HP

Longueur du tableau

L'établissement de la longueur d'un tableau est un aspect de la propriété length dans un tableau :

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
System.out.println(computers.length);
// Outputs 4

Itérer sur un tableau

La boucle for peut être utilisée pour parcourir les éléments du tableau, et la propriété length peut être utilisée pour déterminer combien de fois la boucle doit s'exécuter. Tous les éléments du tableau de l'ordinateur sont générés dans l'exemple suivant :

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
int i =0;
for (i; i < computers.length; i++) {
  System.out.println(computers[i]);
}

De plus, avec For-Each, vous pouvez parcourir un tableau. Il existe également une boucle "for-each", qui n'est utilisée que pour parcourir les éléments du tableau :

Syntaxe

for (type variable : arrayname) {
  ...
}

À l'aide d'une boucle "for-each", l'exemple suivant imprime tous les membres du tableau de véhicules :

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
for (String i : computers) {
  System.out.println(i);
}

Vous comprendrez peut-être l'exemple précédent lorsque nous le décomposons comme suit :imprimez la valeur de i pour chaque élément String (appelé i - comme dans index) dans les ordinateurs. En comparant la boucle for et la boucle for-each, vous remarquerez que la technique est plus facile à coder, ne nécessite aucun compteur (car elle utilise la propriété length) et est plus lisible.

Tableaux à plusieurs dimensions

Un tableau de tableaux est un tableau multidimensionnel. Ajoutez chaque tableau dans son propre ensemble d'accolades pour créer un tableau à deux dimensions :

int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };

numVals est maintenant un tableau qui contient deux tableaux en tant qu'éléments. Pour accéder aux éléments du tableau numVals, vous aurez besoin de deux index :un pour le tableau et un pour chaque élément qu'il contient. Cet exemple utilise le troisième membre (2) du deuxième tableau (1) de numVals :

int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };
int a = numVals[1][2];
System.out.println(a); // Outputs 7

Pour acquérir les éléments d'un tableau à deux dimensions, nous pouvons utiliser une boucle for à l'intérieur d'une autre boucle for bien que nous ayons toujours besoin de pointer vers les deux index :

public class Main {
  public static void main(String[] args) {
    int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };
    for (int i = 0; i < numVals.length; ++i) {
      for(int j = 0; j < numVals[i].length; ++j) {
        System.out.println(numVals[i][j]);
      }
    }
  }
}

Chaînes en Java

Le texte est stocké à l'aide de chaînes. Une variable String est composée d'un groupe de caractères entourés de guillemets :

Exemple :Créez une variable String avec la valeur suivante :

String greeting = "Codeunderscored";

Longueur de la chaîne

Une chaîne en Java est un objet qui comprend des méthodes qui peuvent effectuer des actions spécifiques sur des chaînes. Par exemple, la longueur d'une chaîne peut être obtenue avec la méthode length() :

String txtVal = "Codeunderscored";
System.out.println("The length of the text string is: " + txtVal.length());

Méthodes de chaîne supplémentaires

Il existe de nombreuses fonctions de chaîne, telles que toUpperCase() et toLowerCase() :

String txtVal = "Code underscored";
System.out.println(txtVal .toUpperCase()); // Outputs "CODE UNDERSCORED"
System.out.println(txtVal .toLowerCase()); // Outputs "code underscored"

Trouver un caractère dans une chaîne est une tâche difficile. La méthode indexOf() récupère la première occurrence d'un texte fourni dans une chaîne (y compris les espaces) :

String txtVal = "Please find where 'locate' occurs!";
System.out.println(txtVal .indexOf("find")); // Outputs

Java commence à compter à zéro. 0 est la première place dans une chaîne, 1 est la deuxième et deux est la troisième.

Concaténation de chaînes

L'opérateur + est chargé de joindre deux chaînes ensemble. C'est ce qu'on appelle la concaténation :

String prefixName = "Code";
String suffixName = "underscored";
System.out.println( prefixName + " " + suffixName);

Pour faire un espace entre firstName et lastName à l'impression, nous avons placé un texte vide (" ") entre eux. Vous pouvez également concaténer deux chaînes avec la méthode concat() :

String prefixName = "Code";
String suffixName = "underscored";
System.out.println(prefixName .concat(suffixName));

Personnages aux qualités uniques

Étant donné que les chaînes doivent être entre guillemets, Java interprétera mal cette chaîne et générera l'erreur suivante :

String txtVal = "Codeunderscored are the "Vikings" from the web.";

Le caractère d'échappement antislash est un excellent moyen d'éviter ce problème. Les caractères spéciaux sont convertis en caractères de chaîne à l'aide du caractère d'échappement barre oblique inverse (). De plus, en Java, il existe plus de six séquences d'échappement valides comme suit :

Caractère d'échappement	Résultat	Description
\’	‘	Avis simples
\”	“	Avis double
\\		Barre oblique inverse
\n		Nouvelle ligne
\r		Retour chariot
\t		Onglet
\b		Retour arrière
\f		Saut de formulaire

Dans une chaîne, la séquence \" insère un guillemet double :

String txt = "We are the so-called \"Vikings\" from the north.";

Dans une chaîne, la séquence \' insère une apostrophe :

String txt = "It\'s alright.";

La séquence suivante \ ajoute une seule barre oblique inverse à une chaîne :

String txt = "The character \ is called backslash.";

Ajouter des chaînes et des nombres

L'opérateur + est utilisé en Java pour l'addition et la concaténation.

• Des nombres sont ajoutés à l'équation.
• Les chaînes sont jointes.

Lorsque deux nombres sont additionnés, le résultat est un nombre :

int a = 50;
int b = 30;
int c = a + b; // c will be 80 (an integer/number)

La combinaison de deux chaînes conduit à une concaténation de chaînes :

String a = "50";
String b = "30";
String c = a + b; // c will be 5030 (a String)

En combinant un nombre et une chaîne, vous obtenez une concaténation de chaînes :

String a = "50";
int b = 30;
String c = a + b; // c will be 5030 (a String)

Conclusion

La base la plus cruciale de tout langage informatique est ses types de données. C'est la notion la plus vitale pour tout nouveau venu. Le type de données est requis pour exprimer le type, la nature et l'ensemble des opérations associées à la valeur qu'il stocke.

Les types de données Java sont incroyablement fondamentaux. C'est la première chose que vous devez apprendre avant de passer à d'autres concepts Java.