Java: Řazení - Historie editací

Spravce: Přidáno řazení standardních tříd Javy.

2018-01-23T07:40:52Z

Přidáno řazení standardních tříd Javy.

← Starší verze		Verze z 23. 1. 2018, 07:40
Řádka 4:		Řádka 4:


−	== Pro třídy ~~s přirozeným řazením~~ ==	+	== Standardní třídy Javy ==
		+	* Standardní třídy v Javě mají definované uspořádání prvků.
		+	* Pro jejich řazení tedy stačí použít:
		+	Collections.sort(kontejner);
		+	* Týká se například tříd <code>Integer</code>, <code>String</code>, <code>Date</code> a dalších tříd, kde existuje nějaké „standarní“ uspořádání prvků.
		+	* Prakticky je uspořádání realizováno implementací rozhraní <code>Comparable</code> viz dále.
		+
		+	<div class="Priklad">
		+	; Příklad
		+	java.text.DateFormat formatter = new java.text.SimpleDateFormat("yyyy-MM-dd");
		+	ArrayList<Date> dataUdalosti = new ArrayList<>();
		+	''...''
		+	try {
		+	dataUdalosti.add(formatter.parse("2018-01-22")); ''// Může nastat výjimka <code>ParseException</code>''
		+	dataUdalosti.add(formatter.parse("2017-12-31"));
		+	} catch (ParseException ex) { throw RuntimeException("Error in date: "+ex.getMessage() }
		+	dataUdalosti.add(new Date()); ''// Aktuální datum''
		+	Collections.sort(dataUdalosti);
		+	''// Seřadí prvky v kontejneru od nejstaršího data k nejnovějšímu.
		+	''...''
		+	for(Date datum : dataUdalosti) {
		+	System.out.println(datum);
		+	}
		+	</div>
		+
		+
		+	== <code>Comparable</code> — řadíme vlastní třídy ==
		+	* Pokud chceme řadit instance vlastní třídy, musíme Javě vysvětlit, jak mají být uspořádány.
	* Pokud je přirozené porovnávat instance třídy a je zřejmé, podle jakého kritéria porovnání probíhá (například srovnání čísel), pak u třídy implementujeme rozhraní: <code>Comparable<Trida></code>		* Pokud je přirozené porovnávat instance třídy a je zřejmé, podle jakého kritéria porovnání probíhá (například srovnání čísel), pak u třídy implementujeme rozhraní: <code>Comparable<Trida></code>
	* Rozhraní vyžaduje jedinou metodu: <code>int compareTo(druha Trida)</code>		* Rozhraní vyžaduje jedinou metodu: <code>int compareTo(druha Trida)</code>

Spravce: Oprava porovnání desetinných čísel u Comparatoru.

2017-11-13T08:00:11Z

Oprava porovnání desetinných čísel u Comparatoru.

← Starší verze		Verze z 13. 11. 2017, 08:00
Řádka 54:		Řádka 54:
	class AutoComparatorSpotreba implements Comparator<Auto> {		class AutoComparatorSpotreba implements Comparator<Auto> {
	public int compare(Auto a1, Auto a2) {		public int compare(Auto a1, Auto a2) {
−	~~return Math.truncate~~(a1~~.getSpotreba(~~) - ~~a2.getSpotreba~~());	+	if (a1 < a2) return -1;
		+	if (a1 > a2) return 1;
		+	return 0;
	}		}
	}		}

Spravce: /* Související stránky */ Přidán odkaz na stránku Java: Kontejnery

2016-01-21T14:06:57Z

Související stránky: Přidán odkaz na stránku Java: Kontejnery

← Starší verze		Verze z 21. 1. 2016, 14:06
Řádka 76:		Řádka 76:

	== Související stránky ==		== Související stránky ==
−	* [[Řadící algoritmy]]	+	* [[Řadící algoritmy]], [[Java: Kontejnery]]

Spravce: Stránka Java: Řazení a vyhledávání přemístěna na stránku Java: Řazení

2014-12-09T10:31:57Z

Stránka Java: Řazení a vyhledávání přemístěna na stránku Java: Řazení

← Starší verze

Verze z 9. 12. 2014, 10:31

Spravce: /* Pro třídy, kde je více možných kritérií řazení */ Oprava vzhledu

2014-12-09T10:26:44Z

Pro třídy, kde je více možných kritérií řazení: Oprava vzhledu

← Starší verze		Verze z 9. 12. 2014, 10:26
Řádka 67:		Řádka 67:
	Collections.sort(auta, new AutoHmotnostComparator());		Collections.sort(auta, new AutoHmotnostComparator());
	* Lze vytvořit také anonymní třídu pro porovnání (komparátor):		* Lze vytvořit také anonymní třídu pro porovnání (komparátor):
−	Collections.sort(auta, new Comparator<Auto>() { public int compare(Auto a1, Auto a2) { ~~return~~ ... } } );	+	Collections.sort(
		+	auta,
		+	new Comparator<Auto>() {
		+	public int compare(Auto a1, Auto a2) {
		+	return ...
		+	}
		+	});

	== Související stránky ==		== Související stránky ==
	* [[Řadící algoritmy]]		* [[Řadící algoritmy]]

Spravce: /* Pro třídy, kde je více možných kritérií řazení */ Oprava vzhledu

2014-12-09T10:24:32Z

Pro třídy, kde je více možných kritérií řazení: Oprava vzhledu

← Starší verze		Verze z 9. 12. 2014, 10:24
Řádka 40:		Řádka 40:

	public int getCena() { return this.cena; }		public int getCena() { return this.cena; }
−	public double getSpotreba() { return this.spotreba; }	+	public double getSpotreba() {
		+	return this.spotreba;
		+	}
	public String getNazev() { return this.nazev; }		public String getNazev() { return this.nazev; }
	}		}

	class AutoComparatorCena implements Comparator<Auto> {		class AutoComparatorCena implements Comparator<Auto> {
−	public int compare(Auto a1, Auto a2) { return a1.getCena() - a2.getCena(); }	+	public int compare(Auto a1, Auto a2) {
		+	return a1.getCena() - a2.getCena();
		+	}
	}		}

	class AutoComparatorSpotreba implements Comparator<Auto> {		class AutoComparatorSpotreba implements Comparator<Auto> {
−	public int compare(Auto a1, Auto a2) { return Math.truncate(a1.getSpotreba() - a2.getSpotreba()); }	+	public int compare(Auto a1, Auto a2) {
		+	return Math.truncate(a1.getSpotreba() - a2.getSpotreba());
		+	}
	}		}

	class AutoComparatorNazev implements Comparator<Auto> {		class AutoComparatorNazev implements Comparator<Auto> {
−	public int compare(Auto a1, Auto a2) { return a1.getNazev().compareTo(a2.getNazev()); }	+	public int compare(Auto a1, Auto a2) {
		+	return a1.getNazev().compareTo(a2.getNazev());
		+	}
	}		}
	</div>		</div>
