¿Has buscado en google? Seguramente encuentras respuestas rápidamente.

Como ya creaste el tema te responderé. WindowsBuilder o lo que es en Netbeans GUIBuilder, es una herramienta que te ayuda a crear Interfaces Gráficas de Usuario (GUI). Para hacer pruebas rápidas me parece bien, pero para utilizarlo como herramienta esencial al crear tus GUI, no me parece correcto.

Los GUI Builders generan mucho código basura, además de ser un proceso automatizado en donde no aprenderás ni un carajo. Lo mejor es preocuparse por aprender, y en éste caso significa aprender layouts. Hay muchos tipos de layouts que puedes usar, te recomiendo buscar.

Lo segundo es mi opinión un factor con cierta importancia ya que darle un tamaño fijo a una GUI en una determinada resolución, si se abre en otra resolución más baja, habrá problemas de visualización. Para conseguir que los componentes se adapten al tamaño de la pantalla, debes usar GridBagLayout en el caso de Swing.

1) Crea una clase que herede de JPanel (ésta clase será el panel con el fondo) y Guardas la imagen en un objeto Image:

Image fondo = new ImageIcon(
   getClass().getResource("fondo.jpg")
).getImage();

2) Lde implementar los controles y todo lo que desees, sobreescribes el método paintComponent.

@Override
protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.drawImage(fondo, 0, 0, null);      
}

NOTA: No necesitas llamar al método paintComponent explícitamente, ya que éste es llamado automáticamente por JPanel cada vez que el estado del JPanel cambia (cuando se mueve, se refresca la pantalla, etc). En casos es necesario llamarlo explícitamente, esto se hace con el método repaint.

public class PanelFondo extends JPanel {
	Image fondo;
 
	public PanelFondo() {
		this.setPreferredSize(500,600);
		this.add(crearFondo());
	}
 
	private void crearFondo() {
		fondo = new ImageIcon(
   			getClass().getResource("fondo.jpg")
			).getImage();
	}
 
	// ESTE METODO ES LLAMADO AUTOMATICAMENTE POR JPANEL PARA
	// PINTAR LA UI, INCLUIDA LA IMAGEN DE FONDO
	@Override
	protected void paintComponent(Graphics g) {
        	super.paintComponent(g);
        	g.drawImage(fondo, 0, 0, null);      
	}
 
}

@Override
protected void paintComponent(Graphics g) {
     super.paintComponent(g);
     g.drawImage(image, 0, 0, null);      
}

Recuerda, para dibujar cualquier cosa en un contenedor de JPanel, debes de usar el método paintComponent, que será llamado automáticamente cada vez que hayan cambios en el JPanel (se mueva, etc), así que debes dibujar tu imagen en éste método para que la imagen sea visible todo el tiempo en el JPanel.

Usa el método split(expresión), donde 'expresión' es el patrón que se usará para dividir una cadena en uno o más grupos. Por ejemplo:

String dias = "Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo";
String diaArray[] = dias.split(",");
 
for(String dia : diaArray){
      System.out.println(dia);
}

El resultado es que lo que hay antes y después del caracter ',' se guardará en un array y se devolverá el array final. Ésto aplicado a tu caso, se haría de la siguiente manera:

String linea = "Mates, Ingles, Frances";
String[] idiomas = linea.split(", ");
 
// ahora idiomas = {Mates,Ingles,Frances}
// haces lo que quieres con cada idioma (Mates?)

Android Studio es un IDE para desarrollar aplicaciones para Android. Como la mayoría de IDE de provee un GUI builder, en donde puedes hacer tus interfaces gráficas de manera rápida y sencilla.


Supongamos que quieres darle estilos a un botón en JavaFX. Primero, debemos crear el botón:

<Button styleClass="botones" fx:id="btnAceptar" text="Limpiar" prefWidth="80.0" prefHeight="30"  layoutX="15.0" layoutY="250.0"/>

Plus: Si quieres agregarle una imagen a tu botón, puedes hacerlo así:

<Button styleClass="botones" fx:id="btnAceptar" text="Limpiar" prefWidth="80.0" prefHeight="30"  layoutX="15.0" layoutY="250.0">
             <graphic>
	      	<ImageView><Image url="rutapaquete/imagen.png"/></ImageView>
	    </graphic>
</Button>

Y en los estilos, en -fx-background-color, pones 'transparent', para que sólo sea visible la imagen del botón.

Entonces, haríamos nuestra hoja de estilos:

.botones {
        -fx-border-radius: 0;
        -fx-background-radius: 0;
	-fx-background-color: black;
	-fx-text-fill: white;
	-fx-font-size: 16px;
	-fx-font-weight: bold;
}
 
.botones:pressed {
        -fx-background-color: #a3a3a3;
}

2) Es necesario jalar el archivo .fxml desde una clase Java para que se pueda construir:

public class GUIBuilder {
 
	public GUIBuilder() {}
 
	public void build() {
		Stage ventana = new Stage();
		// carga la vista
		Parent root = FXMLLoader.load(this.class.getResource("paquete/vista.fxml"));
		// agrega la vista a la escena
		Scene scene = new Scene(root);
		scene.getStyleSheets().add(this.class.getResource("paquete/estilos.css").toExternalForn());
		ventana.setScene(scene); // agrega la escena al a ventana
		ventana.setResizable(false); // no se puede cambiar el tamanio
		ventana.show(); // muestra la ventana
	}
}

Y así construimos nuestra interfaz con una hoja de estilos. Aprovechando todo el poder de JavaFX

Eso pasa por que el método remove de la interface Interator siempre elimina el último elemento de una lista. Lo que aquí tienes que hacer es identificar la posición en la lista de artículos del artículo actual, luego con el método remove(posicion) de la interface List, eliminas el artículo actual por medio de su posición.

¿Cuando se cierran todas las conexiones, lanza alguna excepción (debería hacerlo) ? Si es así, coloca el StackTrace.

Te dejo un ejemplo extraído del libro Cómo programar en Java, que crea un servidor con una cola de conexiones:

