Das Vergleich und die Aufgliederung im Java

View more categories:

1- Primitives Typ und Referenz-Typ im Java

Wir sollen zum ersten den Unterschied zwischen Primitive type und reference type im Java machen.
Im Java haben wir 8 primitive type
  • 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
Alle anderen Typen werden aus Objekt ausgeweitert, sie sind die reference type

2- Wie wird das primitive Typ in der Speicherung archiviert?

Ersten sollen Sie verstehen, Java guarantiert nicht, dass jede Variable ein angemessene Position in Speicher liegt. Zum Beispiel: Java wird die Variale  'i'  in Register speichern oder sogar nirgendwo speichern wenn der Complier findet, dass Sie es nie benutzen oder es wird durch Code beobachtet
Sehen Sie ein Code
// 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;
Dann sind die Durchführungschritte von Java
  • TODO

3- Wie wird das Referenz-Typ in der Speicherung archiviert

Wenn Sie die Operator new ( z.B new Object()) benutzen, macht Java ein neues Objekt in Speicher. Sie melden eine Variable an und erstellen ihre Wert durch die Operator new, Zum Beispiel Object a = new Object(); Java wird dann ein neues Objekt in Speicher und eine Reference 'a', die die Position der neu erstellten Objekt Speicher zeigt

Wenn Sie eine Variable b   Object b = a;  kein Objekt wird in Speicher erstellt. Java macht ein Reference 'b' , die die Position so gleich wie die Position der Reference a zeigt
// 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;
  • TODO

4- Das Typ vom Vergleich im Java

Im Java gibt es 2 Vergleich:
  • Operator == benutzen
  • Methode (method) equals(..) benutzen
Operator == für das Vergleich der primitive type und reference type.
Operator equals(..) ist eine Methode für die Reference type

5- Der Vergleich der primitiven Type

Mit der primitive type haben wir nur das einzige Vergleich durch die Operator ==. Die primitive type sind miteinander durch ihre Wert verglichen
// 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);

6- Der Vergleich zwischen die Referenz

6.1- Den Operator == um die Referenztype zu vergleichen

Wenn Sie die 2 Reference Object durch die Operator == vergleichen,d.h Die Position von 2 Reference Object vergleichen. Aus die Wesen checken wir, ob die 2 Reference Type die gleiche Object in Speicher zeigen
Sehen Sie das unten Beispiel
ReferenceEeDemo.java
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);
	}
	
}
Das Ergebnis von dem Programm laufen

6.2- Benutzen Sie equals(..) um die Referenz-Typ zu vergleichen

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

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

}
Das Ergebnis

6.3- Die Methode equals(Object) überschreiben

Die Methode equals(Object) ist eine vorhandene Methode in class  Object, alle Tochterclass haben die Inheritance aus dieser Methode. In irgende Situation können Sie bei der Tochterclass die Method übreschreiben
NumberOfMedals.java
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;
	}

}
NumberOfMedalsComparationDemo.java
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));
	}

}
Das Ergebnis von Beispiel

7- Zum Beispiel: ein Array vom String aufgliedern

String ist eigentlich ein class, dass seine Objecte miteinander vergleichbar sind, nach der Buchstabenregelung. Das unten Beispiel stellt eine Anordnung einer Array String mit der im Java vorhandenen Methode dar 
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" };

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

}
Ergebnis von Beispiel

8- Die Objekte können miteinander verglichen werden (vergleichbar -Comparable)

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

}
Actor.java
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;
	}

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

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

	}

}
Ergebnis von Beispiel
Die Arrays.sort(Object[]) für die Anordnung des obengenannten Beispiel benutzen
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 };

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

	}
}

9- Eine Liste sortieren (List)

Sie können die mehr Unterlagen Java Collection Framework lesen bei :
Beispiel
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");

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

	}

}

10- Die Benutzung eines Vergleicher (Comparator) sortieren

Die obengenannten Beispiels stellen die Anordnung eines Array oder einer Liste. Die Elemente können miteinander vergleichbar sein (durch die Durchführung der interface Comparable). Eine Frage: Ob die Object, deren Class kein interface comparable durchführt, angeordnet werden können. In diesem Fall brauchen Sie ein Comparator haben, das ist  ein Grundsatz für die Anordnung dieser Objekt
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;

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

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

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

}
Ergebnis von Beispiel

View more categories: