Comparer et trier en Java

View more Tutorials:

1- Le type primitif et le type de référence en Java

Tout d'abord, nous devons différencier le type Primitif (Primitive type) et le type de référence (reference type) en Java.
En Java, il existe 8 types primitifs.
  • Type primitif (Primitive type)
Type Bit/Bytes Range
boolean 1 bit True or False
char 16 bit/ 2 bytes 0 to 65535
byte 8 bit/ 1 byte -128 to 127
short 16 bit/ 2 bytes -32768 to 32767
int 32 bits/ 4 bytes -2147483648 to 2147483647
long 64 bits/ 8 bytes -9,223,372,036,854,775,808 to -9,223,372,036,854,775,808
(-2^63 to -2^63)
float 32 bits/ 4 bytes -3.4028235 x 10^38 to 3.4028235 x 10^38
double 64 bits/ 8 bytes -1.7976931348623157 x 10^308 to 1.7976931348623157 x 10^308
Tous les autres types sont étendus depuis Object, ce sont des types de référence.

2- Où sont les types primitifs stockés dans la mémoire

Tout d'abord, Java ne garantit pas vraiment que les variables correspondent aux emplacements de mémoire; par exemple, votre méthode pourrait être optimisée de telle sorte que «i» soit stocké dans un registre (register) ou peut-être même pas être stocké du tout, si le compilateur peut voir que vous n'utilisez jamais sa valeur, ou s'il peut parcourir le code et utiliser les valeurs appropriées directement.
Voir un extrait de code:
// Créez une variable 'a', et attribuez-lui une valeur 100.
int a = 100;

// Attribuez une nouvelle valeur à la variable 'a'
a = 200;

// Créez la variable 'b', attribuez b = a.
int b = a;
Java prend les mesures suivantes:
  • TODO

3- Où sont les types de référence stockés dans la mémoire

Lors que vous utilisez l'opérateur new (Par exemple new Object()), Java va créer une nouvelle entité dans la mémoire. Vous déclarez une variable et initialisez sa valeur via l'opérateur new, telle que Object a = new Object(); Java créera une nouvelle entité dans la mémoire et un point de référence dans la location de la mémoire de nouvelle entité qui vient d'être créée.

Lors que vous déclarez une variable b Object b = a;  il n'y a aucune entité qui a été créée en mémoire, Java crée seulement une référence 'b', pointe vers le même endroit où 'a' pointe.
// Déclarez et initialisez un objet.
Object a =  new Object();

// Attribuez une nouvelle valeur à l'objet 'a'.
a = new String("Text");

// Déclarez l'objet 'b', et attribuez-lui 'a'.
Object b =  a;
  • TODO

4- Les types de comparaison en Java

En Java, il existe 2 types de comparaison:
  • L'utilisation l'opérateur ==
  • L'utilisation la méthode (method)
    equals(..)

​​​​​​​
 L'opérateur == est utilisé pour comparer les types primitifs et les types de référence.
L'opérateur equals(..) est la méthode qui est seulement utilisée pour les types de référence.

5- Comparaison des types primitifs

Avec le type primitif, nous avons seulement une facon de comparer par l'utilisation l'opérateur ==, les types primitifs comparent entre eux via ses valeurs.
// Créez une variable 'a', attribuez- lui une valeur de 200.
// Une zone de mémoire (1) est créée qui contient la valeur de 200.
int a = 200;

// Créez une variable 'b', attribuez- lui une valeur de 200.
// Une zone de mémoire (2) est créée qui contient la valeur de 200.
int b = 200;

// Bien que 'a' et 'b' indiquent deux zones de mémoire différentes.
// La comparaison a == b renvoie le résultat true.
// Parce que les types primitifs sont comparés les uns aux autres en fonction de leur valeur.
boolean c = (a == b);

6- Comparaison les types de référence

6.1- L'utilisation l'opérateur == pour comparer des types de référence

Lorsque vous comparez deux références d'objet en utilisant l'opérateur ==, c'est-à-dire la comparaison de la position sur laquelle appartiennent 2 références d'objet. Essentiellement, il est de vérifier si les deux référence d'objet  indiquent la même entité sur la mémoire ou non.
Voir l'exemple ci- dessous:
ReferenceEeDemo.java
package org.o7planning.tutorial.comparation;

public class ReferenceEeDemo {

