(anterior) Esta sección trata el procesamiento de palabras, oraciones, caracteres y grupos de caracteres. Se presentan las clases String, StringBuffer, Character y StringTokenizer. También se presentan ejemplos de la API de Java para las expresiones regulares, la cual permite a los programas buscar en las cadenas secuencias de caracteres que concuerden con ciertos patrones especificados.

Métodos static de Character para probar caracteres y cambiar mayúsculas/minúsculas

// Métodos static de Character para probar caracteres y cambiar mayúsculas/minúsculas.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MetodosStaticChar extends JFrame {
   private char c;
   private JLabel indicadorEtiqueta;
   private JTextField entradaCampo;
   private JTextArea areaSalida;

   // el constructor crea la GUI
   public MetodosStaticChar()
   {
      super( "Métodos estáticos de Character" );

      Container contenedor = getContentPane();
      contenedor.setLayout( new FlowLayout() );

      indicadorEtiqueta = new JLabel( "Escriba un carácter y oprima Intro" );
      contenedor.add( indicadorEtiqueta );
      entradaCampo = new JTextField( 5 );

      entradaCampo.addActionListener(

         new ActionListener() {  // clase interna anónima

            // manejar evento del campo de texto
            public void actionPerformed( ActionEvent evento )
            {
               String s = evento.getActionCommand();
               c = s.charAt( 0 );
               crearSalida();
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      contenedor.add( entradaCampo );
      areaSalida = new JTextArea( 10, 20 );
      contenedor.add( areaSalida );

      setSize( 300, 225 );  // establecer el tamaño de la ventana
      setVisible( true);    // mostrar la ventana

   } // fin del constructor

   // mostrar información del carácter en areaSalida
   private void crearSalida()
   {
      areaSalida.setText( "está definido: " + Character.isDefined( c ) +
         "\nes dígito: " + Character.isDigit( c ) +
         "\nes primer caracter en un identificador de Java: " +
         Character.isJavaIdentifierStart( c ) +
         "\nes parte de un identificador de Java: " +
         Character.isJavaIdentifierPart( c ) +
         "\nes letra: " + Character.isLetter( c ) +
         "\nes letra o dígito: " + Character.isLetterOrDigit( c ) +
         "\nes minúscula: " + Character.isLowerCase( c ) +
         "\nes mayúscula: " + Character.isUpperCase( c ) +
         "\na mayúscula: " + Character.toUpperCase( c ) +
         "\na minúscula: " + Character.toLowerCase( c ) );
   }

   // crear objeto MetodosStaticChar para empezar la ejecución
   public static void main( String args[] )
   {
      MetodosStaticChar aplicacion = new MetodosStaticChar();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase MetodosStaticChar

Descargar código fuente

Métodos static de Character para la conversión de caracteres

// Métodos estáticos de Character para conversión de caracteres.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MetodosStaticChar2 extends JFrame {
   private char c;
   private int digito, raiz;
   private JLabel indicador1, indicador2;
   private JTextField entrada, raizCampo;
   private JButton enChar, enInt;

   // el constructor crea la GUI
   public MetodosStaticChar2()
   {
      super( "Métodos de conversión de Character" );

      Container contenedor = getContentPane();
      contenedor.setLayout( new FlowLayout() );

      indicador1 = new JLabel( "Escriba un dígito o caracter " );
      entrada = new JTextField( 5 );
      contenedor.add( indicador1 );
      contenedor.add( entrada );

      indicador2 = new JLabel( "Escriba una raíz " );
      raizCampo = new JTextField( 5 );
      contenedor.add( indicador2 );
      contenedor.add( raizCampo );

      enChar = new JButton( "Convertir dígito en carácter" );
      enChar.addActionListener(

         new ActionListener() { // clase interna anónima

            // manejar evento de objeto JButton enChar
            public void actionPerformed( ActionEvent eventoAccion )
            {
               digito = Integer.parseInt( entrada.getText() );
               raiz = Integer.parseInt( raizCampo.getText() );
               JOptionPane.showMessageDialog( null,
                  "Convertir dígito en carácter: " +
                  Character.forDigit( digito, raiz ) );
            }

         } // fin de clase interna anónima

      ); // fin de la llamada a addActionListener

      enInt = new JButton( "Convertir carácter en dígito" );
      enInt.addActionListener(

         new ActionListener() {  // clase interna anónima

            // manejar evento de objeto JButton enInt
            public void actionPerformed( ActionEvent eventoAccion )
            {
               String s = entrada.getText();
               c = s.charAt( 0 );
               raiz = Integer.parseInt( raizCampo.getText() );
               JOptionPane.showMessageDialog( null,
                  "Convertir carácter en dígito: " +
                  Character.digit( c, raiz ) );
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      contenedor.add( enChar );
      contenedor.add( enInt );
      setSize( 275, 150 );  // establecer el tamaño de la ventana
      setVisible( true );   // mostrar la ventana
   }

   // crear objeto MetodosStaticChar2 para ejecutar la aplicación
   public static void main( String args[] )
   {
      MetodosStaticChar2 aplicacion = new MetodosStaticChar2();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase MetodosStaticChar2

Descargar código fuente

Métodos no static de Character

// Métodos no estáticos de Character.
import javax.swing.*;

public class OtrosMetodosChar {

   public static void main( String args[] )
   {
      Character c1 = new Character( 'A' );
      Character c2 = new Character( 'a' );

      String salida = "c1 = " + c1.charValue() +
         "\nc2 = " + c2.toString();

      if ( c1.equals( c2 ) )
         salida += "\n\nc1 y c2 son iguales";
      else
         salida += "\n\nc1 y c2 no son iguales";

      JOptionPane.showMessageDialog( null, salida,
         "Métodos no estáticos de Character",
         JOptionPane.INFORMATION_MESSAGE );

      System.exit( 0 );
   }

} // end class OtrosMetodosChar

Descargar código fuente

La clase StringTokenizer

// La clase StringTokenizer.
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaToken extends JFrame {
   private JLabel indicadorEtiqueta;
   private JTextField entradaCampo;
   private JTextArea areaSalida;

   // configurar GUI y manejo de eventos
   public PruebaToken()
   {
      super( "Prueba de la clase StringTokenizer" );

      Container contenedor = getContentPane();
      contenedor.setLayout( new FlowLayout() );

      indicadorEtiqueta = new JLabel( "Escriba una oración y oprima Intro" );
      contenedor.add( indicadorEtiqueta );

      entradaCampo = new JTextField( 20 );
      entradaCampo.addActionListener(

         new ActionListener() {  // clase interna anónima

            // manejar evento de campo de texto
            public void actionPerformed( ActionEvent evento )
            {
               StringTokenizer tokens =
                  new StringTokenizer( evento.getActionCommand() );

               areaSalida.setText( "Número de elementos: " +
                  tokens.countTokens() + "\nLos tokens son:\n" );

               while ( tokens.hasMoreTokens() )
                  areaSalida.append( tokens.nextToken() + "\n" );
            }

         } // fin de clase interna anónima

      ); // fin de la llamada a addActionListener

      contenedor.add( entradaCampo );

      areaSalida = new JTextArea( 10, 20 );
      areaSalida.setEditable( false );
      contenedor.add( new JScrollPane( areaSalida ) );
      setSize( 275, 240 );  // establecer el tamaño de la ventana
      setVisible( true );   // mostrar la ventana
   }

   // ejecutar la aplicación
   public static void main( String args[] )
   {
      PruebaToken aplicacion = new PruebaToken();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   } 

} // fin de la clase PruebaToken

Descargar código fuente

Validación de la información del usuario mediante expresiones regulares

// Validación de la información del usuario mediante expresiones regulares.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ValidarFrame extends JFrame {
   private JTextField telefonoCampoTexto, codigoPostalCampoTexto, estadoCampoTexto,
      ciudadCampoTexto, direccionCampoTexto, nombreCampoTexto, apellidoCampoTexto;

   public ValidarFrame()
   {
      super( "Validación" );

      // crear los componentes de GUI
      JLabel telefonoEtiqueta = new JLabel( "Teléfono" );
      JLabel codigoPostalEtiqueta = new JLabel( "C.P." );
      JLabel estadoEtiqueta = new JLabel( "Estado" );
      JLabel ciudadEtiqueta = new JLabel( "Ciudad" );
      JLabel direccionEtiqueta = new JLabel( "Dirección" );
      JLabel nombreEtiqueta = new JLabel( "Primer nombre" );
      JLabel apellidoEtiqueta = new JLabel( "Apellido paterno" );

      JButton aceptarBoton = new JButton( "Aceptar" );
      aceptarBoton.addActionListener( 

         new ActionListener() { // clase interna

            public void actionPerformed( ActionEvent evento ) {
               validarFecha();
            }

         } // fin de la clase interna

      ); // fin de la llamada a addActionListener

      telefonoCampoTexto = new JTextField( 15 );
      codigoPostalCampoTexto = new JTextField( 5 );
      estadoCampoTexto = new JTextField( 2 );
      ciudadCampoTexto = new JTextField( 12 );
      direccionCampoTexto = new JTextField( 20 );
      nombreCampoTexto = new JTextField( 20 );
      apellidoCampoTexto = new JTextField( 20 );

      JPanel primerNombre = new JPanel();
      primerNombre.add( nombreEtiqueta );
      primerNombre.add( nombreCampoTexto );

      JPanel apellidoPaterno = new JPanel();
      apellidoPaterno.add( apellidoEtiqueta );
      apellidoPaterno.add( apellidoCampoTexto );

      JPanel direccion1 = new JPanel();
      direccion1.add( direccionEtiqueta );
      direccion1.add( direccionCampoTexto );

      JPanel direccion2 = new JPanel();
      direccion2.add( ciudadEtiqueta );
      direccion2.add( ciudadCampoTexto );
      direccion2.add( estadoEtiqueta );
      direccion2.add( estadoCampoTexto );
      direccion2.add( codigoPostalEtiqueta );
      direccion2.add( codigoPostalCampoTexto );

      JPanel telefono = new JPanel();
      telefono.add( telefonoEtiqueta );
      telefono.add( telefonoCampoTexto );

      JPanel aceptar = new JPanel();
      aceptar.add( aceptarBoton );

      // agregar los componentes a la aplicación
      Container contenedor = getContentPane();
      contenedor.setLayout( new GridLayout( 6, 1 ) );

      contenedor.add( primerNombre );
      contenedor.add( apellidoPaterno );
      contenedor.add( direccion1 );
      contenedor.add( direccion2 );
      contenedor.add( telefono );
      contenedor.add( aceptar );

      setSize( 400, 225 );
      setVisible( true );

   } // fin del constructor de ValidarFrame

   public static void main( String args[] )
   {
      ValidarFrame aplicacion = new ValidarFrame();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

   // maneja el evento de acción de aceptarBoton
   private void validarFecha()
   {
      // asegurar que no haya cuadros de texto vacíos
      if ( apellidoCampoTexto.getText().equals( "" ) ||
           nombreCampoTexto.getText().equals( "" ) ||
           direccionCampoTexto.getText().equals( "" ) ||
           ciudadCampoTexto.getText().equals( "" ) ||
           estadoCampoTexto.getText().equals( "" ) ||
           codigoPostalCampoTexto.getText().equals( "" ) ||
           telefonoCampoTexto.getText().equals( "" ) ) // fin de la condición

         JOptionPane.showMessageDialog( this, "Por favor llene todos los campos" );

      // si el formato de primer nombre es inválido, mostrar mensaje
      else if ( !nombreCampoTexto.getText().matches( "[A-Z][a-zA-Z]*" ) )
         JOptionPane.showMessageDialog( this, "Primer nombre inválido" );

      // si el formato de apellido paterno es inválido, mostrar mensaje
      else if ( !apellidoCampoTexto.getText().matches( "[A-Z][a-zA-Z]*" ) )
         JOptionPane.showMessageDialog( this, "Apellido inválido" ); 

      // si el formato de dirección es inválido, mostrar mensaje
      else if ( !direccionCampoTexto.getText().matches(
                "\\d+\\s+([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)" ) )
         JOptionPane.showMessageDialog( this, "Dirección inválida" );

      // si el formato de ciudad es inválido, mostrar mensaje
      else if ( !ciudadCampoTexto.getText().matches(
                "([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)" ) )
         JOptionPane.showMessageDialog( this, "Ciudad inválida" ); 

      // si el formato de estado es inválido, mostrar mensaje
      else if ( !estadoCampoTexto.getText().matches(
                "([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)" ) )
         JOptionPane.showMessageDialog( this, "Estado inválido" ); 

      // si el formato de código postal es inválido, mostrar mensaje
      else if ( !codigoPostalCampoTexto.getText().matches( "\\d{5}" ) )
         JOptionPane.showMessageDialog( this, "Código postal inválido" ); 

      // si el formato de teléfono es inválido, mostrar mensaje
      else if ( !telefonoCampoTexto.getText().matches(
                 "[1-9]\\d{2}-[1-9]\\d{2}-\\d{4}" ) )
         JOptionPane.showMessageDialog( this, "Número telefónico inválido" ); 

      else // la información es válida, avisar al usuario
         JOptionPane.showMessageDialog( this, "Gracias" ); 

   } // fin del método validarFecha

} // fin de la clase ValidarFrame

Descargar código fuente

Métodos replaceFirst, replaceAll y split

// Uso de los métodos replaceFirst, replaceAll y split.
import javax.swing.*;

public class SustitucionExpReg
{
   public static void main( String args[] )
   {
      String primerString = "Este enunciado termina con 5 estrellas *****";
      String segundoString = "1, 2, 3, 4, 5, 6, 7, 8";

      String salida = "String original 1: " + primerString;

      // reemplazar '*' con '^'
      primerString = primerString.replaceAll( "\\*", "^" );

      salida += "\n^ reemplazó a *: " + primerString;

      // reemplazar 'estrellas' con 'intercaladores'
      primerString = primerString.replaceAll( "estrellas", "intercaladores" );

      salida += "\n\"intercaladores\" reemplazan a \"estrellas\": " + primerString;

      // reemplazar palabras con 'palabra'
      salida += "\nCada palabra reemplazada por \"palabra\": " +
         primerString.replaceAll( "\\w+", "palabra" );

      salida += "\n\nString original 2: " + segundoString;

      // reemplazar primeros tres dígitos con 'digito'
      for ( int i = 0; i < 3; i++ )
         segundoString = segundoString.replaceFirst( "\\d", "digito" );

      salida += "\nPrimeros 3 dígitos reemplazados por \"digito\" : " +
         segundoString;
      salida += "\nString dividido en las comas: [";

      String[] resultados = segundoString.split( ",\\s*" ); // dividir en comas

      for ( int i = 0; i < resultados.length; i++ )
         salida += "\"" + resultados[ i ] + "\","; // mostrar resultados

      // eliminar la coma adicional y agregar un corchete
      salida = salida.substring( 0, salida.length() - 2 ) + "]";

      JOptionPane.showMessageDialog( null, salida );
      System.exit( 0 );

   } // fin del método main

} // fin de la clase SustitucionExpReg

Descargar código fuente

Concordancias Expresiones Regulares, utilizando las clases Pattern y Matcher

// Demonstrating Classes Pattern and Matcher.
import java.util.regex.*;
import javax.swing.*;

class ConcordanciasExpReg
{
	public static void main( String args[] )
	{
		String salida = "";

		// crear expresión regular
		Pattern expresion =
		Pattern.compile( "J.*\\d[0-35-9]-\\d\\d-\\d\\d" );

		String cadena1 = "Jacinto nació el 05-12-75\n" +
		"Javid nació el 11-04-68\n" +
		"Miguel nació el 04-28-73\n" +
		"Juan nació el 12-17-77";

		// comparar expresión regular con la cadena e imprimir concordancias
		Matcher matcher = expresion.matcher( cadena1 );

		while ( matcher.find() )
		salida += matcher.group() + "\n";
		JOptionPane.showMessageDialog( null, salida );
		System.exit( 0 );
	} // fin de main
} // fin de la clase ConcordanciasExpReg

Descargar código fuente