Vergleichen und Sortieren in Java

// Die Variable 'a' erstellen und die Wert 100 zuweisen.
int a = 100;

// Die neue Wert für 'a' zuweisen
a = 200;

// Die Variable 'b' erstellen, b = a zuweisen.
int b = a;

// Das Objekt erklären und initialisieren.
Object a =  new Object();

// Die neue Wert für das Objekt 'a' zuweisen.
a = new String("Text");

// Das Objekt 'b' erklären und 'a' für es zuweisen
Object b =  a;

// Eine Variable  'a' erstellen, die Wert von 200 für es zuweisen.
// Ein Speicherungsraum (1) wird für die Enthaltung der Wert 100 erstellt.
int a = 200;

// Eine Variable 'b' erstellen, die Wert von 200 für es zuweisen
// Ein Speicherungsraum (2) wird für die Enthaltung der Wert 100 erstellt.
int b = 200;

// Obwohl 'a' und 'b' auf 2 unterschiedlichen Speicherungsraum zeigen.
// Das  Vergleichhen a == b gibt das Ergebnis true zurück.
// Denn der primitiven Vergleich basiert auf die Wert
boolean c = (a == b);

package org.o7planning.tutorial.comparation;

public class ReferenceEeDemo {

	public static void main(String[] args) {

		// Achtung: Mit String sind 2 folgende Maßnahme zur Objekt-Initialization nicht gleich:
		String str1 = "String 1";
		String str2 = new String("String 1");

		// Der Operator 'new' erstellt den Speicherungsraum (1), 
		// der String "This is text" enthaltet
		// Und 's1' ist ein Referenz nach den Raum (1).
		String s1 = new String("This is text");

		// Der Operator 'new' erstellt den Speicherungsraum (2), 
		// der String  "This is text" enthaltet 
		// Und 's2' ist ein Referenz nach dem Raum (2)
		String s2 = new String("This is text");

		// Den Operator == benutzen um 's1' und 's2' zu vergleichen.
		// Das Ergebnis ist false.
		// Es unterscheidet sich mit Ihrem Gedanken.
		// Der Grund liegt darin, mit dem Referenzstyp 
		// vergleicht der Operator == die Positionen in der Speicherung.
		boolean e1 = (s1 == s2); // false

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

		// Es gibt keinen Operator 'new'.
		// Java erstellt ein Referenz 'obj' und zeigt nach den Speicherungsraum, 
		// wonach 's1' gerade zeigt.
		Object obj = s1;

		// 2 Referenz 'obj' und 's1' zeigen nach den gleichen Speicherungsraum. 
		// Das Ergebnis ist 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");

		// Der Vergleich zwischen s1 und s2 durch die Methode equals(..)
		boolean e1 = s1.equals(s2);

		// Das Ergebnis ist true
		System.out.println("first comparation: s1 equals s2 ? " + e1);

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

		boolean e2 = s1.equals(s2);

		// Das Ergebnis ist false
		System.out.println("second comparation: s1 equals s2 ? " + e2);
	}

}

package org.o7planning.tutorial.comparation.equals;

// Die Anzahl von der Medaille
public class NumberOfMedals {

	// Die Anzahl von der Goldmedaille
	private int goldCount;

	// Die Anzahl von der Silvermedaille
	private int silverCount;

	// Die Anzahl von der Bronzemedaille
	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;
	}

	// Die Methode equals(Object) der Klasse Object überschreiben.
	@Override
	public boolean equals(Object other) {
		// Wenn other = null, gibt es false zurück.
		if (other == null) {
			return false;
		}
		// Wenn 'other' kein Typ von NumberOfMedals ist, gibt es false zurück.
		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) {

		// Die Leistung von der USA Mannschaft
		NumberOfMedals american = new NumberOfMedals(40, 15, 15);

		// Die Leistung von der Japan Mannschaft
		NumberOfMedals japan = new NumberOfMedals(10, 5, 20);

		// Die Leistung von der Korea Mannschaft
		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" };

		// Die static Methode von der Klasse Arrays benutzen um zu sortieren.
		// Arrays.sort(Object[])
		Arrays.sort(fruits);

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

}

