Zoznam

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<E>
  - - java.util.Vector<Typ>
    - - Zoznam<Typ>

Všetky implementované rozhrania:

Serializable, Cloneable, Iterable<Typ>, Collection<Typ>, List<Typ>, RandomAccess

Známe priame odvodené triedy:

Filtre, GRobotException.Denník
```
public class Zoznam<Typ>
extends Vector<Typ>
```
Zoznam je použiteľný na vytvorenie zoznamu ľubovoľných objektov. Trieda obaľuje a rozširuje triedu Javy Vector<Typ>. To znamená, že podobne ako pri pôvodnom vektore, je možné vytvorený zoznam prechádzať konštrukciou:
```
for (Typ prvok : zoznam)
{
    prvok.metóda(…
    …
}
```
Napríklad zoznam reťazcov vytvoríme a prejdeme takto:
```
final Zoznam<String> zoznamMien = new Zoznam<String>();
zoznamMien.pridaj("Adam");
zoznamMien.pridaj("Braňo");
zoznamMien.pridaj("Cyril");
zoznamMien.pridaj("Daniel");

Svet.vypíšRiadok("Zoznam mien:");
for (String meno : zoznamMien)
{
    Svet.vypíšRiadok(" >", meno);
}
```
Výsledok:
```
Zoznam mien:
 > Adam
 > Braňo
 > Cyril
 > Daniel
```
Zoznamy sú dynamické – prvky je možné ľubovoľne pridávať a odoberať – táto trieda obsahuje širokú skupinu metód pokrývajúcu najdôležitejšie funkcie práce so zoznamom (pridávanie/vkladanie, odoberanie, nahrádzanie a vyhľadávanie…). Vnútorná správa zoznamu je v réžii Javy. Je dôležité upozorniť na to, že nie je správne meniť zoznam (pridávať alebo odoberať prvky) počas jeho prechádzania. Mohli by vzniknúť nepredvídateľné vedľajšie efekty alebo by to mohlo viesť ku vzniku výnimky.

Poznámka: Táto trieda používa na generovanie pseudonáhodných čísiel implementáciu Mersennovho twistera z CERNu z roku 1999. Uvedená implementácia bola použitá aj v rámci procesu implementácie vlastnej optimalizovanej verzie generátora pseudonáhodných čísiel s binomickým rozložením. (Pozri zdroj nižšie.)

Súvisiaci zdroj:
- Horváth, Roman: Optimisation of Algorithms Generating Pseudorandom Integers with Binomial Distribution. ICETA 2022. Danver : Institute of Electrical and Electronics Engineers, 2022. ISBN 979-8-3503-2032-9. Pp. 197–201. [prevziať]
Pozri tiež:

Vector<E>, Serializovateľnosť

Prehľad vnorených tried

Vnorené triedy
Modifikátor a typ	Trieda a opis
`static class`	`Zoznam.ObratenyIterator<Typ>` Alias pre `ObrátenýIterátor`.
`static class`	`Zoznam.ObrátenýIterátor<Typ>` Táto trieda slúži na vytvorenie obráteného iterátora zoznamu.

Prehľad atribútov
- Atribúty zdedené z triedy java.util.Vector
  capacityIncrement, elementCount, elementData
- Atribúty zdedené z triedy java.util.AbstractList
  modCount

Prehľad konštruktorov

Konštruktory
Konštruktor a opis
`Zoznam()` Vytvorí prázdny zoznam.
`Zoznam(Collection<? extends Typ> c)` Vytvorí zoznam obsaujúci prvky zadanej kolekcie.
`Zoznam(int počiatočnáKapacita)` Vytvorí prázdny zoznam s určenou počiatočnou kapacitou.
`Zoznam(int počiatočnáKapacita, int prírastokKapacity)` Vytvorí prázdny zoznam s určenou počiatočnou kapacitou a zadaným prírastkom kapacity použitým na zväčšenie kapacity po dosiahnutí aktuálneho limitu.
`Zoznam(Typ... prvky)` Vytvorí zoznam obsahujúci zadané prvky.

Prehľad metód

