PROBLEMA Java e il gioco scopa

[fedi98]

Suggerisco un'alternativa migliore: usa un semplice array (non un ArrayList) di oggetti di tipo carta da gioco, l'array rappresenta un mazzo
riempi il mazzo con le carte in modo ordinato:
nella posizione 0 l'asso di denari (o un altro seme che ti piace),
nella posizione 1 il 2 di denari...nella posizione 9 il 10 di denari
fai lo stesso con gli altri semi
alla fine hai un mazzo perfettamente ordinato

adesso devi "mischiare" il mazzo:
per "mischiare" 2 carte ti basta generare 2 numeri interi compresi tra 0 e 39 (gli indici dell'array), per esempio la prima volta generi 5 e 30;
scambia gli oggetti puntati da questi indici: in questo modo avrai (per esempio) che all'indice 5 (precedentemente occupato dal 6 di denari) ci metti l'indice 30 (l'asso di bastoni se bastoni è l'ultimo seme); viceversa, all'indice 30 va a finire il 6 di denari.
Se fai un ciclo da un centinaio (o più) di generazioni random di coppie di interi e, ad ogni passo, esegui lo scambio delle carte ai rispettivi indici, alla fine del ciclo avrai un array di carte competamente (pseudo) casuale; in questo modo non è più un problema se verrà generato più volte lo stesso intero pseudocasuale perché ogni volta la carta puntata scambierà la posizione con un'altra carta (d'altra parte è quasi compeltamente impossibile che generi 2 volte di seguito la stessa coppia casuale di interi).
Alla fine di questo procedimento hai una mazzo mischiato come nella realtà.

Cosa si fa dopo nella realtà?
prima si mischia un mazzo e poi le carte vengono distribuite in ordine, ed è quello che fai tu:
dai le carte tre a 3 nello stesso ordine in cui sono nel mazzo mischiato!
per esempio se giochi in 2 dai le carte di indice 0,1,2 al primo giocatore, poi dai le carte di indice 3,4,5 al secondo giocatore
poi metti le 4 carte per terra (indici 6,7,8,9)
a questo punto hai bisogno di una variabile intera che "ricorda" a quale indice sei arrivato:
dopo la prima mano al giocatore-1 dai le carte di indice 10,11,12 e la giocatore 2 quelle di indice 13,14,15

Se fai come ti ho suggerito non avrai più problemi di generazione della stessa carta, eviti l'operazione di eliminazione di carte da un ArrayList e il mazzo mischiato si può anche riusare senza essere per forza creato ordinato.

Come risposta è interessante, ma credo che richieda più tempo sia di esecuzione che di per programmarla.
Comunque non è necessario creare una nuova classe per fare il tutto , anzi secondo me non si deve fare: basta una semplice funzione. Detto questo provo ad abbozzarti due righe di codice perchè mi sembra di capire che non sei particolarmente esperto (nemmeno io).

private ArrayList lista =new ArrayList();
private  void daiCarteDisordinate(int value){
    //l' arrayList deve essere già riempito prima che venga chamata questa funzione
    //value indica quante carte devi estrarre random: ovviamente siccome fai cose diverse con ogni carta devi vedere in base al
    // programma come darle in maniera compatta
    for(int i=0;i<value;i++){
        int indice=(int) (new Random().nextDouble())* lista.size();
        Object o = lista.get(indice);
        // a questo punto o contiene la tua carta, facci quello che vuoi
        lista.remove(indice);
    }
}

ovviamente il codice può e deve essere adattato in base alle esigenze del programma, ma penso che con quelle 3 righe si risolva facilmente il problema
Inoltre ricordati di specificare nella lista l' oggetto che sono le tue carte (quindi tipo ArrayList<MioOggettoCarta>

 

[Mursey]

Il parametro value potrebbe non servire impostando quel valore leggendolo da lista.size()

 

[DarkGast]

Grazie a tutti ancora per l'aiuto.Ho provato a capire il tuo codice e potrebbe anche funzionare,l'unico problema é che non capisco come posso creare una lista senza dire che cosa ci sia dentro. Oltretutto ancora una domanda,io ho adesso larray in una classe,e il "gioco" diciamo in un altra.In questo momento sto generando i numeri random nella classe del gioco per é li che ho i jlabel, e anche per questo non potevo rimuovere gli elementi dentro larray.Quindi posso generare questo numero nella classe dell'array e poi tramite variabile (?) spostare questo valore nella classe del gioco per generare la carta?

 