	public static void main(String[] args) {

		// REMARQUE: pour String, deux façons d'initialiser l'objet ci-dessous ne sont pas les mêmes:
		String str1 = "String 1";
		String str2 = new String("String 1");

		// L'opérateur 'new' crée la zone de mémoire (1)
		// contient la chaîne (String) "This is text"
		// Et 's1' est une référence qui pointe vers la zone (1).
		String s1 = new String("This is text");

		// L'opérateur 'new' crée la zone de mémoire (2)
		// Contient la chaîne (String) "This is text"
		// Et 's2' est une référence qui pointe vers la zone (2)
		String s2 = new String("This is text");

		// Utilisez l'opérateur == pour comparer 's1' et 's2'.
		// Les résultats sont faux (false).
		// Il est évidemment différent de ce que vous pensez.
		// La raison en est le type de référence
		// L'opérateur == compare les positions auxquelles ils indiquent.
		boolean e1 = (s1 == s2); // false

		System.out.println("s1 == s2 ? " + e1);

		// Il n'y a aucun opérateur 'new'.
		// Java crée une référence appelée 'obj'
		// Et pointant vers une zone de mémoire sur laquelle 's1' indique.
		Object obj = s1;

		// 2 référence 'obj' et 's1'  indiquent toutes une zone de mémoire.
		// Le résultat renvoie vrai (true).
		boolean e2 = (obj == s1); // true

		System.out.println("obj == s1 ? " + e2);
	}
	
}
Résultats de l'exécution de l'exemple:

6.2- L'utilisation l'opérateur equals(..) pour comparer des types de référence

StringComparationDemo.java
package org.o7planning.tutorial.comparation;

public class StringComparationDemo {

	public static void main(String[] args) {

		String s1 = new String("This is text");

		String s2 = new String("This is text");

		// s1 and s2 Comparison, use equals(..)
		boolean e1 = s1.equals(s2);

		// The result is true
		System.out.println("first comparation: s1 equals s2 ? " + e1);

		s2 = new String("New s2 text");

		boolean e2 = s1.equals(s2);

		// The result is false
		System.out.println("second comparation: s1 equals s2 ? " + e2);
	}

}
Résultats de l'exécution de l'exemple:

6.3- Remplace la méthode equals(Object)

La méthode  equals(Object) est une méthode disponible dans la classe  Object, toutes les sous-classes sont héritées de cette méthode. Dans certaines situations, vous pouvez remplacer cette méthode dans les sous-classes.
NumberOfMedals.java
package org.o7planning.tutorial.comparation.equals;

// Le nombre de médailles.
public class NumberOfMedals {

	// Le nombre de médailles d'or
	private int goldCount;

	// Le nombre de médailles d'argent.
	private int silverCount;

	// Le nombre de médailles de bronze
	private int bronzeCount;

	public NumberOfMedals(int goldCount, int silverCount, int bronzeCount) {
		this.goldCount = goldCount;
		this.silverCount = silverCount;
		this.bronzeCount = bronzeCount;
	}

	public int getGoldCount() {
		return goldCount;
	}

	public int getSilverCount() {
		return silverCount;
	}

	public int getBronzeCount() {
		return bronzeCount;
	}

	// Remplacez la méthode equals(Object) de la classe Objet
	@Override
	public boolean equals(Object other) {
		// Si other = null, le résultat renvoie faux (false).
		if (other == null) {
			return false;
		}
		// Si 'other' n'est pas le type de NumberOfMedals
		// le résultat renvoie faux (false).
		if (!(other instanceof NumberOfMedals)) {
			return false;
		}

		NumberOfMedals otherNoM = (NumberOfMedals) other;

		if (this.goldCount == otherNoM.goldCount && this.silverCount == otherNoM.silverCount
				&& this.bronzeCount == otherNoM.bronzeCount) {
			return true;
		}
		return false;
	}

}
NumberOfMedalsComparationDemo.java
package org.o7planning.tutorial.comparation.equals;

public class NumberOfMedalsComparationDemo {

	public static void main(String[] args) {

		// La réussite de l'équipe américaine.
		NumberOfMedals american = new NumberOfMedals(40, 15, 15);

		// La réussite de l'équipe japonaise.
		NumberOfMedals japan = new NumberOfMedals(10, 5, 20);

		// La réussite de l'équipe sub- coréenne
		NumberOfMedals korea = new NumberOfMedals(10, 5, 20);

		System.out.println("Medals of American equals Japan ? " + american.equals(japan));

		System.out.println("Medals of Korea equals Japan ? " + korea.equals(japan));
	}

}
Résultats de l'exécution de l'exemple

