style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Arreglo generico

Hola, tengo que implenetar un arreglo generico en el cual un "cliente" agrege elementos, otro "cliente" quite elementos de manera aleatoria(threads) y que halla un "ojo"(observer-obserbable) que mire el arreglo y por pantalla pueda ver cuantos elementos hay en la bolsa(vector). quisiera que me vallan dando una mano para poder hacer el proyecto ya que el viernes lo tengo q entregar y estoy medio duro cn esto de java.
desde ya muchas gracias...

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Re: Arreglo generico

Si comprendes la naturaleza del problema y posteas la solución en pseudocódigo, el hecho de que estés medio duro en Java no impedirá crear una solución pronta.

Saludos

Javier

Re: Arreglo generico

ok, gracias.
te detallo un poco mas como seria el problema. los temas a tratar son generics, threads y observer.
en primer lugar debe existir un arreglo generico, con los metodos agregar, quitar y uno q me de la cantidad de elementos en el.
por otro lado deben existir al menos 2 "clientes" uno que agrega y otro que quita los elementos previamente cargados.(theads)
y todo esto debe estar observado por una clase frame que me dice cuantos elementos quedan en el arreglo. eso seria lo basico.
si te interesa yo hice algo pero me lo rebotaron... :(

Imagen de ezamudio

Estructura...

yo más o menos lo haría así:
1. Una subclase de Observable con un ArrayList de los objetos que vas a manejar (por ejemplo si son Strings un ArrayList )
2. Esa subclase tiene métodos agregar(String) y quitar(String) y/o quitar(int) (para quitar por índice). Internamente usan el arreglo para sincronizar threads (asi no tienes que hacer todo el método synchronized). Esos métodos modifican el arreglo y luego invocan setChanged() y notifyObservers() con el arreglo como parámetro. Con esto ya tienes la parte del arreglo solucionada.
3. Un Runnable que implementa un ciclo en el cual agrega elementos a tu objeto, con un cierto tiempo de espera (o bien un ScheduledExecutor con varios Runnables programados para agregar uno o varios elementos cada cierto tiempo).
4. Un Runnable que quita elementos de tu objeto, con un cierto tiempo de espera (o bien otro ScheduledExecutor con varios Runnables que quitan uno o varios elementos de manera aleatoria, probablemente por índice, validando con el tamaño del arreglo)
5. Un controlador que implementa Observer y en su método update() recibe una copia del arreglo para presentarla como mejor te parezca en la GUI (en un JTextArea o actualizando un JTable o algo asi).

Re: Arreglo generico

hola...
estoy tratando de hacer la bolsa generica pero me da error en todas las lineas...
public class Bolsa
{
public ArrayList();
public set(E element);
public E get(int index);
public E remove(int index);

}

Imagen de ezamudio

Lee algo de Generics

Nunca has usado generics por lo visto. Estas usando al menos Java 5 o 6?

public class Bolsa<E> {
  private ArrayList<E> lista = new ArrayList<E>();
  public set(E elem);
  public E get(int index);
  public E remove(int index);
}

y se usa asi:

Bolsa<String> bolsa = new Bolsa<String>();

Hice algo...

buen dia... si uso Java 6...
aca hay algo q hice esta mañana temprano... me da un error al quitar un elemento y tendria que agregarle el setChanged y notifyObservers.
bueno, voy a seguir con lo demas...
import java.util.ArrayList;

public class Bolsa<E>
{
    private ArrayList<E> lista = new ArrayList<E>();
    protected int cantidad;
   
    public synchronized void agregar(E elem)
    {
        if (this.cantidad < 10)
        {
            try
            {  
            lista.add(elem);
            this.cantidad++;
            wait();
            }
            catch(InterruptedException e)
            {
            System.out.println("Excepcion al Agregar");
            }
        }
        notifyAll();
     }        
           
   
    public synchronized E quitar()//missing return statment
    {
        while(!lista.isEmpty())
        {
            try
            {
             return(lista.remove(0));
             this.cantidad--;
             wait();
            }
            catch(InterruptedException e)
            {
            System.out.println("Excepcion al quitar");
            }
         }
        notifyAll();
    }
   
    public int getCantidad()
    {
    return this.cantidad;
    }
   
    @Override
    public String toString()
    {
    String cant = new Integer(getCantidad()).toString();
    return cant;
    }
   
}
Imagen de ezamudio

Ja...

Mira, hiciste exactamente lo que dije que no tenias que hacer en mi punto 2... declaraste los métodos como synchronized. Suerte.

gracias...

asi es como me lo enseñaron y asi es como lo tengo q hacer....
si aun te interesa eyudarme te agradeceria...

Imagen de ezamudio

Observable

Bolsa debe heredar de Observable. Tus metodos de agregar y quitar pueden ser asi:

public void agrega(E elem) {
  List l2 = null;
  synchronized(lista) {
    lista.add(elem);
    l2 = Collections.unmodifiableList(lista);
  }
  setChanged();
  notifyObservers(l2);
}

La variable cantidad te sobra porque tienes lista.size(), no sé para qué estás haciendo el wait() y notifyAll().

Tu controlador en GUI debe implementar Observer, y a su bolsa al principio le dice bolsa.addObserver(this) para que posteriormente reciba llamadas a su update(Observable,Object) donde el segundo parámetro va a ser una copia de la lista como ha quedado después de la última modificación. agregar() y quitar() deben hacer una copia de la lista para que cuando la pasen a los observadores, no haya problema con que sigan invocándose agregar() y quitar().

sigo codificando...

bien... el wait y el notifyAll los puse porque los usuarios son threads y puede haber 2 agregando/sacando en simultaneo. ya saque cantidad e implemente lo de size :)...
te muestro lo que hice en el "ojo"

public class Ojo extends javax.swing.JPanel implements Observer
{
    Bolsa obs1;
   
    public Ojo(Bolsa u1)
    {
        obs1 = u1;

       
        obs1.addObserver(this);
       
        initComponents();
    }

    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        jTextField1 = new javax.swing.JTextField();
        jLabel1 = new javax.swing.JLabel();

        jLabel1.setText("Bolsa");

        org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(this);
        this.setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(org.jdesktop.layout.GroupLayout.TRAILING, layout.createSequentialGroup()
                .addContainerGap()
                .add(layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
                    .add(jTextField1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, 80, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                    .add(jLabel1))
                .add(300, 300, 300))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
            .add(layout.createSequentialGroup()
                .add(33, 33, 33)
                .add(jLabel1)
                .addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
                .add(jTextField1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(22, Short.MAX_VALUE))
        );
    }// </editor-fold>                        

    // Variables declaration - do not modify                    
    private javax.swing.JLabel jLabel1;
    private javax.swing.JTextField jTextField1;
    // End of variables declaration                  

    public void update(Observable o, Object arg)
    {
        Bolsa bolsa = (Bolsa)arg;
       
         jTextField1.setText(bolsa.toString());
       
    }
}

podrias corroborar el meodo quitar en la bolsa, que me da error. algo estoy haciendo mal con los datos q retorna...

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">