[Mursey]

Direi che c'e' qualche confusione sull'uso delle classi...
Probabilmente il tuo codice non ne ha bisogno, quindi potresti alleggerirlo un po'...

Se invece vuoi tenerle, meglio se ti leggi http://pages.di.unipi.it/corradini/Didattica/LIP-07/SviluppoClassi/Statici/main.html

 

[icox]

Secondo me stai facendo un po' di confusione con le classi.
Io ti suggerirei ti creare una classe per ogni "oggetto" che intendi rappresentare.
Quindi per esempio una classe Carta, Giocatore, Gioco, ...
Per semplificare le cose potresti pensare ad una struttura comune che mantiene le Carte.
Se ci pensi, nella realta' hai un mazzo, le carte in tavole, quelle in mano ai giocatori e le loro prese. Questi non sono altro che "insiemi di carte", con caratteristiche diverse, ma con una cosa in comune: sono tutti composti dallo stesso elemento, la carta.
Quindi potresti crearti una classe "Stack" che rappresenta il concetto di "insieme di carte" e su di esso implementare delle operazioni comuni, come ad esempio "aggiungiCarta" che, data una carta, la aggiunge all'insieme di quelle esistenti. In questo modo non devi preoccuparti di come e' fatta la struttura, la crei la prima volta e poi la riutilizzi dove ti serve senza dover ogni volta riscrivere il codice.

Io abbozzerei una cosa del genere, vedi se puo' tornarti utile.

public class Carta {
   private String seme;
   private int valore;
   ...

