Él se refiere a esta etiqueta:



Saludos.

No hagas doble post, edita el primero que ha habías hecho.

Mira los problemas de Project Euler se ven muy interesantes.

Saludos.

Pues veo que es otra de las razones. La verdad no sabía eso que acabas de comentar y pues es algo importante a tener en cuenta cuando programas aplicaciones que precisan de la velocidad para funcionar correctamente, quiero decir: no tratar de conmutar entre direcciones de memoria que estén muy alejados.

Saludos...

Te ayudaría mejor si publicaras todo el código, para no tener que escribir todo de nuevo en caso de que no haya trabajado antes con los temas sobre tu duda. Buscando por la web me encontré con algo parecido a lo que estas haciendo y te dejo el código;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
 
import javax.swing.event.*;
 
public class FlightReservation extends JFrame
 
{
 
  public FlightReservation() {
 
    super("Flight Reservation Dialog");
 
    setSize(400, 300);
 
    JPanel p1 = new JPanel();
 
    p1.setLayout(new BoxLayout(p1, BoxLayout.X_AXIS));
 
    JPanel p1r = new JPanel();
 
    p1r.setBorder(new EmptyBorder(10, 10, 10, 10));
 
    // Variant 1
 
    p1r.setLayout(new GridLayout(3, 2, 5, 5));
 
    p1r.add(new JLabel("Date:"));
 
    p1r.add(new JTextField());
 
    p1r.add(new JLabel("From:"));
 
    JComboBox cb1 = new JComboBox();
 
    cb1.addItem("New York");
 
    p1r.add(cb1);
 
    p1r.add(new JLabel("To:"));
 
    JComboBox cb2 = new JComboBox();
 
    cb2.addItem("London");
 
    p1r.add(cb2);
 
    p1.add(p1r);
    JPanel p3 = new JPanel();
 
    p3.setLayout(new BoxLayout(p3, BoxLayout.Y_AXIS));
    String[] list = {"UNO","DOS","TRES","CUATRO","CINCO","SEIS","SIETEASDAS"};
    ScrollPane scrollpane = new ScrollPane();
    scrollpane.add(new JList(list));
    p3.add(scrollpane);
 
    p1.add(p3);
 
    getContentPane().add(p1, BorderLayout.NORTH);
 
    JPanel p4 = new JPanel();
 
    JPanel p4c = new JPanel();
 
    p4c.setLayout(new GridLayout(1, 3, 5, 5));
 
    JButton b1 = new JButton("Search");
 
    p4c.add(b1);
 
    JButton b2 = new JButton("Purchase");
 
    p4c.add(b2);
 
    JButton b3 = new JButton("Exit");
 
    p4c.add(b3);
 
    p4.add(p4c);
 
    getContentPane().add(p4, BorderLayout.CENTER);
 
    WindowListener wndCloser = new WindowAdapter() {
 
      public void windowClosing(WindowEvent e) {
 
        System.exit(0);
 
      }
 
    };
 
    addWindowListener(wndCloser);
 
    setVisible(true);
 
  }
 
  public static void main(String argv[]) {
 
    new FlightReservation();
 
  }
 
}
 
 
 

Lo he modificado un poco para que se parezca más a lo que quieres. Otra opción creo que sería meter un GridLayout dentro de otro en el de la derecha solo estaría la lista, bueno no sé si funcionaría.

Fuente Del Código

Puedes ver un arreglo de la siguiente forma;

   dirBase        variables que están en direcciones relativas a dirBase     
   0x0001           4             6             7              8
   0x0005           3             6             7              2
   0x0009           4             3             10             8
   0x00013          1             0             7              1
  
Cada variable como podrás imaginar tiene una dirección en la memoria, para acceder a un elemento del arreglo en java por ejemplo puedes hacer algo así arreglo[2][3]; esto sería un 8 teniendo en cuenta el arreglo de arriba, pero la computadora lo ve más como una dirección así;


nota que solo hay que aumentarle un 3 a la dirección base.

Ahora para recorrer un arreglo empezando por filas y luego columnas solo es necesario aumentar un valor a la base, puesto que la base suele ser "i" entonces solo hay que variar el valor de "j", pero si quieres recorrer por columnas entonces tienes que cambiar la dirección base constantemente y luego incrementarlo.

Para entenderlo mejor te recomiendo estudiar ASM, la verdad muchas cosas entenderás cuando estudies ese lenguaje.

Suerte

Hola, me gusta la idea pero los problemas que propones son muy pocos y no me parecen adecuados, por ejemplo el primer problema no es como para sentarse todo el día y teclear lo que sea para ver si encontramos la solución porque con una búsqueda en Google tienes el problema solucionado y da igual lo que se haga porque no se ganaría mucho que digamos en ambos casos, en cambio un problema del tipo "calcular la suma entre los dígitos del número (1 ^ 34627550862)" sería algo como para ponerse con él todo el día y no buscarlo en Google ya que en ese caso ya no tendría su gracias, y si logramos cumplir con el reto entonces tendríamos algo que sería útil para futuros trabajos.

Debemos ir pensando en otros problemas, algo así como 20 ya sería buena idea, claro que ya depende de la dificultad.

Te enviaré un MP con más problemas y vemos si publicamos otro hilos un poco más formal con más problemas y reglas definidas.

Yo lo descubrí. Me puse a buscar por Internet y encontré que otras personas lo utilizan( como era de esperar, claro):
Usado en una linea
Vaya, aquí lo usan muchas veces

Suerte.

¿En qué te basas para decir que es mejor sin funciones trigonométricas? Para el problema al menos creo que es la mejor solución, si no es que la única.


No te has explicado muy bien que digamos.

De nada 

int[] arreglo;

Con eso te creas una referencia a un arreglo, pero solo una referencia, es decir, puede estar apuntando a nada( una referencia nula) o puede estar apuntando a un arreglo. En el caso anterior es simplemente una referencia nula.

con new puedes crear un objeto y hacer que una referencia apunte al objeto. Puedes crear tantos objetos quieras y hacer que la referencia apunte a ellos:
   

int[] arreglo;
arreglo = new int[] {3,4,1};
arreglo = new int[] {3,4,1,4,2,3};
arreglo = new int[] {3,4,1,4,2,3,4,2,4,2};

          
la referencia "arreglo" se queda con el último objeto creado, pero ¿Qué pasa con los objetos anteriores? Pues java tiene algo que se llama recolector de basura y te hace el favor de eliminar los objetos que ya no estas utilizando cuando le parezca conveniente, ¿y siempre lo hace? Pues por algo java consume mucha Memoria RAM, pero no tienes que estar preocupándote de eliminar los objetos.

Esto solo es válido para los objetos, no es lo mismo con las variables primitivas int,char,float etc..
Ahora no sé si lo que escribí fue en vano, al menos creo que entenderás que un arreglo es una especie de objeto por si ya sabías el resto.


Edito: El código que no sabías es sólo una forma diferente de hacer esto;

// declares an array of integers
        int[] anArray;
 
        // allocates memory for 10 integers
        anArray = new int[10];
 
        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

Suerte.