Všetky metódy Statické metódy Inštančné metódy Skutočne definované metódy
Modifikátor a typ	Metóda a opis
`Typ`	`aktualny()` Alias pre `daj`.
`Typ`	`aktuálny()` Alias pre `daj`.
`boolean`	`bolPrejdenyDokola()` Alias pre `prejdenýDokola`.
`boolean`	`bolPrejdenýDokola()` Alias pre `prejdenýDokola`.
`Typ`	`citaj()` Alias pre `daj`.
`Typ`	`citaj(int kde)` Alias pre `daj`.
`Typ`	`čítaj()` Alias pre `daj`.
`Typ`	`čítaj(int kde)` Alias pre `daj`.
`Typ`	`daj()` Vráti prvok na pozícii vnútorného počítadla zoznamu.
`Typ`	`daj(int kde)` Vráti prvok na zadanej pozícii v zozname.
`Typ`	`dalsi()` Alias pre `ďalší`.
`Typ`	`dalsiPrvok()` Alias pre `ďalší`.
`Typ`	`ďalší()` Vráti ďalší prvok zoznamu.
`Typ`	`ďalšíPrvok()` Alias pre `ďalší`.
`int`	`dlzka()` Alias pre `veľkosť`.
`int`	`dĺžka()` Alias pre `veľkosť`.
`int`	`hladaj(Typ prvok)` Alias pre `nájdi`.
`int`	`hľadaj(Typ prvok)` Alias pre `nájdi`.
`int`	`hladaj(Typ prvok, int začniOd)` Alias pre `nájdi`.
`int`	`hľadaj(Typ prvok, int začniOd)` Alias pre `nájdi`.
`int`	`hladajOdzadu(Typ prvok)` Alias pre `nájdiPosledný`.
`int`	`hľadajOdzadu(Typ prvok)` Alias pre `nájdiPosledný`.
`int`	`hladajOdzadu(Typ prvok, int začniOd)` Alias pre `nájdiPosledný`.
`int`	`hľadajOdzadu(Typ prvok, int začniOd)` Alias pre `nájdiPosledný`.
`boolean`	`jePrazdny()` Alias pre `prázdny`.
`boolean`	`jePrázdny()` Alias pre `prázdny`.
`int`	`kapacita()` Vráti aktuálnu kapacitu zoznamu.
`Typ`	`nahodny()` Alias pre `náhodný`.
`Typ`	`náhodný()` Vráti náhodný prvok zoznamu.
`Typ`	`nahodnyPrvok()` Alias pre `náhodný`.
`Typ`	`náhodnýPrvok()` Alias pre `náhodný`.
`void`	`nahrad(int kde, Typ prvok)` Alias pre `prepíš`.
`void`	`nahraď(int kde, Typ prvok)` Alias pre `prepíš`.
`int`	`najdi(Typ prvok)` Alias pre `nájdi`.
`int`	`nájdi(Typ prvok)` Vráti polohu prvého výskytu zadaného prvku v zozname alebo `-1` ak prvok nebol v zozname nájdený^[1].
`int`	`najdi(Typ prvok, int začniOd)` Alias pre `nájdi`.
`int`	`nájdi(Typ prvok, int začniOd)` Vráti polohu prvého výskytu zadaného prvku v zozname počnúc štartovacou pozíciou zadanou v parametri `začniOd` alebo `-1` ak prvok nebol v zozname nájdený^[1].
`int`	`najdiPosledny(Typ prvok)` Alias pre `nájdiPosledný`.
`int`	`nájdiPosledný(Typ prvok)` Vráti polohu posledného výskytu zadaného prvku v zozname alebo `-1` ak prvok nebol v zozname nájdený^[1].
`int`	`najdiPosledny(Typ prvok, int začniOd)` Alias pre `nájdiPosledný`.
`int`	`nájdiPosledný(Typ prvok, int začniOd)` Vráti polohu posledného výskytu zadaného prvku v zozname počnúc štartovacou pozíciou zadanou v parametri `začniOd` alebo `-1` ak prvok nebol v zozname nájdený.
`Zoznam.ObrátenýIterátor<Typ>`	`naopak()` Vytvorí pre tento zoznam prevrátený iterátor.
`static <Typ> Zoznam.ObrátenýIterátor<Typ>`	`naopak(List<Typ> pôvodný)` Vytvorí pre zadaný zoznam prevrátený iterátor.
`void`	`nastav(int kde, Typ prvok)` Alias pre `prepíš`.
`boolean`	`obsahuje(Typ prvok)` Zistí, či sa zadaný objekt nachádza v zozname^[1].
`void`	`odober(int kde)` Odstráni prvok na zadanej pozícii.
`void`	`odober(int začiatok, int koniec)` Odstráni všetky prvky na pozíciách zadaných rozsahom parametrov `začiatok` (vrátane) a `koniec` (okrem neho).
`boolean`	`odober(Typ prvok)` Odstráni zo zoznamu prvý výskyt prvku zhodného so zadaným prvkom^[1].
`void`	`odoberOdKonca(int začiatok, int koniec)` Odstráni všetky prvky na pozíciách zadaných rozsahom parametrov `začiatok` (vrátane) a `koniec` (okrem neho) s možnosťou určenia tohto rozsahu od konca zoznamu.
`Zoznam.ObrátenýIterátor<Typ>`	`odzadu()` Vytvorí pre tento zoznam prevrátený iterátor.
`static <Typ> Zoznam.ObrátenýIterátor<Typ>`	`odzadu(List<Typ> pôvodný)` Vytvorí pre zadaný zoznam prevrátený iterátor.
`int`	`pocet()` Alias pre `veľkosť`.
`int`	`pocitadlo()` Alias pre `počítadlo`.
`void`	`pocitadlo(int nováHodnota)` Alias pre `počítadlo`.
`void`	`pocitadloNaKoniec()` Alias pre `počítadloNaKoniec`.
`void`	`pocitadloNaZaciatok()` Alias pre `počítadloNaZačiatok`.
`int`	`počet()` Alias pre `veľkosť`.
`int`	`počítadlo()` Vráti hodnotu vnútorného počítadla používaného najmä metódami `ďalší` a `predchádzajúci`.
`void`	`počítadlo(int nováHodnota)` Nastaví novú hodnotu vnútorného počítadla používaného metódami `ďalší` a `predchádzajúci`.
`void`	`počítadloNaKoniec()` Nastaví vnútorné počítadlo zoznamu na polohu za posledným prvkom (`veľkosť()`), aby najbližšie volanie metódy `predchádzajúci` vrátilo posledný prvok zoznamu.
`void`	`počítadloNaZačiatok()` Nastaví vnútorné počítadlo zoznamu na polohu pred prvým prvkom (`-1`), aby najbližšie volanie metódy `ďalší` vrátilo prvý prvok zoznamu.
`Typ`	`posledny()` Alias pre `posledný`.
`Typ`	`posledný()` Vráti posledný prvok zoznamu.
`Typ`	`poslednyPrvok()` Alias pre `posledný`.
`Typ`	`poslednýPrvok()` Alias pre `posledný`.
`boolean`	`prazdny()` Alias pre `prázdny`.
`boolean`	`prázdny()` Vráti `true` vtedy a len vtedy, keď je zoznam prázdny, inak vráti `false`.
`Typ`	`predchadzajuci()` Alias pre `predchádzajúci`.
`Typ`	`predchádzajúci()` Vráti predchádzajúci prvok zoznamu.
`Typ`	`predchadzajuciPrvok()` Alias pre `predchádzajúci`.
`Typ`	`predchádzajúciPrvok()` Alias pre `predchádzajúci`.
`boolean`	`prejdenyDokola()` Alias pre `prejdenýDokola`.
`boolean`	`prejdenýDokola()` Vráti `true`, keď bol zoznam pri poslednom volaní metódy `ďalší` alebo `predchádzajúci` prejdený dokola.
`void`	`prepis(int kde, Typ prvok)` Alias pre `prepíš`.
`void`	`prepíš(int kde, Typ prvok)` Nahradí prvok na zadanej pozícii zadaným prvkom.
`void`	`presun(int ktorý, int kam)` Alias pre `presuň`.
`void`	`presuň(int ktorý, int kam)` Presunie prvok zoznamu nachádzajúci sa na zadanej zdrojovej pozícii (`ktorý`) na zadanú cieľovú pozíciu (`kam`).
`void`	`presun(int ktorý, Typ pred)` Alias pre `presuň`.
`void`	`presuň(int ktorý, Typ pred)` Presunie prvok v zozname z určenej pozície (indexu) pred prvok učený inštanciou, ktorá sa musí nachádzať v zozname.
`void`	`presun(Typ ktorý, int kam)` Alias pre `presuň`.
`void`	`presuň(Typ ktorý, int kam)` Presunie prvok zoznamu určený jeho inštanciou na zadanú pozíciu (index).
`void`	`presun(Typ ktorý, Typ pred)` Alias pre `presuň`.
`void`	`presuň(Typ ktorý, Typ pred)` Presunie prvok zoznamu určený jeho inštanciou pred iný prvok, tiež určený jeho inštanciou.
`void`	`pridaj(int kde, Typ prvok)` Alias pre `vlož`.
`void`	`pridaj(Typ prvok)` Pridá zadaný prvok na koniec zoznamu.
`void`	`pridaj(Typ[] pole)` Pridá prvky zadaného poľa na koniec tohto zoznamu.
`void`	`pridaj(Vector<Typ> inýZoznam)` Pridá zadaný zoznam na koniec tohto zoznamu podľa poradia určeného zadaným zoznamom (jeho iterátorom).
`Typ`	`prvy()` Alias pre `prvý`.
`Typ`	`prvý()` Vráti prvý prvok zoznamu.
`Typ`	`prvyPrvok()` Alias pre `prvý`.
`Typ`	`prvýPrvok()` Alias pre `prvý`.
`Typ`	`tento()` Alias pre `daj`.
`int`	`velkost()` Alias pre `veľkosť`.
`int`	`veľkosť()` Vráti počet prvkov zoznamu.
`void`	`vloz(int kde, Typ prvok)` Alias pre `vlož`.
`void`	`vlož(int kde, Typ prvok)` Vloží prvok na zadanú pozíciu v zozname.
`Typ`	`vrat()` Alias pre `daj`.
`Typ`	`vráť()` Alias pre `daj`.
`Typ`	`vrat(int kde)` Alias pre `daj`.
`Typ`	`vráť(int kde)` Alias pre `daj`.
`void`	`vymaz()` Alias pre `vymaž`.
`void`	`vymaz(int kde)` Alias pre `odober`.
`void`	`vymaz(int začiatok, int koniec)` Alias pre `odober`.
`void`	`vymazOdKonca(int začiatok, int koniec)` Alias pre `odoberOdKonca`.
`void`	`vymaž()` Odstráni všetky prvky zoznamu.
`void`	`vymaž(int kde)` Alias pre `odober`.
`void`	`vymaž(int začiatok, int koniec)` Alias pre `odober`.
`void`	`vymažOdKonca(int začiatok, int koniec)` Alias pre `odoberOdKonca`.
`void`	`vymen(int kde1, int kde2)` Alias pre `vymeň`.
`void`	`vymeň(int kde1, int kde2)` Vymení prvky v zozname nachádzajúce sa na zadaných pozíciách.
`void`	`vymen(int kde, Typ prvok)` Alias pre `vymeň`.
`void`	`vymeň(int kde, Typ prvok)` Vymení prvky v zozname, z ktorých jeden je určený pozíciou (indexom) a druhý objektom nachádzajúcim sa v zozname.
`void`	`vymen(Typ prvok, int kde)` Alias pre `vymeň`.
`void`	`vymeň(Typ prvok, int kde)` Vymení prvky v zozname, z ktorých jeden je určený pozíciou (indexom) a druhý objektom nachádzajúcim sa v zozname.
`void`	`vymen(Typ prvok1, Typ prvok2)` Alias pre `vymeň`.
`void`	`vymeň(Typ prvok1, Typ prvok2)` Vymení prvky zoznamu určené objektami nachádzajúcimi sa v zozname.

