Java - seznam

 public boolean vlozVec(Vec vec) {
        // bude treba pregenerovat equals() a hashcode() ve tride Vec, ale je to elegantnejsi reseni, nez porad prochazet seznam
        if (!seznamVeci.contains(vec)){
        	seznamVeci.add(vec);
        	return true;
        }
    	return false;
    }

    public Vec odeberVec(String vec) {
        for (Vec cokoli2: seznamVeci) {
            if (cokoli2.getNazev().equals(vec)) { //nefunguje vec.getNazev, proč???(nepřeloží překladač)
                // protoze vec je v tomto pripade String, nema tedy metodu getNazev()...
                seznamVeci.remove(cokoli2);
                return cokoli2;
            }
        }
		return null;
    }

3 poradím až uvidím, jak vypadá třída Vec...

1) Nádhera - my jsme to dělali v hodinách vždy procházením, jaktože zde ho netřeba procházet?
"if (!seznamVeci.contains(vec))" - Nebo ho toto prochází též? - "Pokud seznamVeci neobsahuje vec, tak přidej věc" - tak jsem seznam musel projít, ne?
- jenom, jak by to vypadalo přes to procházení seznamu?

2)
Ale já když prohlížím seznamVeci, tak tam vidím i instance, které jsem právě odebral.

3)
V konstruktoru "věc"i si volíme "boolean sebratelna" a "String nazevVeci". Pak je přidáváme do seznamu v "Mistnost"

Vec.java

package cz.technecium;

public class Vec {

	private final String nazev;
	private final boolean sebratelna;

	public Vec(String nazev, boolean sebratelna){
		this.nazev = nazev;
		this.sebratelna = sebratelna;
	}

	public String getNazev() {
		return nazev;
	}
	
	public boolean isSebratelna() {
		return sebratelna;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((nazev == null) ? 0 : nazev.hashCode());
		result = prime * result + (sebratelna ? 1231 : 1237);
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Vec other = (Vec) obj;
		if (nazev == null) {
			if (other.nazev != null)
				return false;
		} else if (!nazev.equals(other.nazev))
			return false;
		if (sebratelna != other.sebratelna)
			return false;
		return true;
	}
}

Mistnost.java

package cz.technecium;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Mistnost
{
    //== Datové atributy (statické i instancí)======================================
    public List<Vec> seznamVeci = new ArrayList<Vec>();
    public String nazevMistnosti;

    //== Konstruktory a tovární metody =============================================
    public Mistnost(String nazevMistnosti) {
        this.nazevMistnosti = nazevMistnosti;
    }

    //== Nesoukromé metody (instancí i třídy) ======================================

    public boolean vlozVec(Vec vec) {
        if (!seznamVeci.contains(vec)){
        	seznamVeci.add(vec);
        	return true;
        }
    	return false;
    }
    
    public boolean vlozVecItr(Vec vec){
    	for (Vec v : seznamVeci){
    		if (v.getNazev().equals(vec.getNazev())){
    			return false;
    		}
    	}
    	seznamVeci.add(vec);
    	return true;
    }

    public Vec odeberVec(String vec) {
        for (Vec cokoli2: seznamVeci) {
            if (cokoli2.getNazev().equals(vec)) { //nefunguje vec.getNazev, proč???(nepřeloží překladač)
                seznamVeci.remove(vec);
                return cokoli2;
            }
        }
		return null;
    }

    public Collection<Vec> sebratelneVeci() {
        Collection<Vec> ret = new ArrayList<Vec>();
        for (Vec v : seznamVeci){
        	if (v.isSebratelna()){
        		ret.add(v);
        	}
        }
        return ret;
    }

    //== Soukromé metody (instancí i třídy) ========================================
}

Když použiješ contains, tak už procházet nemusíš protože ten průchod je už v metodě contains... Pokud chceš používat tu verzi s tím contains, musíš mít ve třídě Vec překryté metody hashcode a equals.

Geniální ... snad i všemu rozumím, ale chci se ujistit.

Raději použiju opět procházení seznamu, hrabání se v HashCodu nebo Equals bych evidentně schopný nebyl.
Zadáno bylo takto(ve třídě "Vec"), ale tuto třídu nemáme měnit(naštěstí :) ):

    @Override
    public boolean equals(Object o) {
        if (o instanceof Vec) {
            Vec druha = (Vec) o;
            return nazev.equals(druha.nazev);
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        return nazev.hashCode();
    }

Ale ještě mám otázečky:
K druhé metodě: Změnil jsem seznamVeci.remove(cokoli2); ... protože "String vec" remove nemaže instanci.
Ke třetí metodě: Jsem si raději okomentoval - chápu to správně, když je isSebratelna() false, tak jakoby není???

    public Collection<Vec> sebratelneVeci() {
        Collection<Vec> ret = new ArrayList<Vec>(); //vytvoření kolekce "ret" = nový seznam
        for (Vec v : seznamVeci){ //projdi seznam, hledám v
            if (v.isSebratelna()){ //v je sebratelná - kde rozlišuje true nebo false???
                ret.add(v); //přidej v do "ret"
            }
        }
        return ret; //vrať kolekci
    }

A poslední otázka: Jak bych udělal abych přes konstrukor určil maximum seznamu, například aby seznam mohl mít například nejvýše 5 věcí.

//Datový atribut
public int maximum;
//Konstrukor
public Mistnost(int maximum) {
        this.maximum = maximum;
}

Snad už přestanu otravovat. Jinak velké díky, M.

K druhé metodě: Změnil jsem seznamVeci.remove(cokoli2); ... protože "String vec" remove nemaže instanci.

Ano, tak je to správně. Máš kolekci instancí Vec a vlastně odebíráš instanci String. Ta tam samozřejmě není...

Ke třetí metodě: Jsem si raději okomentoval - chápu to správně, když je isSebratelna() false, tak jakoby není???

Ano. Nemusíš testovat isSberatelna() == true. V Javě se stačí zeptat if (isSberatelna), pokud bude false, tak to do toho ifu neskočí. Jinak je to ok.

A poslední otázka: Jak bych udělal abych přes konstrukor určil maximum seznamu, například aby seznam mohl mít například nejvýše 5 věcí

To je trochu problém, ArrayList je v Javě dynamická datová struktura, takže nemá omezenou kapacitu. Musel bys při přidávání prvku kontrolovat jestli seznamVeci.size() == maximum, pokud ano, tak prvek nepřidat.

Nebo použij klasické pole a jeho velikost si naalokuj podle parametru maximum.

Zdravím,

nakonec jsme měli omezovat přesně přes zmínění .size().

Jediné co jsem v testu nevěděl, bylo testování výpisu seznamu. > ?

    @Test
    public void test_vraciSeznamVse() {
        Zastavka zastavka1 = new Zastavka(100, "a"); //+další
        SeznamZastavek seznamZa1 = new SeznamZastavek();
        assertEquals(true, seznamZa1.pridejZastavku(zastavka1));//+další
        assertEquals( -->>??COZDE??<<-- , seznamZa1.seznamZastavek()); //"zastavka1, zastavka2, zastavka3", true, 3, "3"
    }

Ještě otázečka: jaký je rozdíl mezi length() a size()? Vím, že jsme někde používala length(snad u polí, teď nevím), také jsem to nejdřív zkoušel a nefungoval to zde u toho seznamu. Jediné, co mě napadá, je, že length je délka něčeho omezeného(polí (Nebo pole mohou být i neomezená?)), zatímco size(se nastavuje něčemu co nemá length(seznam) -> pak ale nevím jaké je rozdíl u polí mezi length a size ... jen moje úvaha.

Předem díky, M.

lenght - je typicky u polí, které mají danou délku, zadává se už při alokaci a vrací pořád stejnou hodnotu
size() - vrací počet prvku které jsou skutečně v dané kolekci (u polí není)

Ten unit test má testovat co? Metodu seznamZastavek(), která vrací celý seznam? Pokud ano, tak:

@Test
    public void test_vraciSeznamVse() {
        // vytvoříme treba tri zastavky
        Zastavka zastavka1 = new Zastavka(100, "a");
        Zastavka zastavka2 = new Zastavka(100, "b");
        Zastavka zastavka3 = new Zastavka(100, "c");

        // vytvorime seznam zastavek
        SeznamZastavek seznamZa1 = new SeznamZastavek();

        // pridame zastavky do seznamu
        seznamZa1.pridejZastavku(zastavka1));
        seznamZa1.pridejZastavku(zastavka2));
        seznamZa1.pridejZastavku(zastavka3)); 
        
        // zkontrolujeme, ze jsou v seznamu 3 zastavky
        assertEquals( 3 , seznamZa1.seznamZastavek().size() ));

        // zkontrolujeme, ze jsou v seznamu, ty zastavky, ktere jsme tam pridali
        assertEquals( zastavka1, seznamZa1.seznamZastavek().get(0));
        assertEquals( zastavka2, seznamZa1.seznamZastavek().get(1));
        assertEquals( zastavka3, seznamZa1.seznamZastavek().get(2));
    }

Tak by to snad mohlo stačit...

PS: Předpokládám, že seznamZastavek() vrací aspon Collection.

Díky.
Je to přesně, jak říkáš, Collection seznamuZastávek.

assertEquals( 3 , seznamZa1.seznamZastavek().size() ); // krása

assertEquals( zastavka1, seznamZa1.seznamZastavek().get(0)); // hláška: cannot find symbol - method get(int) - pozice by měli souhlasit.
assertEquals( zastavka2, seznamZa1.seznamZastavek().get(1));
assertEquals( zastavka3, seznamZa1.seznamZastavek().get(2));

Ještě bych prosil pomoc k seznamu s jedním cyklem. On teda nakonec snad funguje ve všech případech, ale přijde mi to strašně kostrbatý, přímo hranatý :).

/**
* 1) Nelze přidat hráče s číslem dresu, který již v týmu existuje.
* 2) Pokud má hráč číslo dresu nula, tak se mu přiřadí první volné číslo dresu.
* - "hrac" má defaultně getCislo()0, ale můe mu být nastavena, pak se čísla nesmí opakovat
*/
    public boolean pridejHrace(Hrac hrac) {
        if(hrac.getCislo() == 0) {
            hrac.setCislo(1);
            for(int i = 1; i <= 99; i++) {
                for(Hrac cokoli1: seznamHracu) {
                    if(cokoli1.getCislo() == hrac.getCislo()) {
                        System.out.println(i+1);
                        hrac.setCislo(i+1);
                    }
                }
            }
        }
        for(Hrac cokoli1: seznamHracu) {
            if(cokoli1.getCislo() == hrac.getCislo()) {
                return false;
            }
        }
        seznamHracu.add(hrac);
        return true;
    }

Tím bych snad už mohl Vám dát odpočinout a skončit otravovat se seznamy (možná za čas s něčím jiným :) vtip :) )

M

private int getFreePlayerNumber(){
  int playerNumber = seznamHracu.get(0).getCislo();
  for (int i = 1 ; i < seznamHracu.size() ; i++){
    Hrac h = seznamHracu.get(i);
    if (h.getCislo() > playerNumber){
       playerNumber = h.getCislo(); 
    }
  }
  return playerNumber + 1;
}

private boolean containsPlayerWithNumber(int playerNumber){
  for(Hrac cokoli1: seznamHracu) {
            if(cokoli1.getCislo() == playerNumber) {
                return true;
            }
        }
  return false;
}

public boolean pridejHrace(Hrac hrac) {
  if (!containsPlayerWithNumber(hrac.getCislo()){
      if (hrac.getCislo() == 0){
          hrac.setCislo(getFreePlayerNumber());
          seznamHracu.add(hrac);
          return true;
      }
      else{
          seznamHracu.add(hrac);
          return true;
      }
  }
   return false;
}

Snad... píšu z hlavy, bez kompilátoru...

Reakce 1:
No :), možná je něco blbě u mě, ale opět nic - "variable zastavky might not have been initialized"
I přes rýpání jsem to nějak nebyl schopen zprovoznit.

Ze třídy seznamZastavek: Datový atribut + metoda.

public ArrayList<Zastavka> seznamZastavek = new ArrayList<Zastavka>();

    public Collection<Zastavka> seznamZastavek() {
        return seznamZastavek; //+ další metody(přidat hráče, odebrat, atd.)
    }

Reakce 2:
Ehmm, já dávám těch mých 15 řádků dohromady půl dne, a Vy máte román za 5 minut :) no.
Nicméně, pokud má být toto jednodušší :) ... ono to právě má být v jedné metodě, aby se kliklo na přidat hráče, a "všechno se to udělalo samo"
-> Ale klidně toto nechte být -> nesejde na tom, hlavně že to "nějak" funguje :)
-> Já jen jestli v tom mém není nějaká základní logická chyba
-->> re:3metody: Hlásilo to nějaké chyby, vůbec mi to něchtělo přidat(možná to chtělo datový atribut(nevím)), rozeberu si to zítra, pokud ten kod vůbec zcela pochopím.

Zatím dík, dneska + pár hodin už ty kody nech´t zmizí ze světa :)

M

1)
Stačí udělat Zastavka[] zastavky = null;

2)Tvoje metoda funguje jenom do 99, a navíc nevím jestli dobře... Tady máš odzkoušený a okomentovaný kód, včera jsem tam měl chybu.
Hrac.java

public class Hrac {

    private int cislo;

    public Hrac(int cislo) {
        this.cislo = cislo;
    }

    public int getCislo() {
        return cislo;
    }

    public void setCislo(int number) {
        this.cislo = number;
    }
}

SeznamHracu.java

import java.util.ArrayList;
import java.util.List;

public class SeznamHracu {

    private List<Hrac> seznamHracu = new ArrayList<Hrac>();

    // pomocna metoda
    // najde maximalni cislo v seznamu hracu a vrati o jedno vetsi
    private int getFreePlayerNumber() {
        // pokud je seznamhracu prazdny vratime nulu
        if (seznamHracu.size() == 0) {
            return 0;
        }

        // docasne si ulozime cislo prvniho hrace v seznamu
        int playerNumber = seznamHracu.get(0).getCislo();

        // projdeme seznam od druheho hrace
        for (int i = 1; i < seznamHracu.size(); i++) {
            // aktualni hrac
            Hrac h = seznamHracu.get(i);
            // pokud je cislo aktualniho hrace vetsi, nez docasne ulozene cislo
            // aktualizujeme docasne ulozene cislo
            // typicky zpusob hledani maxima
            if (h.getCislo() > playerNumber) {
                playerNumber = h.getCislo();
            }
        }

        // ted by melo byt v playerNumber maximalni cislo hrace v seznamu
        // vracime o jedno vice
        return playerNumber + 1;
    }

    // pomocna metoda, zjistuje jestli uz je v seznamu hrac
    // s urcitym cislem
    private boolean containsPlayerNumber(int playerNumber) {
        for (Hrac cokoli1 : seznamHracu) {
            if (cokoli1.getCislo() == playerNumber) {
                return true;
            }
        }
        return false;
    }

    // prida hrace
    public boolean pridejHrace(Hrac hrac) {
        // je cislo hrace ktereho chceme pridat 0?
        if (hrac.getCislo() == 0) {
            // mame uz hrace s 0 v seznamu?
            if (containsPlayerNumber(0)) {
                // pokud ano, dame mu jine cislo
                hrac.setCislo(getFreePlayerNumber());
            }
            // pridame hrace do seznamu.
            seznamHracu.add(hrac);
            return true;
        }

        // obsauje seznam cislo hrace, ktereho chceme pridat?
        if (!containsPlayerNumber(hrac.getCislo())) {
            // pokud ne, muzem pridat
            seznamHracu.add(hrac);
            return true;
        }
        // hrac je v seznamu, nepridavame nic, vracime false
        return false;
    }

    public static void main(String[] args) {
        SeznamHracu s = new SeznamHracu();
        s.pridejHrace(new Hrac(2));
        s.pridejHrace(new Hrac(1));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(0));

        // v seznamu budou hraci s cisly 2, 1, 0 a 3
    }
}

Těch privátních metody se neboj, nebudou na venek vidět. Dělám je proto, aby byl kód přehlednější a implementace metod co nejkratší.

EDIT: No, teď vidím i v tom mém řešení potenciální problém:
1) přidám hráče s číslem 1, přidá se
2) přidám hráče s číslem 34, přidá se
3) přidám hráče s číslem 0, přidá se s číslem 35
4) přidám dalšího hráče s číslem 0, přidá se s číslem 36

chtělo by to vychytat, ale zadání to myslím splňuje...

SeznamHracu.java verze 1.1

import java.util.ArrayList;
import java.util.List;

public class SeznamHracu {

    private List<Hrac> seznamHracu = new ArrayList<Hrac>();

    // pomocna metoda
    // najde maximalni cislo v seznamu hracu a vrati o jedno vetsi
    private int getIncrementedMaxPlayerNumber() {
        // pokud je seznamhracu prazdny vratime nulu
        if (seznamHracu.size() == 0) {
            return 0;
        }

        // docasne si ulozime cislo prvniho hrace v seznamu
        int playerNumber = seznamHracu.get(0).getCislo();

        // projdeme seznam od druheho hrace
        for (int i = 1; i < seznamHracu.size(); i++) {
            // aktualni hrac
            Hrac h = seznamHracu.get(i);
            // pokud je cislo aktualniho hrace vetsi, nez docasne ulozene cislo
            // aktualizujeme docasne ulozene cislo
            // typicky zpusob hledani maxima
            if (h.getCislo() > playerNumber) {
                playerNumber = h.getCislo();
            }
        }

        // ted by melo byt v playerNumber maximalni cislo hrace v seznamu
        // vracime o jedno vice
        return playerNumber + 1;
    }

    // pomocna metoda vrati prvni volne cislo
    private int getFirstFreePlayerNumber() {
        // volne bude urcite cislo, ktere vrati metoda getIncrementedMaxPlayerNumber()
        int freeNumber = getIncrementedMaxPlayerNumber();
        // pole pouzitych cisel, pouzijem freeNumber at nemusime 2x volat getIncrementedMaxPlayerNumber()
        int[] usedNumbers = new int[freeNumber];

        // v poli usedNumbers na pozici h.getCislo() si udelame znacky
        // ktera cisla mame pouzite
        for (Hrac h : seznamHracu) {
            // znacka -1
            usedNumbers[h.getCislo()] = -1;
        }

        // hledame prvni nulu v poli
        // pouzite jsou -1
        for (int i = 0; i < usedNumbers.length; i++)
            if (usedNumbers[i] == 0) {
                // prvni nula je na pozici i, nastavujeme i jako volne cislo
                freeNumber = i;
                // koncime cyklus
                break;
            }
        // vracime cislo
        return freeNumber;
    }

    // pomocna metoda, zjistuje jestli uz je v seznamu hrac
    // s urcitym cislem
    private boolean containsPlayerNumber(int playerNumber) {
        for (Hrac cokoli1 : seznamHracu) {
            if (cokoli1.getCislo() == playerNumber) {
                return true;
            }
        }
        return false;
    }

    // prida hrace
    public boolean pridejHrace(Hrac hrac) {
        // je cislo hrace ktereho chceme pridat 0?
        if (hrac.getCislo() == 0) {
            // mame uz hrace s 0 v seznamu?
            if (containsPlayerNumber(0)) {
                // pokud ano, dame mu prvni volne cislo
                hrac.setCislo(getFirstFreePlayerNumber());
            }
            // pridame hrace do seznamu.
            seznamHracu.add(hrac);
            return true;
        }

        // obsauje seznam cislo hrace, ktereho chceme pridat?
        if (!containsPlayerNumber(hrac.getCislo())) {
            // pokud ne, muzem pridat
            seznamHracu.add(hrac);
            return true;
        }
        // hrac je v seznamu, nepridavame nic, vracime false
        return false;
    }

    public static void main(String[] args) {
        SeznamHracu s = new SeznamHracu();
        s.pridejHrace(new Hrac(2));
        s.pridejHrace(new Hrac(1));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(34));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(35));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(6));
        s.pridejHrace(new Hrac(0));
        s.pridejHrace(new Hrac(47));
        s.pridejHrace(new Hrac(0));

        // v seznamu budou hraci s cisly 2, 1, 0, 3, 34, 4, 35, 5, 6, 7, 47, 8 :-)
    }
}

Tady je vidět, jak celkem jednoduchý problém může být záludný...

1) Překladač OK. Ale test skončí nezdarem :).

Zastavka[] zastavky = null;
seznamZa1.seznamZastavek().toArray(zastavky);
assertEquals( zastavka1, zastavky[0]);
assertEquals( zastavka2, zastavky[1]);
assertEquals( zastavka3, zastavky[2]);

Samotný první řádek testu projde, s jakýmkoliv dalším už ne.

2) Počítám jen do 99, protože na dresu bývají jen dvě čísla :). Taky mi to nejdřív počítalo jako ve vaší verzi 1.0.
Jinak to Vaše funguje krásně, radši jsem si na to udělal novou třídu, už se mi to tam motalo :).
Dokonce i System.out.println u Vás vypisuje krásně jedno číslo, ne jak u mě, proto jsem si právě nebyl jist, protože mně vypisuje i čísla, která prochází, ačkoliv v set()u se objeví správné .). (Vlastně ve Vaší metodě getFirstFreePlayerNumber() System.out.printl vypisuje též dvě čísla, to by nemělo, ne?, ale nevím)

Ale toto je pro mě zatím moc, některé konstrukce jsem zatím ani neviděl, natož abych je vytvořil.

Pokusím se zjistit řešení 2), tak uvidíme :).