list.arraylist

## Class CircularArrayList

- java.lang.Object
- - list.listinterface.BaseList
  - - list.arraylist.BaseArrayList
    - - list.arraylist.QueueArrayList
      - - list.arraylist.CircularArrayList

- All Implemented Interfaces:
    BaseListInterface, CommonBase, List, QueueList, StackList

      class CircularArrayList
      extends QueueArrayList
      implements List, StackList

  Implementace seznamu kruhovým polem.

  Popis: při vkládání a odebírání se přesunuje mnoho prvků.

  Užití: instance této třídy lze používat v aplikacích.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private int` | `current` index běžného prvku

    - ### Fields inherited from class list.arraylist.QueueArrayList

      `last`

    - ### Fields inherited from class list.arraylist.BaseArrayList

      `first, store`

    - ### Fields inherited from class list.listinterface.BaseList

      `moveCounter`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CircularArrayList(int aSize)` Vyrobí kruhový seznam CircularArrayList.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `append(Element elem)` Vloží elem za poslední prvek seznamu, běžný prvek se neposune.
    `Element` | `getElement()` Vrátí hodnotu běžného prvku.
    `void` | `insert(Element elem)` Vloží elem před běžný prvek.
    `boolean` | `isFirst()` Zjistí, zda běžný prvek je první.
    `boolean` | `isLast()` Zjistí, zda běžný prvek je poslední.
    `void` | `moveFirst()` Učiní první běžným prvkem.
    `void` | `moveLast()` Učiní ocas běžným prvkem.
    `void` | `moveNext()` Učiní následující prvek běžným prvkem.
    `void` | `movePrev()` Učiní předcházející prvek běžným prvkem.
    `void` | `moveTo(int index)` Učiní index-tý prvek běžným prvkem.
    `Element` | `remove()` Odstraní běžný prvek.
    `void` | `setElement(Element value)` Nastaví hodnotu běžného prvku do členu datové struktury.
    `protected void` | `shiftDown(int lb, int ub)` Přesune prvky kruhového pole store o jeden dolů od indexu lb do indexu ub.
    `protected void` | `shiftUp(int lb, int ub)` Přesune prvky kruhového pole store o jeden vzhůru od indexu ub do indexu lb.

    - ### Methods inherited from class list.arraylist.QueueArrayList

      `nextIx, prevIx`

    - ### Methods inherited from class list.arraylist.BaseArrayList

      `getSize`

    - ### Methods inherited from class list.listinterface.BaseList

      `getMoveCounter, resetMoveCounter`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface list.listinterface.BaseListInterface

      `getSize`

    - ### Methods inherited from interface list.listinterface.CommonBase

      `getMoveCounter, resetMoveCounter`

- - ### Field Detail

    - #### current

          private int current

      index běžného prvku

  - ### Constructor Detail

    - #### CircularArrayList

          public CircularArrayList(int aSize)

      Vyrobí kruhový seznam CircularArrayList.
      Parameters:
        `aSize` - kapacita seznamu

  - ### Method Detail

    - #### shiftUp

          protected void shiftUp(int lb,
                                 int ub)

      Přesune prvky kruhového pole store o jeden vzhůru od indexu ub do indexu lb.

      Popis: Přesune prvky s indexy od lb do PrevIx(ub) na indexy od NextIx(lb) do ub. Když lb = ub, nepřesune nic.

      Parameters:
        `lb` - spodní mez, index prvku, který se ztratí, protože bude přepsán, ale sám se už nepřesune
        `ub` - index posledního prvku, který se přesune a sám přepsán nebude

    - #### shiftDown

          protected void shiftDown(int lb,
                                   int ub)

      Přesune prvky kruhového pole store o jeden dolů od indexu lb do indexu ub.

      Popis: Přesune prvky s indexy od NextIx (lb) do ub na indexy od lb do PrevIx (ub). Když lb = ub, nepřesune nic.

      Parameters:
        `lb` - spodní mez, index prvku, který se ztratí, protože bude přepsán, ale sám se už nepřesune
        `ub` - index posledního prvku, který se přesune a sám přepsán nebude

    - #### setElement

          public void setElement(Element value)

      Description copied from interface: `CommonBase`
      Nastaví hodnotu běžného prvku do členu datové struktury.

      Vyžaduje: not isEmpty

      Specified by:
        `setElement` in interface `CommonBase`
      Overrides:
        `setElement` in class `BaseArrayList`
      Parameters:
        `value` - prvek, který má být uložen do členu

    - #### getElement

          public Element getElement()

      Description copied from interface: `CommonBase`
      Vrátí hodnotu běžného prvku.

      Vyžaduje: not isEmpty

      Specified by:
        `getElement` in interface `CommonBase`
      Overrides:
        `getElement` in class `BaseArrayList`
      Returns:
        hodnota běžného prvku

    - #### insert

          public void insert(Element elem)

      Description copied from interface: `List`
      Vloží elem před běžný prvek.

      Vyžaduje: not isFull

      Specified by:
        `insert` in interface `List`
      Specified by:
        `insert` in interface `StackList`
      Parameters:
        `elem` - prvek, který má být vložen

    - #### append

          public void append(Element elem)

      Description copied from class: `QueueArrayList`
      Vloží elem za poslední prvek seznamu, běžný prvek se neposune.

      Popis: Přidá nový prvek do ocasu seznamu. Seznam je zacyklený, takže od prvku s největším indexem přejde k indexu nejmenšímu.

      Užití: Typ výsledku se řídí specializací typu Element.

      Vyžaduje: not isFull

      Splní: not isEmpty

      Mění: přidá nový prvek na konec seznamu.

      Specified by:
        `append` in interface `QueueList`
      Overrides:
        `append` in class `QueueArrayList`
      Parameters:
        `elem` - nový prvek, který se má přidat na konec seznamu

    - #### remove

          public Element remove()

      Description copied from class: `QueueArrayList`
      Odstraní běžný prvek.

      Popis: Odebere prvek, na který odkazuje hlava a do hlavy vloží odkaz na další prvek v seznamu. Seznam je zacyklený, takže po odebrání prvku s největším indexem přejde k indexu nejmenšímu.

      Užití: Typ výsledku se řídí specializací typu Element.

      Vyžaduje: not isEmpty

      Splní: not isFull

      Mění: odebere první prvek z neprázdného seznamu.

      Specified by:
        `remove` in interface `BaseListInterface`
      Overrides:
        `remove` in class `QueueArrayList`
      Returns:
        odstraněný běžný prvek

    - #### moveFirst

          public void moveFirst()

      Description copied from class: `BaseArrayList`
      Učiní první běžným prvkem.

      Popis: nic nedělá, protože hlava seznamu je vždy běžný prvek nebo < High (store) (když seznam je prázdný).

      Specified by:
        `moveFirst` in interface `BaseListInterface`
      Overrides:
        `moveFirst` in class `BaseArrayList`

    - #### moveLast

          public void moveLast()

      Description copied from interface: `List`
      Učiní ocas běžným prvkem.

      Vyžaduje: not isEmpty

      Specified by:
        `moveLast` in interface `List`

    - #### moveNext

          public void moveNext()

      Description copied from interface: `List`
      Učiní následující prvek běžným prvkem.

      Vyžaduje: not isEmpty and not isLast

      Specified by:
        `moveNext` in interface `List`

    - #### movePrev

          public void movePrev()

      Description copied from interface: `List`
      Učiní předcházející prvek běžným prvkem.

      Vyžaduje: not isEmpty and not isFirst

      Specified by:
        `movePrev` in interface `List`

    - #### moveTo

          public void moveTo(int index)

      Description copied from interface: `List`
      Učiní index-tý prvek běžným prvkem.

      Vyžaduje: not isEmpty and (index in [0..Pred(getSize)])

      Specified by:
        `moveTo` in interface `List`
      Parameters:
        `index` - pořadové číslo prvku, který má být běžný (čísluje se od 0?)

    - #### isFirst

          public boolean isFirst()

      Description copied from interface: `List`
      Zjistí, zda běžný prvek je první.

      Vyžaduje: not isEmpty

      Specified by:
        `isFirst` in interface `List`
      Returns:
        true když je první, jinak false

    - #### isLast

          public boolean isLast()

      Description copied from interface: `List`
      Zjistí, zda běžný prvek je poslední.

      Vyžaduje: not isEmpty

      Specified by:
        `isLast` in interface `List`
      Returns:
        true když je poslední, jinak false