Metódy zdedené z triedy java.util.Vector
add, add, addAll, addAll, addElement, capacity, clear, clone, contains, containsAll, copyInto, elementAt, elements, ensureCapacity, equals, firstElement, forEach, get, hashCode, indexOf, indexOf, insertElementAt, isEmpty, iterator, lastElement, lastIndexOf, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, removeAllElements, removeElement, removeElementAt, removeIf, removeRange, replaceAll, retainAll, set, setElementAt, setSize, size, sort, spliterator, subList, toArray, toArray, toString, trimToSize

Metódy zdedené z triedy java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Metódy zdedené z rozhrania java.util.Collection
parallelStream, stream

- Podrobnosti konštruktorov
  - Zoznam
```
public Zoznam()
```
    Vytvorí prázdny zoznam.
  - Zoznam
```
@SafeVarargs
public Zoznam(Typ... prvky)
```
    Vytvorí zoznam obsahujúci zadané prvky.
    
    Parametre:
    
    prvky – zoznam prvkov oddelený čiarkami
  - Zoznam
```
public Zoznam(Collection<? extends Typ> c)
```
    Vytvorí zoznam obsaujúci prvky zadanej kolekcie.
    
    Parametre:
    
    c – kolekcia, ktorej prvky sú použité na naplnenie zoznamu
    
    Pozri tiež:
    
    Collection<E>
  - Zoznam
```
public Zoznam(int počiatočnáKapacita)
```
    Vytvorí prázdny zoznam s určenou počiatočnou kapacitou. Tento konštruktor je vhodné použiť ak vieme, že do zoznamu pridáme naraz veľké množstvo prvkov. Odhadované množstvo prvkov zadáme ako počiatočnú kapacitu zoznamu.
    
    Parametre:
    
    počiatočnáKapacita – počiatočná kapacita zoznamu
  - Zoznam
```
public Zoznam(int počiatočnáKapacita,
              int prírastokKapacity)
```
    Vytvorí prázdny zoznam s určenou počiatočnou kapacitou a zadaným prírastkom kapacity použitým na zväčšenie kapacity po dosiahnutí aktuálneho limitu. Tento konštruktor je vhodné použiť ak vieme, že do zoznamu pridáme naraz veľké množstvo prvkov a objem pridávaných prvkov sa bude nárazovo meniť. Odhadované množstvo prvkov zadáme ako počiatočnú kapacitu zoznamu. Prírastok kapacity je odhad naraz pridávaného objemu prvkov v priebehu bytia zoznamu.
    
    Parametre:
    
    počiatočnáKapacita – počiatočná kapacita zoznamu
    
    prírastokKapacity – objem o ktorý sa zväčší kapacita zoznamu po prekročení aktuálneho limitu
- Podrobnosti metód
  - kapacita
```
public int kapacita()
```
    Vráti aktuálnu kapacitu zoznamu.
    
    Návratová hodnota:
    
    aktuálna kapacita zoznamu (veľkosť vnútorného poľa slúžiaceho na uchovávanie prvkov zoznamu – nie je totožná so skutočnou veľkosťou zoznamu – kapacita udáva množstvo prvkov, ktoré môžeme do zoznamu pridať bez potreby zväčšenia jeho vnútornej veľkosti (pamäťových nárokov); zväčšenie vnútornej veľkosti zoznamu vždy zaberá určitý čas…)
  - veľkosť
```
public int veľkosť()
```
    Vráti počet prvkov zoznamu.
    
    Návratová hodnota:
    
    počet prvkov zoznamu
  - počet
```
public int počet()
```
    Alias pre veľkosť.
  - dĺžka
```
public int dĺžka()
```
    Alias pre veľkosť.
  - velkost
```
public int velkost()
```
    Alias pre veľkosť.
  - pocet
```
public int pocet()
```
    Alias pre veľkosť.
  - dlzka
```
public int dlzka()
```
    Alias pre veľkosť.
  - prázdny
```
public boolean prázdny()
```
    Vráti true vtedy a len vtedy, keď je zoznam prázdny, inak vráti false.
    
    Návratová hodnota:
    
    true/false
  - prazdny
```
public boolean prazdny()
```
    Alias pre prázdny.
  - jePrázdny
```
public boolean jePrázdny()
```
    Alias pre prázdny.
  - jePrazdny
```
public boolean jePrazdny()
```
    Alias pre prázdny.
  - pridaj
```
public void pridaj(Typ prvok)
```
    Pridá zadaný prvok na koniec zoznamu. Dĺžka zoznamu narastie o jedna a kapacita sa zvýši ak je prekročený aktuálny limit.
    
    Parametre:
    
    prvok – prvok, ktorý má byť pridaný na koniec zoznamu
  - pridaj