// Configurar un servidor que reciba una conexión de un cliente, envíe
// una cadena al cliente y cierre la conexión.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Servidor extends JFrame {
   private JTextField campoIntroducir;
   private JTextArea areaPantalla;
   private ObjectOutputStream salida;
   private ObjectInputStream entrada;
   private ServerSocket servidor;
   private Socket conexion;
   private int contador = 1;
 
   // configurar GUI
   public Servidor()
   {
      super( "Servidor" );
 
      Container contenedor = getContentPane();
 
      // crear campoIntroducir y registrar componente de escucha
      campoIntroducir = new JTextField();
      campoIntroducir.setEditable( false );
      campoIntroducir.addActionListener(
         new ActionListener() {
 
            // enviar mensaje al cliente
            public void actionPerformed( ActionEvent evento )
            {
               enviarDatos( evento.getActionCommand() );
               campoIntroducir.setText( "" );
            }
         }  
      ); 
 
      contenedor.add( campoIntroducir, BorderLayout.NORTH );
 
      // crear areaPantalla
      areaPantalla = new JTextArea();
      contenedor.add( new JScrollPane( areaPantalla ), 
         BorderLayout.CENTER );
 
      setSize( 300, 150 );
      setVisible( true );
 
   } // fin del constructor de Servidor
 
   // configurar y ejecutar el servidor 
   public void ejecutarServidor()
   {
      // configurar servidor para que reciba conexiones; procesar las conexiones
      try {
 
         // Paso 1: crear un objeto ServerSocket.
         servidor = new ServerSocket( 12345, 100 );
 
         while ( true ) {
 
            try {
               esperarConexion(); // Paso 2: esperar una conexión.
               obtenerFlujos();        // Paso 3: obtener flujos de entrada y salida.
               procesarConexion(); // Paso 4: procesar la conexión.
            }
 
            // procesar excepción EOFException cuando el cliente cierre la conexión 
            catch ( EOFException excepcionEOF ) {
               System.err.println( "El servidor terminó la conexión" );
            }
 
            finally {
               cerrarConexion();   // Paso 5: cerrar la conexión.
               ++contador;
            }
 
         } // fin de instrucción while
 
      } // fin del bloque try
 
      // procesar problemas con E/S
      catch ( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
 
   } // fin del método ejecutarServidor
 
   // esperar que la conexión llegue, después mostrar información de la conexión
   private void esperarConexion() throws IOException
   {
      mostrarMensaje( "Esperando una conexión\n" );
      conexion = servidor.accept(); // permitir al servidor aceptar la conexión            
      mostrarMensaje( "Conexión " + contador + " recibida de: " +
         conexion.getInetAddress().getHostName() );
   }
 
   // obtener flujos para enviar y recibir datos
   private void obtenerFlujos() throws IOException
   {
      // establecer flujo de salida para los objetos
      salida = new ObjectOutputStream( conexion.getOutputStream() );
      salida.flush(); // vaciar búfer de salida para enviar información de encabezado
 
      // establecer flujo de entrada para los objetos
      entrada = new ObjectInputStream( conexion.getInputStream() );
 
      mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
   }
 
   // procesar la conexión con el cliente
   private void procesarConexion() throws IOException
   {
      // enviar mensaje de conexión exitosa al cliente
      String mensaje = "Conexión exitosa";
      enviarDatos( mensaje );
 
      // habilitar campoIntroducir para que el usuario del servidor pueda enviar mensajes
      establecerCampoTextoEditable( true );
 
      do { // procesar los mensajes enviados por el cliente
 
         // leer el mensaje y mostrarlo en pantalla
         try {
            mensaje = ( String ) entrada.readObject();
            mostrarMensaje( "\n" + mensaje );
         }
 
         // atrapar problemas que pueden ocurrir al tratar de leer del cliente
         catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
            mostrarMensaje( "\nSe recibió un tipo de objeto desconocido" );
         }
 
      } while ( !mensaje.equals( "CLIENTE>>> TERMINAR" ) );
 
   } // fin del método procesarConexion
 
   // cerrar flujos y socket
   private void cerrarConexion() 
   {
      mostrarMensaje( "\nFinalizando la conexión\n" );
      establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir
 
      try {
         salida.close();
         entrada.close();
         conexion.close();
      }
      catch( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
   }
 
   // enviar mensaje al cliente
   private void enviarDatos( String mensaje )
   {
      // enviar objeto al cliente
      try {
         salida.writeObject( "SERVIDOR>>> " + mensaje );
         salida.flush();
         mostrarMensaje( "\nSERVIDOR>>> " + mensaje );
      }
 
      // procesar problemas que pueden ocurrir al enviar el objeto
      catch ( IOException excepcionES ) {
         areaPantalla.append( "\nError al escribir objeto" );
      }
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a
   // areaPantalla en el subproceso despachador de eventos
   private void mostrarMensaje( final String mensajeAMostrar )
   {
      // mostrar mensaje del subproceso de ejecución despachador de eventos
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run() // actualiza areaPantalla
            {
               areaPantalla.append( mensajeAMostrar );
               areaPantalla.setCaretPosition( 
                  areaPantalla.getText().length() );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a 
   // campoIntroducir en el subproceso despachador de eventos
   private void establecerCampoTextoEditable( final boolean editable )
   {
      // mostrar mensaje del subproceso de ejecución despachador de eventos
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run()  // establece la capacidad de modificar a campoIntroducir
            {
               campoIntroducir.setEditable( editable );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   public static void main( String args[] )
   {
      Servidor aplicacion = new Servidor();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      aplicacion.ejecutarServidor();
   }
 
}  // fin de la clase Servidor

// Cliente que lee y muestra la información que le envía un Servidor.
import java.io.*;
import java.net.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Cliente extends JFrame {
   private JTextField campoIntroducir;
   private JTextArea areaPantalla;
   private ObjectOutputStream salida;
   private ObjectInputStream entrada;
   private String mensaje = "";
   private String servidorChat;
   private Socket cliente;
 
   // inicializar servidorChat y configurar GUI
   public Cliente( String host )
   {
      super( "Cliente" );
 
      servidorChat = host; // establecer el servidor al que se va a conectar este cliente
 
      Container contenedor = getContentPane();
 
      // crear campoIntroducir y registrar componente de escucha
      campoIntroducir = new JTextField();
      campoIntroducir.setEditable( false );
      campoIntroducir.addActionListener(
         new ActionListener() {
 
            // enviar mensaje al servidor
            public void actionPerformed( ActionEvent evento )
            {
               enviarDatos( evento.getActionCommand() );
               campoIntroducir.setText( "" );
            }
         }  
      ); 
 
      contenedor.add( campoIntroducir, BorderLayout.NORTH );
 
      // crear areaPantalla
      areaPantalla = new JTextArea();
      contenedor.add( new JScrollPane( areaPantalla ),
         BorderLayout.CENTER );
 
      setSize( 300, 150 );
      setVisible( true );
 
   } // fin del constructor de Cliente
 
   // conectarse al servidor y procesar mensajes del servidor
   private void ejecutarCliente() 
   {
      // conectarse al servidor, obtener flujos, procesar la conexión
      try {
         conectarAServidor(); // Paso 1: crear un socket para realizar la conexión
         obtenerFlujos();      // Paso 2: obtener los flujos de entrada y salida
         procesarConexion(); // Paso 3: procesar la conexión
      }
 
      // el servidor cerró la conexión
      catch ( EOFException excepcionEOF ) {
         System.err.println( "El cliente termino la conexión" );
      }
 
      // procesar los problemas que pueden ocurrir al comunicarse con el servidor
      catch ( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
 
      finally {
         cerrarConexion(); // Paso 4: cerrar la conexión
      }
 
   } // fin del método ejecutarCliente
 
   // conectarse al servidor
   private void conectarAServidor() throws IOException
   {      
      mostrarMensaje( "Intentando realizar conexión\n" );
 
      // crear Socket para realizar la conexión con el servidor
      cliente = new Socket( InetAddress.getByName( servidorChat ), 12345 );
 
      // mostrar la información de la conexión
      mostrarMensaje( "Conectado a: " + 
         cliente.getInetAddress().getHostName() );
   }
 
   // obtener flujos para enviar y recibir datos
   private void obtenerFlujos() throws IOException
   {
      // establecer flujo de salida para los objetos
      salida = new ObjectOutputStream( cliente.getOutputStream() );      
      salida.flush(); // vacíar búfer de salida para enviar información de encabezado
 
      // establecer flujo de entrada para los objetos
      entrada = new ObjectInputStream( cliente.getInputStream() );
 
      mostrarMensaje( "\nSe recibieron los flujos de E/S\n" );
   }
 
   // procesar la conexión con el servidor
   private void procesarConexion() throws IOException
   {
      // habilitar campoIntroducir para que el usuario del cliente pueda enviar mensajes
      establecerCampoTextoEditable( true );
 
      do { // procesar mensajes enviados del servidor
 
         // leer mensaje y mostrarlo en pantalla
         try {
            mensaje = ( String ) entrada.readObject();
            mostrarMensaje( "\n" + mensaje );
         }
 
         // atrapar los problemas que pueden ocurrir al leer del servidor
         catch ( ClassNotFoundException excepcionClaseNoEncontrada ) {
            mostrarMensaje( "\nSe recibió un objeto de tipo desconocido" );
         }
 
      } while ( !mensaje.equals( "SERVIDOR>>> TERMINAR" ) );
 
   } // fin del método procesarConexion
 
   // cerrar flujos y socket
   private void cerrarConexion() 
   {
      mostrarMensaje( "\nCerrando conexión" );
      establecerCampoTextoEditable( false ); // deshabilitar campoIntroducir
 
      try {
         salida.close();
         entrada.close();
         cliente.close();
      }
      catch( IOException excepcionES ) {
         excepcionES.printStackTrace();
      }
   }
 
   // enviar mensaje al servidor
   private void enviarDatos( String mensaje )
   {
      // enviar objeto al servidor
      try {
         salida.writeObject( "CLIENTE>>> " + mensaje );
         salida.flush();
         mostrarMensaje( "\nCLIENTE>>> " + mensaje );
      }
 
      // procesar los problemas que pueden ocurrir al enviar el objeto
      catch ( IOException excepcionES ) {
         areaPantalla.append( "\nError al escribir el objeto" );
      }
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a 
   // areaPantalla en el subproceso despachador de eventos
   private void mostrarMensaje( final String mensajeAMostrar )
   {
      // mostrar mensaje del subproceso de ejecución de la GUI
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run() // actualiza areaPantalla
            {
               areaPantalla.append( mensajeAMostrar );
               areaPantalla.setCaretPosition( 
                  areaPantalla.getText().length() );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   // método utilitario que es llamado desde otros subprocesos para manipular a 
   // campoIntroducir en el subproceso despachador de eventos
   private void establecerCampoTextoEditable( final boolean editable )
   {
      // mostrar mensaje del subproceso de ejecución de la GUI
      SwingUtilities.invokeLater(
         new Runnable() {  // clase interna para asegurar que la GUI se actualice apropiadamente
 
            public void run()  // establece la capacidad de modificar campoIntroducir
            {
               campoIntroducir.setEditable( editable );
            }
 
         }  // fin de la clase interna
 
      ); // fin de la llamada a SwingUtilities.invokeLater
   }
 
   public static void main( String args[] )
   {
      Cliente aplicacion;
 
      if ( args.length == 0 )
         aplicacion = new Cliente( "127.0.0.1" );
      else
         aplicacion = new Cliente( args[ 0 ] );
 
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      aplicacion.ejecutarCliente();
   }
 
} // fin de la clase Cliente

Es realmente sencillo, hay diversas formas de validar datos, aquí te pongo un ejemplo:

public class RegistrarClienteControl {
 
	final RegistrarClienteGUI GUI;
 
	public RegistrarClienteControl(RegistrarClienteGUI referencia) {
		gui = referencia;
	}
 
	public boolean validar(TextField... campos) {
		boolean validacion_ok = true;
		boolean campos_vacios = false;
 
		for(TextField txt : campos) {
			if(txt.getText().isEmpty) {
				validacion_ok = false;
				campos_vacios = true;
				break;
			}
		}
 
		if(campos_vacios)
			JOptionPane.showMessageDialog(GUI,"No deje campos vacíos.");
		else if( !isNumeric(GUI.txtTelefono.getText()) )
			JOptionPane.showMessageDialog(GUI,"Algunos campos deben ser numéricos.");
 
		return validacion_ok;
	}
 
	public void guardarCliente() {
		boolean exito = validar(GUI.txtNombre, GUI.txtApellido, GUI.txtDireccion, GUI.txtEmail, GUI.txtTelefono);
		if(exito) {
			// aqui guardas los datos
		}
	}
 
	private boolean isNumeric(String posbl_num) {
		try {
			Integer.parseInt(posbl_num);
			return true;
		} catch (NumberFormatException ex) {
			return false;
		}
	}
 
} // FIN

Cuando se ingrese el usuario y contraseña en el login, en primer lugar debes extraer esos datos. Luego, buscas el usuario en el HashMap, si lo encuentra procedes a comparar las contraseñas.

public class ValidacionLogin {
 
	private boolean usuario_existe(String usuario) {
		if(listaUsuarios.containsKey(usuario))
			return true;
		else
			return false;
	}
 
	private boolean validar_password(String usuario, String password_ingresado) {
		String password = listaUsuarios.get(usuario);
		if(password.equals(password_ingresado))
			return true;
		else
			return false;
 
	}
 
	public void validar_login() {
		String usuario = txtUsuario.getText();
		String password = txtPassword.getText();
		boolean exito = false;
 
		if(usuario_existe(usuario)) {
			if(validar_password(password))
				ingresar();
			else
				JOptionPane.showMessageDialog(GUI,"El password ingresado es incorrecto.");
		}
		else
			JOptionPane.showMessageDialog(GUI,"Usuario no existe.");
	}
 
	public void ingresar() {
		// codigo para redireccionar a la pagina del cliente
	}
 
} // FIN

Yo te recomendaría que crees una entidad (bean) que represente a los clientes para que guardes los datos en un objeto Cliente. Te pongo un ejemplo:

public class Cliente {
	private String nombre;
	private String apellido;
	private String direccion;
	private String email;
	private int telefono;
 
	public Cliente(String nombre, String apellido, String direccion, 
		String email, int telefono) {
		this.nombre = nombre;
		this.apellido = apellido;
		this.direccion = direccion;
		this.email = email;
		this.telefono = telefono;
	}
 
	public String getNombre() {
		return this.nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getApellido() {
		return this.apellido;
	}
 
	public void setApellido(String apellido) {
		this.apellido = apellido;
	}
 
	public String getDireccion() {
		return this.direccion;
	}
 
	public void setDireccion(String direccion) {
		this.direccion = direccion;
	}
 
	public String getEmail() {
		return this.email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public int getTelefono() {
		return this.telefono;
	}
 
	public void setTelefono(int telefono) {
		this.telefono = telefono;
	}
 
} // FIN

Entonces, para registrar al cliente lo haríamos así:

public class RegistrarClienteControl {
 
	final RegistrarClienteGUI GUI;
	List<Cliente> listaClientes = new ArrayList<>(); // aqui se guardaran los clientes
 
	public RegistrarClienteControl(RegistrarClienteGUI referencia) {
		gui = referencia;
	}
 
	public boolean validar(TextField... campos) {
		boolean validacion_ok = true;
		boolean campos_vacios = false;
 
 
		for(TextField txt : campos) {
			if(txt.getText().isEmpty) {
				validacion_ok = false;
				campos_vacios = true;
				break;
			}
		}
 
		if(campos_vacios)
			JOptionPane.showMessageDialog(GUI,"No deje campos vacíos.");
		else if( !isNumeric(GUI.txtTelefono.getText()) )  
			JOptionPane.showMessageDialog(GUI,"Algunos campos deben ser numéricos.");
 
		return validacion_ok;
	}
 
	public void guardarCliente() {
		boolean exito = validar(GUI.txtNombre, GUI.txtApellido, GUI.txtDireccion, GUI.txtEmail, GUI.txtTelefono);
		if(exito) {
			String nombre = GUI.txtNombre.getText();
			String apellido = GUI.txtApellido.getText();
			String direccion = GUI.txtDireccion.getText();
			String email = GUI.txtEmail.getText();
			int telefono = Integer.parseInt(GUI.txtTelefono.getText());
			listaClientes.add(new Cliente(nombre, apellido, direccion, email, telefono));
		}
}
 
	private boolean isNumeric(String posbl_num) {
		try {
			Integer.parseInt(posbl_num);
			return true;
		} catch (NumberFormatException ex) {
			return false;
		}
	}
 
} // FIN

Ahora, para validar el login, haríamos lo siguiente:

public class validacionLogin {
 
	private boolean usuario_existe(String usuario) {
		boolean existe = false;
 
		for(Usuarios u : listaUsuarios) {
			if (u.getUsuario().equals(usuario))
				existe = true;
				break;
		}
 
		return existe;
	}
 
	private boolean validar_password(String usuario, String password_ingresado) {
		String password = listaUsuarios.get(usuario);
		boolean success = false;
 
		for(Usuarios u : listaUsuarios) {
			if (u.getUsuario().equals(usuario)) {
				String password = u.getPassword();
				if(password.equals(password_ingresado))
					success = true;
			}
 
		}
 
	}
 
	public void validar_login() {
		String usuario = txtUsuario.getText();
		String password = txtPassword.getText();
 
		if(usuario_existe(usuario)) {
			if(validar_password(password))
				ingresar();
			else
				JOptionPane.showMessageDialog(GUI,"El password ingresado es incorrecto.");
		}
		else
			JOptionPane.showMessageDialog(GUI,"Usuario no existe.");
	}
 
	public void ingresar() {
		// codigo para redireccionar a la pagina del cliente
	}
 
} // FIN

Trabajar con entidades (beans) es muy importante en el desarrollo de aplicaciones Java. Recuerda, Java es un lenguaje casi total orientado a objetos, por lo que hay que aprovechar las ventajas que ésto nos trae.

Un saludo.

¿Interfaces estilo W95? Creo que hasta en Delphi puedes hacer una buenas GUI. En Java tienes a JavaFX, viene a sustituir a Swing como UI Framework y puedes hacer unas GUI realmente muy buenas. Puedes usar css en tus aplicaciones, de ésta manera puedes hacer que luzcan como tú desees. Hay 2 formas de crear una GUI en JavaFX: Por medio de código Java (en sus inicios) y por medio de código XML, que en éste caso se llama FXML.

He hecho muchas GUI en JavaFX, además puedes agregar vídeos a tu GUI, animaciones como transiciones, efectos de desvanecimiento, movimiento, etc. Puedes construir gráficas personalizas y muy ricas muy fácilmente y es perfecto para el patrón MVC, dado que cada GUI en FXML, tiene un controlador que lo maneja. Si hablamos de .NET, tienes a WPF que usa su lenguaje de marcado XAML, similar a JavaFX, puedes hacer muy buenas GUI.

Otro punto es que todo depende del destino de tu aplicación. Por ejemplo:

• Si quieres gráficos y componentes ricos en una aplicación JavaFX/WPF es tu opción.
• Si quieres gráficos y componentes ricos y además portabilidad, JavaFX es tu mejor opción, ya que WPF no es soportada por Mono (Mono es la implementación libre de .NET en Linux/Mac) y según los líderes del proyecto, no tienen pensado agregarlo al proyecto.
•   Si quieres gráficos y componentes ricos, portabilidad y además buen rendimiento, tu opción es QT. QT es un Framework para crear GUI con C++ principalmente, pero existen otros bindings para Python, Java, y muchos más lenguajes. La ventaja de QT C++ es que corre nativamente en el sistema operativo (aunque esto no suele ser un problema en la actualidad según últimos benchmarks). QT con C++ puede consumir 45-60% de RAM de lo consume la misma aplicación escrita en Java y utilizando JavaFX.

JavaFX demo:


QT5 demo:


WPF demo:

JPanel llama automáticamente al método paintComponent(Graphics g) cuando se detecta algún posible cambio en la pantalla (movimiento de ventana, etc). Para hacer que un JPanel actualice su gráfica en un momento deseado basta con llamar al método repaint(). También puedes crear un método dibujar(JPanel panel, List<Nodo> nodos) que acepte la lista de nodos actual y un panel, y respecto a eso graficar algo en el panel recibido.