kodovi/stek-i-red-opsluzivanja/Red.java

   1 /**
   2  * Tip podataka red opsluživanja, koji omogućava skladištenje podataka u skladu
   3  * sa principom "prvi unutra, prvi napolje".
   4  *
   5  * <p>
   6  * Ova klasa koristi niz za skladištenje podataka, te je samim tim ograničena i
   7  * moguće je da metod za dodavanje elemenata baci izuzetak u slučaju da više
   8  * nema mesta.
   9  * </p>
  10  *
  11  * @version v1.0.0
  12  *
  13  * @param <T>
  14  *            Tip podataka koji će se čuvati u konkretnoj instanci reda
  15  *            opsluživanja.
  16  */
  17 public class Red<T> {
  18         /**
  19          * Separator vrednosti u {@code toString} metodu: {@value} .
  20          */
  21         public static final String SEPARATOR = ", ";
  22
  23         private int prvi, poslednji;
  24         private T[] elementi;
  25
  26         /**
  27          * Veličina redova za koje nije prosleđen parametar o veličini. Konkretna
  28          * vrednost je {@value} .
  29          */
  30         public static final int PODRAZUMEVANA_VELICINA = 100;
  31
  32         /**
  33          * Kreira novi red opsluživanja podrazumevane veličine
  34          * {@value #PODRAZUMEVANA_VELICINA}.
  35          */
  36         public Red() {
  37                 this(PODRAZUMEVANA_VELICINA);
  38         }
  39
  40         /**
  41          * Kreira novi red opsluživanja zadate veličine.
  42          *
  43          * @param n
  44          *            broj elemenata koji red opsluživanja može maksimalno da primi.
  45          */
  46         // poželjno koristiti Suppress da kompajliranje ne prijavljuje upozorenja
  47         @SuppressWarnings("unchecked")
  48         public Red(int n) {
  49                 prvi = -1;
  50                 poslednji = -1;
  51                 elementi = (T[]) (new Object[n]);
  52         }
  53
  54         /**
  55          * Pomoćni metod za zadržavanje indeksa niza u opsegu. Metod uvek vraća
  56          * indeks sledećeg elementa u odnosu na onaj koji je prosleđen. Sledeći
  57          * element je za jedno mesto više od trenutnog, osim za poslednji kome je
  58          * sledeći prvi.
  59          *
  60          * @param i
  61          *            indeks elementa za koji se traži sledeći
  62          * @return indeks elementa koji je posle onog koji je prosleđen.
  63          */
  64         private int dodajJedan(int i) {
  65                 return (i + 1) % elementi.length;
  66         }
  67
  68         /**
  69          * Vraća da li je red prazan.
  70          *
  71          * @return da li je red prazan
  72          */
  73         public boolean jePrazan() {
  74                 return poslednji == -1;
  75         }
  76
  77         /**
  78          * Vraća da li je red pun.
  79          *
  80          * @return da li je red pun
  81          */
  82         public boolean jePun() {
  83                 return dodajJedan(poslednji) == prvi;
  84         }
  85
  86         /**
  87          * Vraća vrednost elementa na početku reda opsluživanja. Ukoliko je red
  88          * prazan baca se izuzetak.
  89          *
  90          * @return vrednost elementa na početku reda opsluživanja
  91          */
  92         public T prvi() {
  93                 if (jePrazan())
  94                         throw new IllegalStateException("Red je prazan");
  95                 else
  96                         return elementi[prvi];
  97         }
  98
  99         /**
 100          * Izbacuje element sa početka reda opsluživanja i vraća ga. Ukoliko je red
 101          * prazan baca se izuzetak.
 102          *
 103          * @return vrednost elementa koji je bio na početku reda opsluživanja
 104          */
 105         public T izbaciPrvi() {
 106                 if (jePrazan()) {
 107                         throw new IllegalStateException("Red je prazan");
 108                 } else {
 109                         T el = elementi[prvi];
 110                         if (prvi == poslednji) {
 111                                 prvi = -1;
 112                                 poslednji = -1;
 113                         } else
 114                                 prvi = dodajJedan(prvi);
 115                         return el;
 116                 }
 117         }
 118
 119         /**
 120          * Ubacuje prosleđeni element na kraj reda opsluživanja. Ukoliko je red već
 121          * pun baca se izuzetak.
 122          *
 123          * @param x
 124          *            element koji će biti ubačen na kraj reda
 125          */
 126         public void naKraj(T x) {
 127                 if (jePun())
 128                         throw new IllegalStateException("Red je pun");
 129                 else {
 130                         if (jePrazan()) {
 131                                 prvi = 0;
 132                                 poslednji = 0;
 133                         } else
 134                                 poslednji = dodajJedan(poslednji);
 135                         elementi[poslednji] = x;
 136                 }
 137         }
 138
 139         /**
 140          * Vraća String reprezentaciju ovog Reda. Reprezentacija će sadržati
 141          * najviše 4 elementa iz reda, tačnije najviše prva dva i poslednja dva,
 142          * razdvojenih sa {@value #SEPARATOR}, a ukoliko ima više od 4 elementa biće
 143          * dodato i "..." između prvih i poslednjih elemenata.
 144          */
 145         public String toString() {
 146                 String rez = "Red:";
 147
 148                 if (jePrazan()) {
 149                         rez += "prazan";
 150                 } else {
 151                         rez += elementi[prvi];
 152                         if (prvi != poslednji) {
 153                                 int drugi = dodajJedan(prvi);
 154                                 rez += SEPARATOR + elementi[drugi];
 155                                 if (drugi != poslednji) {
 156
 157                                         int predposlednji = poslednji - 1;
 158                                         if (poslednji == 0) {
 159                                                 predposlednji = elementi.length - 1;
 160                                         }
 161
 162                                         if (predposlednji != drugi) {
 163                                                 if (dodajJedan(drugi) != predposlednji) {
 164                                                         rez += SEPARATOR + "...";
 165                                                 }
 166                                                 rez += SEPARATOR + elementi[predposlednji];
 167                                         }
 168                                         rez += SEPARATOR + elementi[poslednji];
 169                                 }
 170                         }
 171                 }
 172                 return rez;
 173         }
 174 }