```
public void pridaj(Typ[] pole)
```
    Pridá prvky zadaného poľa na koniec tohto zoznamu. Metóda sa počas pridávania jednotlivých prvkov poľa správa rovnako ako metóda pridaj(prvok).
    
    Parametre:
    
    pole – pole prvkov, ktoré majú byť pridané na koniec zoznamu
  - pridaj
```
public void pridaj(Vector<Typ> inýZoznam)
```
    Pridá zadaný zoznam na koniec tohto zoznamu podľa poradia určeného zadaným zoznamom (jeho iterátorom). Výsledok akcie je nepredvídateľný, ak je počas tejto operácie zadaný zoznam zmenený.
    
    Parametre:
    
    inýZoznam – zoznam, ktorého prvky majú byť pridané na koniec tohto zoznamu
  - vlož
```
public void vlož(int kde,
                 Typ prvok)
```
    Vloží prvok na zadanú pozíciu v zozname. Všetky prvky, počnúc zadanou polohou, sú posunuté o jednu pozíciu vyššie. Veľkosť zoznamu sa zvýši o jedna. Zadaná poloha musí byť číslo väčšie alebo rovné nule a menšie alebo rovné veľkosti zoznamu. (Ak je poloha rovná dĺžke zoznamu, prvok je pridaný na jeho koniec.)
    
    Parametre:
    
    kde – poloha prvku v zozname – poradové číslo väčšie alebo rovné nule a menšie alebo rovné veľkosti zoznamu
    
    prvok – prvok, ktorý má byť vložený na zadanú pozíciu
  - vloz
```
public void vloz(int kde,
                 Typ prvok)
```
    Alias pre vlož.
  - pridaj
```
public void pridaj(int kde,
                   Typ prvok)
```
    Alias pre vlož.
  - prepíš
```
public void prepíš(int kde,
                   Typ prvok)
```
    Nahradí prvok na zadanej pozícii zadaným prvkom. Poloha musí byť číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu. Dĺžka zoznamu sa nemení, pôvodný prvok je nahradený.
    
    Parametre:
    
    kde – poloha prvku v zozname – poradové číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu
    
    prvok – prvok, ktorým má byť určený prvok nahradený
  - prepis
```
public void prepis(int kde,
                   Typ prvok)
```
    Alias pre prepíš.
  - nastav
```
public void nastav(int kde,
                   Typ prvok)
```
    Alias pre prepíš.
  - nahraď
```
public void nahraď(int kde,
                   Typ prvok)
```
    Alias pre prepíš.
  - nahrad
```
public void nahrad(int kde,
                   Typ prvok)
```
    Alias pre prepíš.
  - vymaž
```
public void vymaž()
```
    Odstráni všetky prvky zoznamu. Po úspešnom vykonaní tejto metódy bude zoznam prázdny.
  - vymaz
```
public void vymaz()
```
    Alias pre vymaž.
  - odober
```
public void odober(int kde)
```
    Odstráni prvok na zadanej pozícii. Pozícia musí byť číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu. Každý prvok nachádzajúci sa nad určeným prvkom je posunutý o jednu pozíciu nižšie. Veľkosť zoznamu je znížená o jedna.
    
    Parametre:
    
    kde – poloha prvku odstraňovaného zo zoznamu – poradové číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu
  - vymaž
```
public void vymaž(int kde)
```
    Alias pre odober.
  - vymaz
```
public void vymaz(int kde)
```
    Alias pre odober.
  - odober
```
public void odober(int začiatok,
                   int koniec)
```
    Odstráni všetky prvky na pozíciách zadaných rozsahom parametrov začiatok (vrátane) a koniec (okrem neho). Ak je začiatočná hodnota rovná koncovej, tak nie je vymazaný žiadny prvok. Veľkosť zoznamu je znížená o počet prvkov nachádzajúcich sa medzi polohami určenými parametrami začiatok (vrátane) a koniec (okrem nej).
    
    Poznámka: Prirodzeným dôsledkom vymazania je presunutie prípadných prvkov nachádzajúcich sa na a nad prvkom určeným parametrom koniec do radu pri zachovaní ich poradia na pozície začínajúce sa na polohe určenej parametrom začiatok.
    
    Parametre:
    
    začiatok – poloha určujúca prvý prvok odstraňovaný zo zoznamu
    
    koniec – poloha určujúca koniec odstraňovnia prvkov zo zoznamu
  - vymaž
```
public void vymaž(int začiatok,
                  int koniec)
```
    Alias pre odober.
  - vymaz
```
public void vymaz(int začiatok,
                  int koniec)
```
    Alias pre odober.
  - odoberOdKonca
```
public void odoberOdKonca(int začiatok,
                          int koniec)
```
    Odstráni všetky prvky na pozíciách zadaných rozsahom parametrov začiatok (vrátane) a koniec (okrem neho) s možnosťou určenia tohto rozsahu od konca zoznamu.
    
    Ak sú parametre kladné, tak táto metóda funguje rovnako ako metóda odober(začiatok, koniec) – odstráni všetky prvky na pozíciách zadaných rozsahom parametrov začiatok (vrátane) a koniec (okrem neho). V prípade zápornej hodnoty jedného alebo obidvoch parametrov sú hodnoty touto metódou upravené tak, aby boli väčšie alebo rovné nule a to tak, aby výsledný rozsah ukazoval na poradové čísla od konca zoznamu, pričom pre parameter začiatok znamená mínus jednotka posledný prvok zoznamu a pre parameter koniec znamená mínus jednotka „koniec zoznamu“ (index rovný dĺžke zoznamu). Tým vieme vytvoriť rôzne situácie, napríklad: 1, −1 – vymazať všetko, okrem prvého prvku… Stále však musí platiť to, že aby bol vymazaný aspoň jeden prvok, tak prepočítaná hodnota začiatku musí byť menšia ako prepočítaná hodnota konca. Ak je začiatočná hodnota rovná koncovej (pozor na prepočet, vtedy sa hodnoty rozchádzajú o jedna), tak nie je vymazaný žiadny prvok. Veľkosť zoznamu je znížená o počet prvkov nachádzajúcich sa medzi polohami určenými parametrami začiatok a koniec (po ich prípadnom prepočítaní a vrátane prvku na začiatočnej pozícii).
    
    Poznámka: Prirodzeným dôsledkom vymazania je presunutie prípadných prvkov nachádzajúcich sa na a nad prvkom určeným parametrom koniec do radu pri zachovaní ich poradia na pozície začínajúce sa na polohe určenej parametrom začiatok.
    
    Parametre:
    
    začiatok – poloha určujúca prvý prvok odstraňovaný zo zoznamu (môže byť prepočítaná – pozri opis)
    
    koniec – poloha určujúca koniec odstraňovnia prvkov zo zoznamu (môže byť prepočítaná – pozri opis)
  - vymažOdKonca