   public Carta() {  //costruttore }

   public String getSeme() {
      return this.seme
   }

   public int getValore() {
      return this.valore;
   }

   ...

public class Stack {
   private ArrayList<Carta> carte;
   ...

   public Stack() {  //costruttore }

   public Carta getCarta() {
      //cerca la prima carta 'disponibile'
      //toglila dalla struttura dati e ritornala
   }

   public void aggiungiCarta(Carta c) {
      //aggiungi la Carta c all'insieme delle carte (this.carte)
   }

   public void mischia() {
      //mischia le carte dentro la struttura this.carte
   }
 
   ...

public class Giocatore {
   private String nome;
   private Stack mano; //insieme di carte che il giocatore ha "in mano"
   private Stack prese; //insieme di carte che mantiene tutte le carte prese dal giocatore
   ...

   public Giocatore() {  //costruttore }

   public void prendiCarta(Carta c)  {
      //aggiungi la Carta c all'insieme delle carte che ha "in mano" il giocatore (this.mano)
   }

   public Carta giocaCarta() {
      //prendi la Carta voluta dall'insieme di carte che ha in mano.
      //rimuovila dalla struttura e ritornala
   }

   public void addPresa(ArrayList<Carta> presa) {
      //aggiungi tutte le carte in 'presa' all'insieme delle carte "prese" del giocatore
   }

   public int getPunti() {
      //ciclo per contare i punti
   }

   ...

public class Gioco {
   private Stack mazzo; //insieme di carte che rappresenta il mazzo
   private Giocatore giocatore1;
   private Giocatore giocatore2
   private Stack tavolo; //insieme di carte che rappresenta quelle presenti sul tavolo
   ...

   public Gioco() {
      //inizializza this.mazzo, per esempio inserendo tutte le Carte e chiamando mazzo.mischia()
   }

   public void distribuisciCarte() {
      //prendi 3 carte da this.mazzo e dalle ai giocatori (giocatore.prendiCarta(Carta))
      //prendi 4 carte e mettile sul tavolo (this.tavolo.add(Carta));
   }

In questo modo demandi la gestione delle carte alla classe Stack, che implementi una sola volta e poi usi tramite i metodi 'aggiungiCarta', 'getCarta', ecc. Rimuovendo/aggiungendo gli oggetti Carta ai vari Stack e' come se spostassi le carte, proprio come avviene in una partita reale; dal mazzo alcune carte vanno ai giocatori, che a loro volta le prendono per metterle nelle loro prese, ecc.

E' una soluzione grezza perche' Stack fa un po' di tutto, comprese operazioni che non hanno senso in tutti i contesti (ad esempio a un giocatore non serve mischiare le proprie carte), ma ti semplifica inizialmente il lavoro.
Successivamente potresti partire da Stack intendola come classe di base con operazioni comuni ed estendendo Stack su altre classi, per esempio Mazzo: in questo modo Mazzo avra' tutti i metodi di Stack (per esempio aggiungiCarta) ma poi potrebbe definire metodi specifici, come ad esempio mischia() che ha senso solo per il mazzo. Idem per giocatore, tavolo ecc... Potrebbe essere un buon esercizio per capire concetti come l'ereditarieta', ma per il momento ti sconsiglierei di tenerne conto e lasciarlo per approfondimenti futuri.

Forse inizialmente ti conviene svillupare la logica senza UI, cosi da concentrarti sulle funzioni di base. Una volta che riesci a gestire gli "spostamenti" delle carte fra le varie classi ci applichi una UI, la quale non dovra' fare altro che "leggere" lo stato delle strutture Stack nelle varie classi e quindi mostrare graficamente tale stato.

 

[DarkGast]

Vi ringrazio ad entrambi.Ho provato a scrivere il codice,ho iniziato con la classe carta:

public class Carta
{
  private String seme;
  private int valore;
  private String nome;

  public Carta()
  {
    this.valore = valore;
    this.nome = nome;
    this.seme= seme;
  }
 
  public String getSeme()
  {
    return seme;
  }
 
  public int getValore()
  {
    return valore;
  }
 
  public String getNome()
  {
    return nome;
  }
}

[CODE]

Se ho capito bene dovrebbe essere giusto.Dopodiche ho provato a creare la classe Stack ma non ho capito diverse cose:

[CODE]
import java.util.*;

public class Stack
{
  private ArrayList<Carta> carte; /* Dove devo creare l´array? Come faccio ad associare un numero della lista
 
  ad una carta? */

  public Stack()
  {
   
  }
 
  public Carta getCarta()
  {
     /*
     Cosa dovrei mettere qua? Come faccio a cercare la carta libera?
     
     */
     
  }
}

[CODE]

e mi sono bloccato qua...consigli?Sta diventando tutto piu complicato di prima :(
Grazie ancora per l´aiuto e le risposte

 

[icox]

L'array lo inizializzi dentro al costruttore, come un qualsiasi oggetto: this.carte = new ArrayList<>();
Dopodiche' lo devi popolare, quindi puoi usare le funzioni che hai gia' per generare le carte. Ricorda che gli hai dato come tipo Carta, pertanto la dentro puoi metterci solo oggetti di tipo Carta.
Quindi o crei l'oggetto Carta in un altra classe e poi lo passi a aggiungiCarta(Carta c), oppure passi due valori ad una funzione aggiungiCarta(String nome, int valore) il quale fara' una new Carta(nome, valore) e quindi una add sulla struttura arrayList. Ti ho messo un arrayList ma puoi usare quello che vuoi, un semplice array, una lista o quello con cui ti trovi meglio.

Per capirci

public void aggiungiCarta(Carta c) {
   // c DEVE essere un oggetto di tipo Carta, che puoi creare anche altrove
   this.carte.add(c);
}

public void aggiungiCarta(String nome, int valore) {
   Carta nuovaCarta = new Carta(nome, valore);
   this.carte.add(nuovaCarta);
}

Infine dovrai recuperare le carte, qui puoi pensare a come funziona un mazzo: se vuoi distribuire una carta, prenderai quella che e' in cima, quindi la togli dal mazzo e la distribuisci.
In getCarta() potresti fare la stessa cosa: prendi il primo elemento di "carte", lo rimuovi dall'insieme e quindi lo ritorni.
Di nuovo, ti ho citato gli arrayList ma puoi usare la struttura che preferisci come ad esempio un array semplice o una lista.
Rimanendo nell'esempio dell'arrayList c'e' la funzione remove(int index), ti rimando alla ocumentazione: http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html .


ps. occhio al costruttore di Carta, per usarlo cosi devi passargli i valori da assegnare ai campi "valore", "nome" e "seme".

 

[DarkGast]

Provo a darvi il codice su cui ho lavorato prima di chiedere a voi (molte variabili sono con nomi tedeschi,ma non credo sia un problema:ops:)visto che mi sembra simile a quello che dici tu

import javax.swing.*;
/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 29.03.2017
  * @author
  */

public class Karte {
 
  // Anfang Attribute
  private int kartenwert;
  private String name;
  public String value;
  private ImageIcon bild;
  // Ende Attribute
 
  public Karte( int pWert, ImageIcon pBild   , String pName )
  { 
    kartenwert = pWert;
    name = pName;
    this.bild = pBild;
 
  }
 
  // Anfang Methoden
  public int getKartenwert() {
    return kartenwert;
  }
 
  public String getName() {
    return name;
  }
 
  public ImageIcon getBild() {
    return bild;
  }
 
  // Ende Methoden
}

questa era la prima classe,e ogni classe é in un file a se stante

import javax.swing.ImageIcon;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.util.*;
/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 08.05.2017
  * @author
  */

public class Karten {
 
  // Anfang Attribute
  public Karte[] kartenArray;
  public static Random zufallsa;
  public static Random zufallsb;
  private  int a;
  private int b;
  public int temp;
  private Random zufallsGenerator;
  public int zufallsZahl;
 
  // Ende Attribute
  public Karten()
  {
    kartenArray = new Karte[40];
    kartenArray[0] = new Karte(1,new ImageIcon("1.jpg")  ,"s1");
    kartenArray[1] = new Karte(1,new ImageIcon("2.jpg")  ,"d1");
    kartenArray[2] = new Karte(1,new ImageIcon("3.jpg")  ,"c1");
    kartenArray[3] = new Karte(1,new ImageIcon("4.jpg")  ,"b1");
    kartenArray[4] = new Karte(2,new ImageIcon("5.jpg")  ,"s2");
    kartenArray[5] = new Karte(2,new ImageIcon("6.jpg")  ,"b2");
    kartenArray[6] = new Karte(2,new ImageIcon("7.jpg")  ,"c2");
    kartenArray[7] = new Karte(2,new ImageIcon("8.jpg")  ,"d2");
    kartenArray[8] = new Karte(3,new ImageIcon("9.jpg")  ,"s3");
    kartenArray[9] = new Karte(3,new ImageIcon("10.jpg")  ,"b3");
    kartenArray[10] = new Karte(3,new ImageIcon("11.jpg")  ,"c3");
    kartenArray[11] = new Karte(3,new ImageIcon("12.jpg")  ,"d3");
    kartenArray[12] = new Karte(4,new ImageIcon("13.jpg")  ,"s4");
    kartenArray[13] = new Karte(4,new ImageIcon("14.jpg")  ,"b4");
    kartenArray[14] = new Karte(4,new ImageIcon("15.jpg")  ,"c4");
    kartenArray[15] = new Karte(4,new ImageIcon("16.jpg")  ,"d4");
    kartenArray[16] = new Karte(5,new ImageIcon("17.jpg")  ,"s5");
    kartenArray[17] = new Karte(5,new ImageIcon("18.jpg")  ,"b5");
    kartenArray[18] = new Karte(5,new ImageIcon("19.jpg")  ,"c5");
    kartenArray[19] = new Karte(5,new ImageIcon("20.jpg")  ,"d5");
    kartenArray[20] = new Karte(6,new ImageIcon("21.jpg")  ,"s6");
    kartenArray[21] = new Karte(6,new ImageIcon("22.jpg")  ,"b6");
    kartenArray[22] = new Karte(6,new ImageIcon("23.jpg")  ,"c6");
    kartenArray[23] = new Karte(6,new ImageIcon("24.jpg")  ,"d6");
    kartenArray[24] = new Karte(7,new ImageIcon("25.jpg")  ,"s7");
    kartenArray[25] = new Karte(7,new ImageIcon("26.jpg")  ,"b7");
    kartenArray[26] = new Karte(7,new ImageIcon("27.jpg")  ,"c7");
    kartenArray[27] = new Karte(7,new ImageIcon("28.jpg")  ,"d7");
    kartenArray[28] = new Karte(8,new ImageIcon("29.jpg")  ,"b8");
    kartenArray[29] = new Karte(8,new ImageIcon("30.jpg")  ,"c8");
    kartenArray[30] = new Karte(8,new ImageIcon("31.jpg")  ,"d8");
    kartenArray[31] = new Karte(8,new ImageIcon("32.jpg")  ,"s8");
    kartenArray[32] = new Karte(9,new ImageIcon("33.jpg")  ,"s9");
    kartenArray[33] = new Karte(9,new ImageIcon("34.jpg")  ,"b9");
    kartenArray[34] = new Karte(9,new ImageIcon("35.jpg")  ,"c9");
    kartenArray[35] = new Karte(9,new ImageIcon("36.jpg")  ,"d9");
    kartenArray[36] = new Karte(10,new ImageIcon("37.jpg")  ,"s10");
    kartenArray[37] = new Karte(10,new ImageIcon("38.jpg")  ,"b10");
    kartenArray[38] = new Karte(10,new ImageIcon("39.jpg")  ,"c10");
    kartenArray[39] = new Karte(10,new ImageIcon("40.jpg")  ,"d10");
    kartenArray[zufallsZahl].getBild();
    zufallsGenerator = new Random();
    zufallsZahl = zufallsGenerator.nextInt(40);

    } 
 
  // Anfang Methoden
 
  public void mischiare() 
  {
    int i;
    i=0;
    if (i<100)
    {
      zufallsa = new Random();
      a = zufallsa.nextInt(39);
      zufallsb = new Random();
      b = zufallsb.nextInt(39);
  
      Karte temp= kartenArray[a];
      kartenArray[a]= kartenArray[b];
      kartenArray[b] = temp;
      i=i++;
    }

 
  }
 
 
  public void generacarta()
    {
    zufallsGenerator = new Random();
    zufallsZahl = zufallsGenerator.nextInt(40);
    }
  
  public void rimuovi()
  {
    kartenArray.remove[zufallsZahl] ;
  }
  }

questa é la classe con l´array

Karten krt = new Karten();
    krt.generacarta();
    unsererZahl = 0;
    unsererZahl = krt.zufallsZahl;
    jLabel1.setBounds(16, 512, 83, 161);
    jLabel1.setIcon(unsereKarten.kartenArray[unsererZahl].getBild());
    jLabel1.setOpaque(false);
    cp.add(jLabel1);
    krt.rimuovi();
    krt.mischiare();

e questo é come ho provato fino ad ora per non far si che si ripetano le carte...ma non va
Come puoi vedere ho seguito i consigli di @BAT00cent ,ma nemmeno cosí riesco a non fare venire doppie carte anche rimuovendole (non so come facciano a tornare)

Lascio la parola a voi

 

[icox]

Per rimuovere una carta hai due possibilita':

1. prendi sempre la prima (all'indice 0)
2. prendi una carta usando un indice random.

Nel primo caso non hai bisogno di generare un numero a caso, ma ti basta accedere all'elemento in posizione (indice) 0 se usi un array/arrayList, oppure in testa se usi una lista. E' necessario ovviamente che le carte non siano ordinate, quindi dovrai avere un'opportuna funzione "mischia".

Nel secondo caso devi generare un numero casuale compreso fra 0 e la lunghezza dell'array (http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#random()).
Attenzione che deve essere un intero e, visto che gli indici partono da 0, dovra essere compreso fra 0 e array.length - 1.

In entrambi i casi dopo aver prelevato la carta, la devi rimuovere dalla struttura.
Se usi un array dovrai shiftare tutti gli elementi di una posizione per coprire il "buco", oppure sposti l'ultimo elemento nella posizione che vuoi coprire, dal momento che l'ordine non e' rilevante.
Se usi una arrayList c'e' il metodo remove() che ti ho gia' scritto (https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html).
Se usi una lista sposti i puntatori in modo da slegare un elemento.

Non inserire la grafica, complichi inutilmente il codice: sviluppa la logica e cerca di far comunicare correttamente i vari oggetti fra di loro.
Consiglio, scriviti su carta una bozza delle classi, prova a pensare come dovranno interagire tra loro e quindi implementa dei metodi per l'accesso ai dati. Non accedere direttamente ai campi di altre classi... Mettili a private cosi ti togli ogni tentazione :asd:

 

[DarkGast]

Per rimuovere una carta hai due possibilita':

1. prendi sempre la prima (all'indice 0)
2. prendi una carta usando un indice random.

Nel primo caso non hai bisogno di generare un numero a caso, ma ti basta accedere all'elemento in posizione (indice) 0 se usi un array/arrayList, oppure in testa se usi una lista. E' necessario ovviamente che le carte non siano ordinate, quindi dovrai avere un'opportuna funzione "mischia".

Nel secondo caso devi generare un numero casuale compreso fra 0 e la lunghezza dell'array (http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#random()).
Attenzione che deve essere un intero e, visto che gli indici partono da 0, dovra essere compreso fra 0 e array.length - 1.

In entrambi i casi dopo aver prelevato la carta, la devi rimuovere dalla struttura.
Se usi un array dovrai shiftare tutti gli elementi di una posizione per coprire il "buco", oppure sposti l'ultimo elemento nella posizione che vuoi coprire, dal momento che l'ordine non e' rilevante.
Se usi una arrayList c'e' il metodo remove() che ti ho gia' scritto (https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html).
Se usi una lista sposti i puntatori in modo da slegare un elemento.

Non inserire la grafica, complichi inutilmente il codice: sviluppa la logica e cerca di far comunicare correttamente i vari oggetti fra di loro.
Consiglio, scriviti su carta una bozza delle classi, prova a pensare come dovranno interagire tra loro e quindi implementa dei metodi per l'accesso ai dati. Non accedere direttamente ai campi di altre classi... Mettili a private cosi ti togli ogni tentazione :asd:

Grazie!esattamente questo volevo sapereora...mettendo che voglio usare il primo metodo,per prendere la carta uso (nel mio caso) kartenArray[zufallsZahl],mentre per rimuoverla devo solo aggiungere ".remove();" ? Per il mischiare ho già fatto un if minore di 100 vengono generati 2 numeri e scambiati.Ancora una domanda,sto usando un Array o una Arraylist?concludo dicendo solo che sto cercando di lavorare insieme al UI visto che dovrei presentarlo per lunedìlo so...ce un po (tanto) lavoro ancora da fare,ma dopo questo problema devo fare solo piccole cose (se non mi sbaglio)

Ad ogni modo grazie ancora, attendo consigli e risposte

 

[BAT]

Come risposta è interessante, ma credo che richieda più tempo sia di esecuzione che di per programmarla.
Comunque non è necessario creare una nuova classe per fare il tutto , anzi secondo me non si deve fare: basta una semplice funzione.

immagino che tu stia scherzando vero?
un seme, una carta ed un mazzo sono 3 cose diverse: serve una classe ciascuno (per il seme è sufficiente una enumerazione, cioè UNA RIGA di codice anche se è accettabile una stringa come attributo), più altre classi a seconda di come implementa la logica di gioco.
Parlando di efficienza:
rimuovere ed inserire continuamente elementi in strutture dati costa enormemente di più che mantenere un semplice indice (un numeo intero) su un array;
tra parentesi, mantenere un indice nell'array che ricorda il punto in cui sei arrivato a dare le carte equivale esattamente a mantenere uno stack:
guarda caso, l'indice mantenuto è il primo elemento dello stack! :ok:
solo che se lo fai con un array ordinario non c'è mai bisogno di eliminare nulla, basta incrementare l'indice dell'array...
quando dai le 3 carte di una mano, basta incrementare di 3 l'indice, con una struttura dati concatenata che usi come stack fai 3 eliminazioni (e rispettivi reinserimenti nella struttura dati che simula le carte "in mano" a un giocatore)
poi ovviamente deve usare una struttura dati (come ArrayList) per ricordare le carte prese dai giocatori,ma questo è un altro discorso
Se ho tempo butto giù qualche riga di codice, temo che senza sia un po' complicato capirmi.

 

[icox]

Grazie!esattamente questo volevo sapereora...mettendo che voglio usare il primo metodo,per prendere la carta uso (nel mio caso) kartenArray[zufallsZahl],mentre per rimuoverla devo solo aggiungere ".remove();" ? Per il mischiare ho già fatto un if minore di 100 vengono generati 2 numeri e scambiati.Ancora una domanda,sto usando un Array o una Arraylist?concludo dicendo solo che sto cercando di lavorare insieme al UI visto che dovrei presentarlo per lunedìlo so...ce un po (tanto) lavoro ancora da fare,ma dopo questo problema devo fare solo piccole cose (se non mi sbaglio)

Ad ogni modo grazie ancora, attendo consigli e risposte

Dal codice che hai postato stai usando gli array, quindi potresti tenere traccia di dove arrivi con un indice come ti ha suggerito @BAT00cent. Per ogni modifica su quella struttura dovrai ricordarti di modificare l'indice oppure, cosa a mio avviso migliore, crearti un metodo che si occupa anche di prendere/inserire la carta e aggiornare l'indice.
Il metodo remove e' specifico di arrayList, quindi non puoi usarlo su un array semplice.

In generale il metodo getCard() lo puoi implementare in 3 modi almeno:
1. da un array mischiato prelevi (quindi rimuovi fisicamente) sempre il primo elemento e poi "tappi" il buco mettendo l'ultimo in prima posizione, o meglio ancora prendi direttamente l'ultimo in modo da non dover fare ulteriori operazioni.
2. prendi un elemento random, avendo cura di generare un numero compreso fra 0 e la lunghezza dell'array (-1); anche qui dovrai poi spostare l'ultimo elemento sull'indice che hai "prelevato".
3. usi un indice esterno per iterare l'array (che non deve essere ordinato), quindi ogni volta che ti serve una carta dovrai aggiornare questo indice per sapere a che punto sei arrivato e non dare due o piu' volte la stessa carta. In questo caso non ti serve eliminare l'elemento perche' hai l'indice che punta al primo disponibile.

Sono tutte soluzioni accettabili.
A essere pignoli il 2. e' quello piu' efficiente perche' non deve mischiare l'array.

Array o arrayList... Dipende, nel tuo caso vanno bene entrambi. Sulla documentazione trovi una spiegazione dettagliata.

 

[BAT]

Concordo
una cosa su cui vale sempre la pena di "perdere tempo" è progettare attentamente le strutture dati su cui lavorare perché è raro che la prima cosa che ti viene in mente sia quella più conveniente.
Poi, come sempre, in Informatica in genere ci sono sempre molti modi per risolvere un problema, l'essenziale è risolverlo bene e se possibile in modo efficiente (cosa non sempre possibile quando ci sono vincoli di tempo stringenti, in tal caso vanno bene anche soluzioni un po' "arrangiate" purché funzionanti)

 

[DarkGast]

Dal codice che hai postato stai usando gli array, quindi potresti tenere traccia di dove arrivi con un indice come ti ha suggerito @BAT00cent. Per ogni modifica su quella struttura dovrai ricordarti di modificare l'indice oppure, cosa a mio avviso migliore, crearti un metodo che si occupa anche di prendere/inserire la carta e aggiornare l'indice.
Il metodo remove e' specifico di arrayList, quindi non puoi usarlo su un array semplice.

In generale il metodo getCard() lo puoi implementare in 3 modi almeno:
1. da un array mischiato prelevi (quindi rimuovi fisicamente) sempre il primo elemento e poi "tappi" il buco mettendo l'ultimo in prima posizione, o meglio ancora prendi direttamente l'ultimo in modo da non dover fare ulteriori operazioni.
2. prendi un elemento random, avendo cura di generare un numero compreso fra 0 e la lunghezza dell'array (-1); anche qui dovrai poi spostare l'ultimo elemento sull'indice che hai "prelevato".
3. usi un indice esterno per iterare l'array (che non deve essere ordinato), quindi ogni volta che ti serve una carta dovrai aggiornare questo indice per sapere a che punto sei arrivato e non dare due o piu' volte la stessa carta. In questo caso non ti serve eliminare l'elemento perche' hai l'indice che punta al primo disponibile.

Sono tutte soluzioni accettabili.
A essere pignoli il 2. e' quello piu' efficiente perche' non deve mischiare l'array.

Array o arrayList... Dipende, nel tuo caso vanno bene entrambi. Sulla documentazione trovi una spiegazione dettagliata.

Ok quindi potrei generare la carta e poi sostituirla con l´ultima del array e dopodiché far si che il numero generato non sia piu 0-39 ma 0-38 no?(mi sembra molto veloce come soluzione,ma non so se sia giusta) o ce un altro metodo per rimuovere un elemento da un semplice array?Per il getCard() non é lo stesso metodo?

@BAT00cent purtroppo come dici tu é il tempo il problema,visto che dovrei presentarlo lunedí:suicidio:quindi sto cercando di fare le cose piú velocemente possibile,ma che funzionino lo stesso (anche se poi ci sono sicuramente metodi che snellirebbero il codice)

 

[DarkGast]

up please