// Sie schreiben eine Klasse zur Simulation eines Schauspieler  (Actor).
// Sie möchten die Reihenfolge der SchauspielerInnen nach dem folgenden Grundsatz anordnen:
// Den Familienname (lastName) zuerst und dann den Vorname (firstName) vergleichen 
public class Actor {

	// Der Vorname
	private String firstName;
	// Der Familienname
	private String lastName;

}

package org.o7planning.tutorial.sorting;

// Die Klasse Actor soll Interface Comparable implementieren um 
// miteinander zu vergleichen
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;
	}

	// Mit einem anderen Actor Objekt vergleichen
	// Nach dem Grundsatz vergleichen wir lastName zuerst, und dann firstName.
	@Override
	public int compareTo(Actor other) {

		// 2 String vergleichen.
		int value = this.lastName.compareTo(other.lastName);

		// Wenn lastName von 2 Objekte nicht gleich ist.
		if (value != 0) {
			return value;
		}
		// Wenn lastName von 2 Objekt gleich ist, vergleichen wir dann  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 };

		// Ein Algorithm benutzen um dem oben Array wieder anzuordnen. 
		// Die Objekt Actor steigend sortieren.
		for (int i = 0; i < actors.length; i++) {

			for (int j = i + 1; j < actors.length; j++) {
				// Wenn actors[j] < actors[i] ist, 
				// führen wir den Umtausch der Stelle voneinander durch.
				if (actors[j].compareTo(actors[i]) < 0) {
					// Eine vorläufige Variable benutzen.
					Actor temp = actors[j];
					actors[j] = actors[i];
					actors[i] = temp;
				}
			}
		}
		// Die Array-Elemente ausdrucken
		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 };

		// Arrays.sort(Object[]) zur Anordnung benutzen.
		Arrays.sort(actors);

		// Die Array-Elemente ausdrucken
		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");

		// Eine Liste von der miteinander vergleichbaren Elemente.
		// (Comparable)
		List<Actor> actors = new ArrayList<Actor>();

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

		// Die Methode Collections.sort(List) benutzen um eine Liste anzuordnen
		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;

// Die Klasse implementiert die Interface Comparator<Person>.
// Das ist eine Regel zum Vergleich der Objekte Person.
public class PersonComparator implements Comparator<Person> {

	// Die Methode compare überschreiben (override). 
	// Die Vergleichsregel von 2 Objekte Person bestimmen.
	@Override
	public int compare(Person o1, Person o2) {
		// Die 2 null Objekte sind gleich wahrgenommen
		if (o1 == null && o2 == null) {
			return 0;
		}
		// Wenn o1 null ist, ist o2 größer wahrgenommen
		if (o1 == null) {
			return -1;
		}
		// Wenn o2 null ist, ist o1 größer wahrgenommen
		if (o2 == null) {
			return 1;
		}
		// Die Regel: nach dem Alter steigend sortieren.
		int value = o1.getAge() - o2.getAge();
		if (value != 0) {
			return value;
		}
		// Wenn das Alter gleich ist, vergleichen wir den fullName.
		// nach dem Alphabet (die Buchstabe) vergleichen
		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);

		// Ein Array wird noch nicht sortiert
		Person[] array = new Person[] { person1, person2, person3, person4, person5 };

		// Bei der Arrayanordnung benutzen Sie  <T> Arrays.sort(T[],Comparator<? supers T>).
		// und bieten einen Comparator (der Vergleicher).
		Arrays.sort(array, new PersonComparator());

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

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

		// Für eine Liste:
		List<Person> list = new ArrayList<Person>();
		list.add(person1);
		list.add(person2);
		list.add(person3);
		list.add(person4);
		list.add(person5);

		// Bei der Listeanordnung benutzen Sie <T> Collections.sort(List<T>, Comparator<? supers T>).
		// und bieten einen Comparator (der Vergleicher).
		Collections.sort(list, new PersonComparator());

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

}