```
public void vymažOdKonca(int začiatok,
                         int koniec)
```
    Alias pre odoberOdKonca.
  - vymazOdKonca
```
public void vymazOdKonca(int začiatok,
                         int koniec)
```
    Alias pre odoberOdKonca.
  - odober
```
public boolean odober(Typ prvok)
```
    Odstráni zo zoznamu prvý výskyt prvku zhodného so zadaným prvkom^[1]. Ak zoznam taký prvok neobsahuje, zostáva nezmenený.
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda odstráni prvý výskyt elementu v zozname, ktorý pri porovnaní so zadaným prvkom spĺňa nasledujúcu podmienku: (prvok ==null ? element == null : prvok.equals(element)) (ak taký element jestvuje); toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), tak sa metóda pokúsi nájsť a odstrániť prvý prázdny element v zozname, inak porovnáva obsahy jednotlivých elementov zoznamu a odstráni ten, ktorého obsah (hodnota) je ekvivalentný s obsahom nami zadaného prvku.
    
    Parametre:
    
    prvok – prvok, ktorý má byť zo zoznamu odstránený (ak sa v ňom nachádza)
    
    Návratová hodnota:
    
    true ak zoznam zadaný prvok obsahoval
  - obsahuje
```
public boolean obsahuje(Typ prvok)
```
    Zistí, či sa zadaný objekt nachádza v zozname^[1].
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda vráti logickú hodnotu true iba v prípade, že aspoň jeden element zoznamu vyhovuje podmienke (prvok == null ? element == null : prvok.equals(element)), kde prvok je nami zadaný prvok a element je porovnávaný prvok zoznamu (metóda postupne prechádza jednotlivé elementy zoznamu a porovnáva ich s nami zadaným prvkom); toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), metóda hľadá výskyt prázdneho prvku v zozname, inak hľadá taký prvok, ktorého obsah sa zhoduje s obsahom nami zadaného (neprázdneho) prvku.
    
    Parametre:
    
    prvok – prvok, ktorého výskyt v zozname má byť overený
    
    Návratová hodnota:
    
    ak bol zadaný prvok v zozname nájdený, vráti sa true
  - počítadlo
```
public int počítadlo()
```
    Vráti hodnotu vnútorného počítadla používaného najmä metódami ďalší a predchádzajúci. Vnútorné počítadlo používa a nastavuje aj mnoho iných metód triedy Zoznam.
    
    Návratová hodnota:
    
    hodnota vnútorného počítadla
  - pocitadlo
```
public int pocitadlo()
```
    Alias pre počítadlo.
  - počítadlo
```
public void počítadlo(int nováHodnota)
```
    Nastaví novú hodnotu vnútorného počítadla používaného metódami ďalší a predchádzajúci. Táto metóda kontroluje hodnotu počítadla tak, aby bola v rozsahu -1 až veľkosť(), čo sú hraničné hodnoty vhodné na použitie pri cyklickom prechádzaní zoznamu. Ak chceme prechádzať zoznam od začiatku metódou ďalší, je šikovnejšie použiť metódu počítadloNaZačiatok a v prípade prechádzania zoznamu od konca (metódou predchádzajúci) zase metódu počítadloNaKoniec.
    
    Nasledujúci príklad ukazuje, ako jednorazovo prejsť číselný zoznam od konca, aj keď na takéto jednorazové prejdenie zoznamu je vhodnejší iný spôsob – pozri poznámku pod výsledkom príkladu.
    
    Príklad:
```
final Zoznam<Integer> čísla = new Zoznam<Integer>(0, 8, 5, 4);

čísla.počítadloNaKoniec();
Integer i = čísla.predchádzajúciPrvok();
while (!čísla.prejdenýDokola())
{
    Svet.vypíš(i, " ");
    i = čísla.predchádzajúciPrvok();
}
```
    Výsledok:
```
4 5 8 0 
```
    Poznámka: Tento spôsob prechádzania zoznamu je vhodný aj na asynchrónne prechádzanie zoznamu (pohyb po ňom). Jestvuje ešte jeden spôsob prechádzania zoznamu odzadu a síce s použitím prevráteného iterátora – pozri metódu odzadu.
    Parametre:
    
    nováHodnota – nová hodnota vnútorného počítadla
  - pocitadlo
```
public void pocitadlo(int nováHodnota)
```
    Alias pre počítadlo.
  - počítadloNaZačiatok
```
public void počítadloNaZačiatok()
```
    Nastaví vnútorné počítadlo zoznamu na polohu pred prvým prvkom (-1), aby najbližšie volanie metódy ďalší vrátilo prvý prvok zoznamu.
  - pocitadloNaZaciatok
```
public void pocitadloNaZaciatok()
```
    Alias pre počítadloNaZačiatok.
  - počítadloNaKoniec
```
public void počítadloNaKoniec()
```
    Nastaví vnútorné počítadlo zoznamu na polohu za posledným prvkom (veľkosť()), aby najbližšie volanie metódy predchádzajúci vrátilo posledný prvok zoznamu.
    
    Poznámka: V opise metódy počítadlo je príklad ukazujúci, ako prejsť zoznam čísel od konca. Príklad využíva aj túto metódu.
  - pocitadloNaKoniec
```
public void pocitadloNaKoniec()
```
    Alias pre počítadloNaKoniec.
  - daj
```
public Typ daj(int kde)
```
    Vráti prvok na zadanej pozícii v zozname. Poloha musí byť číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu.
    
    Parametre:
    
    kde – poloha prvku v zozname – poradové číslo väčšie alebo rovné nule a menšie než veľkosť zoznamu
    
    Návratová hodnota:
    
    prvok zoznamu
  - vráť
```
public Typ vráť(int kde)
```
    Alias pre daj.
  - vrat
```
public Typ vrat(int kde)
```
    Alias pre daj.
  - čítaj
```
public Typ čítaj(int kde)
```
    Alias pre daj.
  - citaj
```
public Typ citaj(int kde)
```
    Alias pre daj.
  - daj
```
public Typ daj()
```
    Vráti prvok na pozícii vnútorného počítadla zoznamu. Ak je z neakého dôvodu hodnota vnútorného počítadla menšia od nuly (a zoznam nie je prázdny), metóda vráti posledný prvok zoznamu. Ak je naopak hodnota počítadla väčšia alebo rovná dĺžke zoznamu, vráti prvý prvok zoznamu (opäť v prípade, že zoznam nie je prázdny, pretože v takom prípade metóda vrhá výnimku).
    
    Návratová hodnota:
    
    prvok zoznamu
    
    Výnimky:
    
    NoSuchElementException
  - vráť
```
public Typ vráť()
```
    Alias pre daj.
  - vrat
```
public Typ vrat()
```
    Alias pre daj.
  - čítaj
```
public Typ čítaj()
```
    Alias pre daj.
  - citaj
```
public Typ citaj()
```
    Alias pre daj.
  - aktuálny