Řádka 59:		Řádka 67:
	Collections.sort(auta, new AutoHmotnostComparator());		Collections.sort(auta, new AutoHmotnostComparator());
	* Lze vytvořit také anonymní třídu pro porovnání (komparátor):		* Lze vytvořit také anonymní třídu pro porovnání (komparátor):
−	Collections.sort(auta, new Comparator&~~ltAuto~~>() { public int compare(Auto a1, Auto a2) { return ... } } );	+	Collections.sort(auta, new Comparator<Auto>() { public int compare(Auto a1, Auto a2) { return ... } } );

	== Související stránky ==		== Související stránky ==
	* [[Řadící algoritmy]]		* [[Řadící algoritmy]]

Spravce: /* Pro třídy, kde je více možných kritérií řazení */ Oprava vzhledu

2014-12-09T10:19:44Z

Pro třídy, kde je více možných kritérií řazení: Oprava vzhledu

← Starší verze		Verze z 9. 12. 2014, 10:19
Řádka 38:		Řádka 38:
	private double spotreba;		private double spotreba;
	private String nazev;		private String nazev;
−		+
	public int getCena() { return this.cena; }		public int getCena() { return this.cena; }
	public double getSpotreba() { return this.spotreba; }		public double getSpotreba() { return this.spotreba; }
Řádka 60:		Řádka 60:
	* Lze vytvořit také anonymní třídu pro porovnání (komparátor):		* Lze vytvořit také anonymní třídu pro porovnání (komparátor):
	Collections.sort(auta, new Comparator&ltAuto>() { public int compare(Auto a1, Auto a2) { return ... } } );		Collections.sort(auta, new Comparator&ltAuto>() { public int compare(Auto a1, Auto a2) { return ... } } );
−

	== Související stránky ==		== Související stránky ==
	* [[Řadící algoritmy]]		* [[Řadící algoritmy]]

Spravce: /* Pro třídy s přirozeným řazením */ Oprava vzhledu

2014-12-09T10:16:35Z

Pro třídy s přirozeným řazením: Oprava vzhledu

← Starší verze		Verze z 9. 12. 2014, 10:16
Řádka 14:		Řádka 14:
	public class Mince implements Comparable<Mince> {		public class Mince implements Comparable<Mince> {
	private int hodnota;		private int hodnota;
−		+
	public int compareTo(Mince druhaMince) {		public int compareTo(Mince druhaMince) {
	return this.hodnota - druhaMince.hodnota;		return this.hodnota - druhaMince.hodnota;

Spravce: Odkaz na související, poznámka, že některé třídy mají Comparable implementované

2014-12-09T10:12:08Z

Odkaz na související, poznámka, že některé třídy mají Comparable implementované

← Starší verze		Verze z 9. 12. 2014, 10:12
Řádka 1:		Řádka 1:
	[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]]		[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]]
		+
		+	<div class="Poznamka">Řadícími algoritmy, jejich principem a vlastnostmi se zabývá stránka [[Řadící algoritmy]].</div>
		+

	== Pro třídy s přirozeným řazením ==		== Pro třídy s přirozeným řazením ==
Řádka 20:		Řádka 23:
	ArrayList<Mince> mince = new Array...		ArrayList<Mince> mince = new Array...
	Collections.sort(mince);		Collections.sort(mince);
		+
		+	<div class="Poznamka">
		+	Některé třídy Javy už mají rozhraní <code>Comparable</code> implementované. Pak je můžeme řadit přímo: <code>Collections.sort(cisla);</code>.
		+
		+	Příkladem takové třídy jsou objektové číselné typy jako <code>Integer</code>.
		+	</div>

	== Pro třídy, kde je více možných kritérií řazení ==		== Pro třídy, kde je více možných kritérií řazení ==
Řádka 51:		Řádka 60:
	* Lze vytvořit také anonymní třídu pro porovnání (komparátor):		* Lze vytvořit také anonymní třídu pro porovnání (komparátor):
	Collections.sort(auta, new Comparator&ltAuto>() { public int compare(Auto a1, Auto a2) { return ... } } );		Collections.sort(auta, new Comparator&ltAuto>() { public int compare(Auto a1, Auto a2) { return ... } } );
		+
		+
		+	== Související stránky ==
		+	* [[Řadící algoritmy]]

Spravce: Vytvoření stránky

2014-12-09T10:05:14Z

Vytvoření stránky

Nová stránka

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]]

== Pro třídy s přirozeným řazením ==
* Pokud je přirozené porovnávat instance třídy a je zřejmé, podle jakého kritéria porovnání probíhá (například srovnání čísel), pak u třídy implementujeme rozhraní: <code>Comparable<Trida></code>
* Rozhraní vyžaduje jedinou metodu: <code>int compareTo(druha Trida)</code>
*Metoda vrací:
**kladné číslo, když je tato instance „větší“ než druhá,
**záporné číslo, když je menší než druhá
**a 0 když jsou obě instance „stejné“.
<div class="Priklad">Příklad:
public class Mince implements Comparable<Mince> {
    private int hodnota;

    public int compareTo(Mince druhaMince) {
        return this.hodnota - druhaMince.hodnota;
    }
}
</div>
* Použití:
ArrayList<Mince> mince = new Array...
Collections.sort(mince);

== Pro třídy, kde je více možných kritérií řazení ==
* Pokud můžeme porovnávat podle více kritérií, vytvoříme samostatné třídy „komparátory“.
* Implementují rozhraní: <code>Comparator<Trida></code>
<div class="Priklad">Příklad:
public class Auto {
    private int cena;
    private double spotreba;
    private String nazev;

    public int getCena() { return this.cena; }
    public double getSpotreba() { return this.spotreba; }
    public String getNazev() { return this.nazev; }
}

class AutoComparatorCena implements Comparator<Auto> {
    public int compare(Auto a1, Auto a2) { return a1.getCena() - a2.getCena(); }
}

class AutoComparatorSpotreba implements Comparator<Auto> {
    public int compare(Auto a1, Auto a2) { return Math.truncate(a1.getSpotreba() - a2.getSpotreba()); }
}

class AutoComparatorNazev implements Comparator<Auto> {
    public int compare(Auto a1, Auto a2) { return a1.getNazev().compareTo(a2.getNazev()); }
}
</div>
* Použití:
Collections.sort(auta, new AutoHmotnostComparator());
* Lze vytvořit také anonymní třídu pro porovnání (komparátor):
Collections.sort(auta, new Comparator&ltAuto>() { public int compare(Auto a1, Auto a2) { return ... } } );