Comparer et trier en Java

// 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;

// 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;

// 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);

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);
	}
	
}

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);
	}

}

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;
	}

}

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));
	}

}

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]);
		}
	}

}

// 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;

}

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;
	}

}

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());
		}

	}

}

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());
		}

	}
}

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());
		}

	}

}

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;
  }
}

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;
	}

}

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());
		}
	}

}