7- Tri d'un tableau d'exemple de String (chaîne)

String est une classe que ses objets peuvent être comparés les uns avec les autres, selon les règles des lettres. L'exemple suivant illustre comment organiser le String à l'aide des méthodes d'utilité disponibles en Java.
StringArraySortingDemo.java
package org.o7planning.tutorial.sorting;

import java.util.Arrays;

public class StringArraySortingDemo {

	public static void main(String[] args) {
		String[] fruits = new String[] { "Pineapple", "Apple", "Orange", "Banana" };

		// Utilisez une méthode statique de la classe Arrays pour arranger.
		// Arrays.sort(Object[])
		Arrays.sort(fruits);

		for (int i = 0; i < fruits.length; i++) {
			System.out.println("fruits " + i + " : " + fruits[i]);
		}
	}

}
Résultats de l'exécutation de l'exemple:

8- Des objets peut être comparés entre eux (Comparable)

// Vous écrivez une classe qui simule un acteur (Actor).
// Vous souhaitez organiser l'ordre des acteurs selon le principe de:
// Comparer le nom de famille (lastName) d'abord, comparez le prénom (firstName).
public class Actor {

	// Le prénom
	private String firstName;
	// Le nom de la famille
	private String lastName;

}
Actor.java
package org.o7planning.tutorial.sorting;

// Pour comparer les uns avec les autres,
// la classe d'Actor doit implémenter une interface comparable.
public class Actor implements Comparable<Actor> {

	private String firstName;
	private String lastName;

	public Actor(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}

	// Comparez cet Actor avec un autre actor.
	// Selon le principe de comparaison du dernier nom d'abord,
	// puis comparez FirstName.
	@Override
	public int compareTo(Actor other) {

		// Comparez deux chaines.
		int value = this.lastName.compareTo(other.lastName);

		// Si lastName de deux objets ne sont pas égaux
		if (value != 0) {
			return value;
		}
		// Si lastName de deux objets sont le même.
		// Ensuite, comparez fistName.
		value = this.firstName.compareTo(other.firstName);
		return value;
	}

}
ActorSortingDemo.java
package org.o7planning.tutorial.sorting;

public class ActorSortingDemo {

	public static void main(String[] args) {

		Actor actor1 = new Actor("Mischa", "Barton");
		Actor actor2 = new Actor("Christian", "Bale");
		Actor actor3 = new Actor("Joan", "Collins");
		Actor actor4 = new Actor("Gemma", "Arterton");
		Actor actor5 = new Actor("Daniel", "Craig");

		Actor[] actors = new Actor[] { actor1, actor2, actor3, actor4, actor5 };

		// Utilisez un algorithme pour trier de nouveau tableau ci-dessus.
		// Triez les objets Actor en augmentant progressivement l'ordre.
		for (int i = 0; i < actors.length; i++) {

			for (int j = i + 1; j < actors.length; j++) {
				// Si actors[j] < actors[i]
				// Ensuite, échangez les positions les uns avec les autres.
				if (actors[j].compareTo(actors[i]) < 0) {
					// Utilisez une variable temporaire.
					Actor temp = actors[j];
					actors[j] = actors[i];
					actors[i] = temp;
				}
			}
		}
		// Imprimez les éléments du tableau.
		for (int i = 0; i < actors.length; i++) {
			System.out.println(actors[i].getFirstName() + "  " + actors[i].getLastName());
		}

	}

}
Résultats de l'exécution de l'exemple:
Utiliser  Arrays.sort(Object[]) ​​​​​​​pour trier la liste de l'exemple ci-dessus:  :
ActorSortingDemo2.java
package org.o7planning.tutorial.sorting;

import java.util.Arrays;

public class ActorSortingDemo2 {

	public static void main(String[] args) {

		Actor actor1 = new Actor("Mischa", "Barton");
		Actor actor2 = new Actor("Christian", "Bale");
		Actor actor3 = new Actor("Joan", "Collins");
		Actor actor4 = new Actor("Gemma", "Arterton");
		Actor actor5 = new Actor("Daniel", "Craig");

		Actor[] actors = new Actor[] { actor1, actor2, actor3, actor4, actor5 };

		// Utilisez Arrays.sort(Object[]) pour trier.
		Arrays.sort(actors);

		// Imprimez les éléments.
		for (int i = 0; i < actors.length; i++) {
			System.out.println(actors[i].getFirstName() + "  " + actors[i].getLastName());
		}

	}
}

