Inhaltsverzeichnis
- Primitives Typ und Referenz-Typ im Java
- Wie wird das primitive Typ in der Speicherung archiviert?
- Wie wird das Referenz-Typ in der Speicherung archiviert
- Das Typ vom Vergleich im Java
- Der Vergleich der primitiven Type
- Der Vergleich zwischen die Referenz
- Zum Beispiel: ein Array vom String aufgliedern
- Die Objekte können miteinander verglichen werden (vergleichbar -Comparable)
- Eine Liste sortieren (List)
- Die Benutzung eines Vergleicher (Comparator) sortieren
Vergleichen und Sortieren in Java
View more Tutorials:
- Primitives Typ und Referenz-Typ im Java
- Wie wird das primitive Typ in der Speicherung archiviert?
- Wie wird das Referenz-Typ in der Speicherung archiviert
- Das Typ vom Vergleich im Java
- Der Vergleich der primitiven Type
- Der Vergleich zwischen die Referenz
- Zum Beispiel: ein Array vom String aufgliedern
- Die Objekte können miteinander verglichen werden (vergleichbar -Comparable)
- Eine Liste sortieren (List)
- Die Benutzung eines Vergleicher (Comparator) sortieren

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
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
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
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
Im Java gibt es 2 Vergleich:
Operator equals(..) ist eine Methode für die Reference type
- Operator == benutzen
- Methode (method) equals(..) benutzen
Operator equals(..) ist eine Methode für die Reference 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);

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

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

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

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

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