```
public Typ aktuálny()
```
    Alias pre daj.
  - aktualny
```
public Typ aktualny()
```
    Alias pre daj.
  - tento
```
public Typ tento()
```
    Alias pre daj.
  - prvý
```
public Typ prvý()
```
    Vráti prvý prvok zoznamu. (Prvok s indexom 0.) Zároveň nastaví vnútorné počítadlo prvkov na nulu.
    
    Návratová hodnota:
    
    prvý prvok zoznamu
  - prvy
```
public Typ prvy()
```
    Alias pre prvý.
  - prvýPrvok
```
public Typ prvýPrvok()
```
    Alias pre prvý.
  - prvyPrvok
```
public Typ prvyPrvok()
```
    Alias pre prvý.
  - posledný
```
public Typ posledný()
```
    Vráti posledný prvok zoznamu. (Prvok s indexom «zoznam».veľkosť() - 1.) Zároveň nastaví vnútorné počítadlo prvkov na index posledného prvku.
    
    Návratová hodnota:
    
    posledný prvok zoznamu
  - posledny
```
public Typ posledny()
```
    Alias pre posledný.
  - poslednýPrvok
```
public Typ poslednýPrvok()
```
    Alias pre posledný.
  - poslednyPrvok
```
public Typ poslednyPrvok()
```
    Alias pre posledný.
  - ďalší
```
public Typ ďalší()
```
    Vráti ďalší prvok zoznamu. Ak vnútorné počítadlo prvkov prekročilo najvyššiu hodnotu, vráti prvý prvok. V takej situácii je zoznam považovaný za prejdený dokola a metóda metóda prejdenýDokola vráti true.
    
    Návratová hodnota:
    
    ďalší prvok zoznamu; prvok je určený podľa hodnoty vnútorného počítadla
  - dalsi
```
public Typ dalsi()
```
    Alias pre ďalší.
  - ďalšíPrvok
```
public Typ ďalšíPrvok()
```
    Alias pre ďalší.
  - dalsiPrvok
```
public Typ dalsiPrvok()
```
    Alias pre ďalší.
  - predchádzajúci
```
public Typ predchádzajúci()
```
    Vráti predchádzajúci prvok zoznamu. Ak vnútorné počítadlo prvkov kleslo pod najnižšiu hodnotu, vráti posledný prvok. V takej situácii je zoznam považovaný za prejdený dokola a metóda metóda prejdenýDokola vráti true.
    
    Poznámka: V opise metódy počítadlo je príklad ukazujúci, ako prejsť zoznam čísel od konca. Príklad využíva aj túto metódu.
    
    Návratová hodnota:
    
    predchádzajúci prvok zoznamu; prvok je určený podľa hodnoty vnútorného počítadla
  - predchadzajuci
```
public Typ predchadzajuci()
```
    Alias pre predchádzajúci.
  - predchádzajúciPrvok
```
public Typ predchádzajúciPrvok()
```
    Alias pre predchádzajúci.
  - predchadzajuciPrvok
```
public Typ predchadzajuciPrvok()
```
    Alias pre predchádzajúci.
  - prejdenýDokola
```
public boolean prejdenýDokola()
```
    Vráti true, keď bol zoznam pri poslednom volaní metódy ďalší alebo predchádzajúci prejdený dokola. Na výslednú hodnotu tejto metódy majú vplyv len spomenuté dve metódy.
    
    Poznámka: V opise metódy počítadlo je príklad ukazujúci, ako prejsť zoznam čísel od konca. Príklad využíva aj túto metódu.
    
    Návratová hodnota:
    
    true/false
  - prejdenyDokola
```
public boolean prejdenyDokola()
```
    Alias pre prejdenýDokola.
  - bolPrejdenýDokola
```
public boolean bolPrejdenýDokola()
```
    Alias pre prejdenýDokola.
  - bolPrejdenyDokola
```
public boolean bolPrejdenyDokola()
```
    Alias pre prejdenýDokola.
  - náhodný
```
public Typ náhodný()
```
    Vráti náhodný prvok zoznamu. Zároveň nastaví vnútorné počítadlo na hodnotu prvku, ktorý bol vrátený.
    
    Poznámka: Táto metóda používa Mersennov twistr z CERNu (1999). Pozri aj poznámku v hlavnom opise tejto triedy.
    
    Návratová hodnota:
    
    náhodný prvok zoznamu
  - nahodny
```
public Typ nahodny()
```
    Alias pre náhodný.
  - náhodnýPrvok
```
public Typ náhodnýPrvok()
```
    Alias pre náhodný.
  - nahodnyPrvok
```
public Typ nahodnyPrvok()
```
    Alias pre náhodný.
  - nájdi
```
public int nájdi(Typ prvok)
```
    Vráti polohu prvého výskytu zadaného prvku v zozname alebo -1 ak prvok nebol v zozname nájdený^[1].
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda vráti najnižší index i pre ktorý platí podmienka (prvok == null ? element ==null : prvok.equals(element)) (kde element je prvok zoznamu na pozícii i) alebo -1 ak taký index nejestvuje; toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), tak sa metóda pokúsi nájsť prvý prázdny element v zozname, inak porovnáva obsahy jednotlivých elementov zoznamu s obsahom nami zadaného (neprázdneho) prvku.
    
    Parametre:
    
    prvok – hľadaný prvok
    
    Návratová hodnota:
    
    poloha prvku v zozname (hľadá sa prvý výskyt) alebo -1 ak prvok nebol nájdený
  - najdi
```
public int najdi(Typ prvok)
```
    Alias pre nájdi.
  - hľadaj
```
public int hľadaj(Typ prvok)
```
    Alias pre nájdi.
  - hladaj
```
public int hladaj(Typ prvok)
```
    Alias pre nájdi.
  - nájdi
```
public int nájdi(Typ prvok,
                 int začniOd)
```
    Vráti polohu prvého výskytu zadaného prvku v zozname počnúc štartovacou pozíciou zadanou v parametri začniOd alebo -1 ak prvok nebol v zozname nájdený^[1].
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda vráti najnižší index i pre ktorý platí podmienka (i >= začniOd && prvok == null? element == null : prvok.equals(element)) (kde element je prvok zoznamu na pozícii i) alebo -1 ak taký index nejestvuje; toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), tak sa metóda pokúsi nájsť prvý prázdny element v zozname (počnúc hľadanie od pozície začniOd), inak porovnáva obsahy jednotlivých elementov zoznamu s obsahom nami zadaného (neprázdneho) prvku.
    
    Parametre:
    
    prvok – hľadaný prvok
    
    začniOd – pozícia v zozname od ktorej sa má začať hľadať
    
    Návratová hodnota:
    
    poloha prvého prvku v zozname nájdeného na pozícii väčšej alebo rovnej hodnote parametra začniOd alebo -1 ak prvok nebol nájdený
  - najdi
```
public int najdi(Typ prvok,
                 int začniOd)
```
    Alias pre nájdi.
  - hľadaj
```
public int hľadaj(Typ prvok,
                  int začniOd)
```
    Alias pre nájdi.
  - hladaj
```
public int hladaj(Typ prvok,
                  int začniOd)
```
    Alias pre nájdi.
  - nájdiPosledný
```
public int nájdiPosledný(Typ prvok)
```
    Vráti polohu posledného výskytu zadaného prvku v zozname alebo -1 ak prvok nebol v zozname nájdený^[1].
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda vráti najvyšší index i pre ktorý platí podmienka (prvok == null ? element ==null : prvok.equals(element)) (kde element je prvok zoznamu na pozícii i) alebo -1 ak taký index nejestvuje; toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), tak sa metóda pokúsi nájsť posledný prázdny element v zozname, inak porovnáva obsahy jednotlivých elementov zoznamu s obsahom nami zadaného (neprázdneho) prvku.
    
    Parametre:
    
    prvok – hľadaný prvok
    
    Návratová hodnota:
    
    poloha posledného prvku v zozname alebo -1 ak prvok nebol nájdený
  - najdiPosledny
```
public int najdiPosledny(Typ prvok)
```
    Alias pre nájdiPosledný.
  - hľadajOdzadu
```
public int hľadajOdzadu(Typ prvok)
```
    Alias pre nájdiPosledný.
  - hladajOdzadu
```
public int hladajOdzadu(Typ prvok)
```
    Alias pre nájdiPosledný.
  - nájdiPosledný
```
public int nájdiPosledný(Typ prvok,
                         int začniOd)
```
    Vráti polohu posledného výskytu zadaného prvku v zozname počnúc štartovacou pozíciou zadanou v parametri začniOd alebo -1 ak prvok nebol v zozname nájdený.
    
    [1] – ak chceme byť úplne presní, tak povieme, že metóda vráti najvyšší index i pre ktorý platí podmienka (i <= začniOd && prvok == null? element == null : prvok.equals(element)) (kde element je prvok zoznamu na pozícii i) alebo -1 ak taký index nejestvuje; toto vyjadrenie obsahuje podmienku, ktorá exaktne vyjadruje to, že ak je nami zadaný prvok prázdny (null), tak sa metóda pokúsi nájsť posledný prázdny element v zozname (počnúc hľadanie od pozície začniOd), inak porovnáva obsahy jednotlivých elementov zoznamu s obsahom nami zadaného (neprázdneho) prvku
    
    Parametre:
    
    prvok – hľadaný prvok
    
    začniOd – pozícia v zozname od ktorej sa má začať hľadať
    
    Návratová hodnota:
    
    poloha posledného prvku v zozname nájdeného na pozícii menšej alebo rovnej hodnote parametra začniOd alebo -1 ak prvok nebol nájdený (vráti -1), ak je parameter začniOd záporný)
  - najdiPosledny
```
public int najdiPosledny(Typ prvok,
                         int začniOd)
```
    Alias pre nájdiPosledný.
  - hľadajOdzadu
```
public int hľadajOdzadu(Typ prvok,
                        int začniOd)
```
    Alias pre nájdiPosledný.
  - hladajOdzadu
```
public int hladajOdzadu(Typ prvok,
                        int začniOd)
```
    Alias pre nájdiPosledný.
  - vymeň
```
public void vymeň(int kde1,
                  int kde2)
```
    Vymení prvky v zozname nachádzajúce sa na zadaných pozíciách.
    
    Parametre:
    
    kde1 – pozícia (index) prvku
    
    kde2 – pozícia (index) prvku
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je niektorá zo zadaných pozící mimo rozsahu zoznamu
    
    Pozri tiež:
    
    vymeň(int, int), vymeň(java.lang.Object, int), vymeň(int, java.lang.Object), vymeň(java.lang.Object, java.lang.Object)
  - vymeň
```
public void vymeň(int kde,
                  Typ prvok)
```
    Vymení prvky v zozname, z ktorých jeden je určený pozíciou (indexom) a druhý objektom nachádzajúcim sa v zozname.
    
    Parametre:
    
    kde – pozícia (index) prvku
    
    prvok – objekt nachádzajúci sa v zozname
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je zadaná pozícia mimo rozsahu zoznamu alebo ak sa zadaný prvok v zozname nenachádza
    
    Pozri tiež:
    
    vymeň(int, int), vymeň(java.lang.Object, int), vymeň(int, java.lang.Object), vymeň(java.lang.Object, java.lang.Object)
  - vymeň
```
public void vymeň(Typ prvok,
                  int kde)
```
    Vymení prvky v zozname, z ktorých jeden je určený pozíciou (indexom) a druhý objektom nachádzajúcim sa v zozname.
    
    Parametre:
    
    prvok – objekt nachádzajúci sa v zozname
    
    kde – pozícia (index) prvku
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je zadaná pozícia mimo rozsahu zoznamu alebo ak sa zadaný prvok v zozname nenachádza
    
    Pozri tiež:
    
    vymeň(int, int), vymeň(java.lang.Object, int), vymeň(int, java.lang.Object), vymeň(java.lang.Object, java.lang.Object)
  - vymeň
```
public void vymeň(Typ prvok1,
                  Typ prvok2)
```
    Vymení prvky zoznamu určené objektami nachádzajúcimi sa v zozname.
    
    Parametre:
    
    prvok1 – objekt nachádzajúci sa v zozname
    
    prvok2 – objekt nachádzajúci sa v zozname
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak sa niektorý zo zadaných prvkov v zozname nenachádza
    
    Pozri tiež:
    
    vymeň(int, int), vymeň(java.lang.Object, int), vymeň(int, java.lang.Object), vymeň(java.lang.Object, java.lang.Object)
  - vymen
```
public void vymen(int kde1,
                  int kde2)
```
    Alias pre vymeň.
  - vymen
```
public void vymen(int kde,
                  Typ prvok)
```
    Alias pre vymeň.
  - vymen
```
public void vymen(Typ prvok,
                  int kde)
```
    Alias pre vymeň.
  - vymen
```
public void vymen(Typ prvok1,
                  Typ prvok2)
```
    Alias pre vymeň.
  - presuň
```
public void presuň(int ktorý,
                   int kam)
```
    Presunie prvok zoznamu nachádzajúci sa na zadanej zdrojovej pozícii (ktorý) na zadanú cieľovú pozíciu (kam).
    
    Parametre:
    
    ktorý – zdrojová pozícia (index) prvku
    
    kam – cieľová pozícia (index) prvku
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je niektorá zo zadaných pozící mimo rozsahu zoznamu
    
    Pozri tiež:
    
    presuň(int, int), presuň(java.lang.Object, int), presuň(int, java.lang.Object), presuň(java.lang.Object, java.lang.Object)
  - presuň
```
public void presuň(int ktorý,
                   Typ pred)
```
    Presunie prvok v zozname z určenej pozície (indexu) pred prvok učený inštanciou, ktorá sa musí nachádzať v zozname.
    
    Parametre:
    
    ktorý – pozícia (index) prvku
    
    pred – inštancia nachádzajúca sa v zozname
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je zadaná pozícia mimo rozsahu zoznamu alebo ak sa zadaný prvok v zozname nenachádza
    
    Pozri tiež:
    
    presuň(int, int), presuň(java.lang.Object, int), presuň(int, java.lang.Object), presuň(java.lang.Object, java.lang.Object)
  - presuň
```
public void presuň(Typ ktorý,
                   int kam)
```
    Presunie prvok zoznamu určený jeho inštanciou na zadanú pozíciu (index). Zadaný (presúvaný) prvok sa musí nachádzať v zozname, inak vznikne výnimka.
    
    Parametre:
    
    ktorý – inštancia nachádzajúca sa v zozname
    
    kam – pozícia (index) prvku
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak je zadaná pozícia mimo rozsahu zoznamu alebo ak sa zadaný prvok v zozname nenachádza
    
    Pozri tiež:
    
    presuň(int, int), presuň(java.lang.Object, int), presuň(int, java.lang.Object), presuň(java.lang.Object, java.lang.Object)
  - presuň
```
public void presuň(Typ ktorý,
                   Typ pred)
```
    Presunie prvok zoznamu určený jeho inštanciou pred iný prvok, tiež určený jeho inštanciou. Obe inštancie sa musia nachádzať v zozname, inak vznikne výnimka.
    
    Parametre:
    
    ktorý – inštancia nachádzajúca sa v zozname
    
    pred – inštancia nachádzajúca sa v zozname
    
    Výnimky:
    
    ArrayIndexOutOfBoundsException – ak sa niektorý zo zadaných prvkov v zozname nenachádza
    
    Pozri tiež:
    
    presuň(int, int), presuň(java.lang.Object, int), presuň(int, java.lang.Object), presuň(java.lang.Object, java.lang.Object)
  - presun
```
public void presun(int ktorý,
                   int kam)
```
    Alias pre presuň.
  - presun
```
public void presun(int ktorý,
                   Typ pred)
```
    Alias pre presuň.
  - presun
```
public void presun(Typ ktorý,
                   int kam)
```
    Alias pre presuň.
  - presun
```
public void presun(Typ ktorý,
                   Typ pred)
```
    Alias pre presuň.
  - odzadu
```
public Zoznam.ObrátenýIterátor<Typ> odzadu()
```
    Vytvorí pre tento zoznam prevrátený iterátor. To znamená, že nasledujúci cyklus:
```
Zoznam<String> zoznam = …
for (String prvok : zoznam.odzadu()) …
```
    bude vykonaný pre každý prvok zoznamu začnúc od posledného a končiac prvým.
    
    Poznámka: Tento spôsob prechádzania zoznamu je vhodný na jednorazové (synchrónne) prejdenie zoznamu. Na asynchrónne prechádzanie zoznamu (pohyb po ňom) je vhodnejšie použiť vnútorné počítadlo zoznamu – pozri metódu počítadlo.
    Parametre:
    
    pôvodný – pôvodný zoznam
    
    Návratová hodnota:
    
    iterátor umožňujúci prejsť zoznam v obrátenom poradí
  - odzadu
```
public static <Typ> Zoznam.ObrátenýIterátor<Typ> odzadu(List<Typ> pôvodný)
```
    Vytvorí pre zadaný zoznam prevrátený iterátor. To znamená, že nasledujúci cyklus:
```
Zoznam<String> zoznam = …
for (String prvok : Zoznam.<String>odzadu(zoznam)) …
```
    bude vykonaný pre každý prvok zoznamu začnúc od posledného a končiac prvým. Jednoduchšie je použitie metódy odzadu(), ale tá je použiteľná len pre inštancie triedy Zoznam. Táto metóda je použiteľná pre ľubovoľný zoznam, ktorý je implementáciou rozhrania List.
    Parametre:
    
    pôvodný – pôvodný zoznam
    
    Návratová hodnota:
    
    iterátor umožňujúci prejsť zoznam v obrátenom poradí
    
    Pozri tiež:
    
    odzadu()
  - naopak
```
public Zoznam.ObrátenýIterátor<Typ> naopak()
```
    Vytvorí pre tento zoznam prevrátený iterátor. To znamená, že nasledujúci cyklus:
```
Zoznam<String> zoznam = …
for (String prvok : zoznam.naopak()) …
```
    bude vykonaný pre každý prvok zoznamu začnúc od posledného a končiac prvým.
    Parametre:
    
    pôvodný – pôvodný zoznam
    
    Návratová hodnota:
    
    iterátor umožňujúci prejsť zoznam v obrátenom poradí
  - naopak
```
public static <Typ> Zoznam.ObrátenýIterátor<Typ> naopak(List<Typ> pôvodný)
```
    Vytvorí pre zadaný zoznam prevrátený iterátor. To znamená, že nasledujúci cyklus:
```
Zoznam<String> zoznam = …
for (String prvok : Zoznam.<String>naopak(zoznam)) …
```
    bude vykonaný pre každý prvok zoznamu začnúc od posledného a končiac prvým. Jednoduchšie je použitie metódy naopak(), ale tá je použiteľná len pre inštancie triedy Zoznam. Táto metóda je použiteľná pre ľubovoľný zoznam, ktorý je implementáciou rozhrania List.
    Parametre:
    
    pôvodný – pôvodný zoznam
    
    Návratová hodnota:
    
    iterátor umožňujúci prejsť zoznam v obrátenom poradí
    
    Pozri tiež:
    
    naopak()

Trieda Zoznam<Typ>

Prehľad vnorených tried

Prehľad atribútov

Atribúty zdedené z triedy java.util.Vector

Atribúty zdedené z triedy java.util.AbstractList

Prehľad konštruktorov

Prehľad metód

Metódy zdedené z triedy java.util.Vector

Metódy zdedené z triedy java.lang.Object

Metódy zdedené z rozhrania java.util.Collection

Podrobnosti konštruktorov

Zoznam

Zoznam

Zoznam

Zoznam

Zoznam

Podrobnosti metód

kapacita

veľkosť

počet

dĺžka

velkost

pocet

dlzka

prázdny

prazdny

jePrázdny

jePrazdny

pridaj

pridaj

pridaj

vlož

vloz

pridaj

prepíš

prepis

nastav

nahraď

nahrad

vymaž

vymaz

odober

vymaž

vymaz

odober

vymaž

vymaz

odoberOdKonca

vymažOdKonca

vymazOdKonca

odober

obsahuje

počítadlo

pocitadlo

počítadlo

pocitadlo

počítadloNaZačiatok

pocitadloNaZaciatok

počítadloNaKoniec

pocitadloNaKoniec

daj

vráť

vrat

čítaj

citaj

daj

vráť

vrat

čítaj

citaj

aktuálny

aktualny

tento

prvý

prvy

prvýPrvok

prvyPrvok

posledný

posledny

poslednýPrvok