9- Trier une liste (List)

Vous pouvez vous référer au tutoriel Java Collection Framework à l'adresse suivante:
Exemple:
ListSortingDemo.java
package org.o7planning.tutorial.sorting;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListSortingDemo {

	public static void main(String[] args) {

		Actor actor1 = new Actor("Mischa", "Barton");
		Actor actor2 = new Actor("Christian", "Bale");
		Actor actor3 = new Actor("Joan", "Collins");
		Actor actor4 = new Actor("Gemma", "Arterton");
		Actor actor5 = new Actor("Daniel", "Craig");

		// Une liste d'éléments comparables.
		// (Comparable)
		List<Actor> actors = new ArrayList<Actor>();

		actors.add(actor1);
		actors.add(actor2);
		actors.add(actor3);
		actors.add(actor4);
		actors.add(actor5);

		// Utilisez la méthode Collections.sort(List)
		// afin de trier une liste (List)
		Collections.sort(actors);

		for (Actor actor : actors) {
			System.out.println(actor.getFirstName() + "  " + actor.getLastName());
		}

	}

}

10- Trier par Comparateur (Comparator)

Dans les exemples ci-dessus, nous trimesons un tableau ou une liste, dont ses éléments sont capables de comparer les uns aux autres (parce qu'il implémente une interface Comparable). La question avec les classes qui n'implémente pas l'interface Comparable est que vous pouvez organiser ou non. Dans ce cas, vous devez fournir un comparateur ( Comparateur). C'est une règle pour organiser des objets.
Person.java
package org.o7planning.tutorial.comparator;

public class Person {

  private int age;
  private String fullName;

  public Person(String fullName, int age) {
      this.fullName = fullName;
      this.age = age;
  }

  public int getAge() {
      return age;
  }

  public String getFullName() {
      return fullName;
  }
}
PersonComparator.java
package org.o7planning.tutorial.comparator;

import java.util.Comparator;

// Cette classe implémente l'interface Comparateur <Person>
// Il peut être considéré comme la règle pour comparer les objets Person.
public class PersonComparator implements Comparator<Person> {

	// Remplacez (override) la méthode compare.
	// Spécifiez les règles de comparaison entre 2 objets Person.
	@Override
	public int compare(Person o1, Person o2) {
		// Si deux objets sont nuls, ils sont considérés comme égaux.
		if (o1 == null && o2 == null) {
			return 0;
		}
		// Si o1 est null, o2 est considéré plus grand.
		if (o1 == null) {
			return -1;
		}
		// Si o2 est null, o1 est considéré plus grand.
		if (o2 == null) {
			return 1;
		}
		// Principe:
		// Trier progressivement par rapport à l'âge.
		int value = o1.getAge() - o2.getAge();
		if (value != 0) {
			return value;
		}
		// Si l'âge est le même, comparez le nom complet (fullName).
		// Comparez par Alphabet( les lettres).
		value = o1.getFullName().compareTo(o2.getFullName());
		return value;
	}

}
ComparatorSortingDemo.java
package org.o7planning.tutorial.comparator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ComparatorSortingDemo {

	public static void main(String[] args) {
		Person person1 = new Person("Marry", 20);
		Person person2 = new Person("Tom", 21);
		Person person3 = new Person("Daniel", 21);
		Person person4 = new Person("Mischa", 18);
		Person person5 = new Person("Christian", 20);

		// Un tableau n'est pas trié.
		Person[] array = new Person[] { person1, person2, person3, person4, person5 };

		// Trier le tableau, utilisez: <T> Arrays.sort(T[],Comparator<? supers T>).
		// Et fournisssez un Comparator (un Comparateur).
		Arrays.sort(array, new PersonComparator());

		for (Person person : array) {
			System.out.println("Person: " + person.getAge() + " / " + person.getFullName());
		}

		System.out.println("------------------------");

		// Pour la liste:
		List<Person> list = new ArrayList<Person>();
		list.add(person1);
		list.add(person2);
		list.add(person3);
		list.add(person4);
		list.add(person5);

		// Trier le tableau, utilisez:
		// <T> Collections.sort(List<T>, Comparator<? supers T>).
		// Et fournissez un Comparator (un Comparateur).
		Collections.sort(list, new PersonComparator());

		for (Person person : list) {
			System.out.println("Person: " + person.getAge() + " / " + person.getFullName());
		}
	}

}
Résultats de l'exécution de l'exemple:

View more Tutorials: