¿Que es un StringTokenizer?

La clase StringTokenizer nos ayuda a dividir un string en substrings o tokens, en base a otro string (normalmente un carácter) separador entre ellos denominado delimitador.

Supongamos un string consistente en el nombre, y los dos apellidos de una persona separados por espacios en blanco. La clase StringTokenizer nos ayuda a romper dicho string en tres substrings basado en que el carácter delimitador es un espacio en blanco.

Un control área de texto, permite varias líneas de texto, cada línea está separada de la siguiente mediante un carácter nueva línea '\n' que se obtiene pulsando la tecla Enter o Retorno. Mediante una función denominada getText obtenemos todo el texto que contiene dicho control. La clase StringTokenizer nos permite dividir el string obtenido en un número de substrings o tokens igual al número de líneas de texto, basado en que el carácter delimitador es '\n'.

Para usar la clase StringTokenizer tenemos que poner al principio del archivo del código fuente la siguiente sentencia import.

import java.util.*;

o bien

import java.util.StringTokenizer;

Arreglos (Arrays) en Java

Los arreglos en Java son dinámicos, pero no extensibles, lo cual significa que deben ser creados con el tamaño que tendrán hasta el final de su vida.

Un arreglo se declara de la siguiente forma:

[] ;

O sea, para declarar, por ejemplo, un arreglo de números enteros utilizaremos la siguiente sentencia:

int[] arrInt;

Es importante notar que el arreglo aún no ha sido creado, sino meramente declarado. Para crear el arreglo (reservar su memoria e inicializarlo) deberemos recurrir al operador new:

arrInt = new int[10];

Este comportamiento debe comprenderse de esta forma: en Java todo es un objeto, y los objetos deben ser creados mediante el operador new. El caso de los arreglos no es diferente, el tipo de datos del arreglo (int[] en este caso) es una clase y cada una de sus instancias debe ser creada explícitamente, el tamaño puede pensarse como un parámetro al constructor de la clase.

A partir de este momento podemos utilizar arrInt como un arreglo de cualquier otro lenguaje.

Una de las características que hacen de Java un entorno de programación seguro, y que se relaciona con el manejo de los arreglos es que el lenguaje no permite la indexación de arreglos fuera de rango, o sea, una asignación de este tipo generará una excepción:

ArrInt[25] = 1;

Otra forma de declararlos es la siguiente:

UNIDIMENSIONALES:

tipo nombre_array[]=new tipo[nº];

tipo nombre_array[]={valores};

BIDIMENSIONALES:

tipo nombre_array[][]=new tipo[nº][nº];

tipo nombre_array[][]={valores};

Algunas de sus características más importantes son las siguientes:

1. Los arrays se crean con el operador new seguido del tipo y número de elementos.

2. Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo, vect.length).

3. Se accede a los elementos de un array con los corchetes [] y un índice que varía de length-1.

4. Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new.

5. Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero para valores numéricos, el carácter nulo para char, false para boolean, null para Strings y para referencias).

6. Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia.

7. Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método).

Inicialización de arrays:

1. Los arrays se pueden inicializar con valores entre llaves {...} separados por comas.

2. También los arrays de objetos se pueden inicializar con varias llamadas a new dentro de unas llaves {...}.

3. Si se igualan dos referencias a un array no se copia el array, sino que se tiene un array con dos nombres, apuntando al mismo y único objeto.

4. Creación de una referencia a un array. Son posibles dos formas:

double[] x; // preferible

double x[];

5. Creación del array con el operador new:

x = new double[100];

6. Las dos etapas 4 y 5 se pueden unir en una sola:

double[] x = new double[100];

Clase: PeliculaVHS

import java.util.ArrayList;

/**
*
*
* @version 1.0
*/
public class PeliculaVHS extends Pelicula implements InfVHS {

private String formato;
private String idioma;

/**
* @param titulo campo que contiene el titulo de la PeliculaVHS
* @param actores campo que contiene los actores de la PeliculaVHS
* @param director campo que contiene el director de la PeliculaVHS
* @param formato campo que contiene el formato de la PeliculaVHS
* @param idioma campo que contiene el idioma de la PeliculaVHS
*/
PeliculaVHS(String titulo, ArrayList actores, String director,
String formato, String idioma) {
super(titulo, actores, director);
this.formato = formato;
this.idioma = idioma;
}

/**
* Devuelve el valor del atributo Formato
*
* @return formato de la PeliculaVHS
*/
public void setFormato(String formato) {
this.formato = formato;
}

/**
* Devuelve el valor del atributo Idioma
*
* @return idioma de la PeliculaVHS
*/
public void setIdioma(String idioma) {
this.idioma = idioma;
}

/**
* Devuelve el valor del atributo Formato
*
* @return formato de la PeliculaVHS
*/
public String getFormato() {

return formato;
}

/**
* Devuelve el valor del atributo Idioma
*
* @return idioma de la PeliculaVHS
*/
public String getIdioma() {

return idioma;
}

/**
* Metodo Polimorfico
*/
public String toString() {

String cadena = super.toString();
cadena += " Formato: " + formato + " Idioma: " + idioma;
return cadena;
}


}

Clase: PeliculaDVD

import java.util.*;

/**
*
*
* @version 1.0
*/
public class PeliculaDVD extends Pelicula {

private int codigoRegion;
private ArrayList audioPistas;
private ArrayList subtitulosIdiomas;

/**
* @param titulo campo que contiene el titulo de la PeliculaDVD
* @param actores campo que contiene los actores de la PeliculaDVD
* @param director campo que contiene el director de la PeliculaDVD
* @param codigoRegion campo que contiene el codigo de la Region de la PeliculaDVD
* @param audioPistas campo que contiene el audio de las pistas de laPeliculaDVD
* @param subtitulosIdiomas campo que contiene los idiomas de la PeliculaDVD
*/
PeliculaDVD(String titulo, ArrayList actores, String director,
int codigoRegion, ArrayList audioPistas,
ArrayList subtitulosIdiomas) {
super(titulo, actores, director);
this.codigoRegion = codigoRegion;
this.audioPistas = audioPistas;
this.subtitulosIdiomas = subtitulosIdiomas;
}

/**
* Devuelve el valor del atributo CodigoRegion
*
* @return codigoRegion de la PeliculaDVD
*/
public int getCodigoRegion(){

return codigoRegion;
}

/**
* Devuelve el valor del ArrayList AudioPistas
*
* @return titulo de la PeliculaDVD
*/
public ArrayList getAudioPistas() {

return audioPistas;
}

/**
* Devuelve el valor del ArrayList SubtitulosIdiomasDVD
*
* @return SubtitulosIdiomas de la Pelicula
*/
public ArrayList getSubtitulosIdiomas() {

return subtitulosIdiomas;
}

/**
* Metodo Polimorfico
*/
public String toString() {

String cadena = super.toString();
cadena += " CodigoRegion: " + codigoRegion + " Pistas: " ;

for(String item : audioPistas) {
cadena += item + " ";
}

cadena += " Subtitulos: ";

for(String item : subtitulosIdiomas) {
cadena += item + " ";
}

return cadena;
}


}

Clase: Pelicula

/**
*
*/


import java.util.*;

/**
*
*
* @version 1.0
*/
public abstract class Pelicula {

/*Atributo que almacena el valor del titulo*/
protected String titulo;

/*Atributo que almacena un ArrayList de actores*/
protected ArrayList actores;

/*Atributo que almacena el valor de director*/
protected String director;

/**
* @param titulo campo que contiene el titulo de la Pelicula
* @param actores campo que contiene los actores de la Pelicula
* @param director campo que contiene el director de la Pelicula
*/
Pelicula(String titulo, ArrayList actores, String director) {

this.titulo = titulo;
this.actores = actores;
this.director = director;
}


/**
* Devuelve el valor del atributo Titulo
*
* @return titulo de la Pelicula
*/
public String getTitulo() {

return titulo;
}

/**
* Asigna un campo para el atributo Titulo
*
* @param campo que contiene valor del Titulo
*/
public void setTitulo(String titulo) {

this.titulo = titulo;
}

/**
* Devuelve el valor del atributo Actores
*
* @return el valor Actores
*/
public ArrayList getActores() {

return actores;
}

/**
* Asigna un campo para el ArrayList Actores
*
* @param actores contiene el campo para el atributo Actores
*/
public void setActores(ArrayList actores) {

this.actores = actores;
}

/**
* Devuelve el valor del atributo Director
*
* @return el valor Director
*/
public String getDirector() {

return director;
}

/**
* Asigna un campo para el atributo Director
*
* @param director contiene el campo para el atributo Director
*/
public void setDirector(String director) {
this.director = director;
}

/**
* Metodo Polimorfico
*/

public String toString() {

String cadena = "Titulo: " + titulo + " Actores: ";

for(String item : actores) {
cadena += item + " ";
}

cadena += " Director: " + director;

return cadena;
}



}

Clase: InfVHS

/**
* Interfase de la informacion de VHS
*
*
* @version 1.0
*/


/**
*
*
*/
public interface InfVHS {

public String getFormato();
public String getIdioma();
}

Clase: InfDVD

/**
* Interfase de la informacion del DVD
*
*
* @version 1.0
*/


import java.util.*;

public interface InfDVD {

public int getCodigoRegion();
public ArrayList getAudioPistas();
public ArrayList getSubtitulosIdiomas();
}

Clase principal: AplicaVideo

import java.io.*;
import java.util.*;

/**
*
*
*@version 1.0
*/
public class AplicaVideo {
/**
* @param args
*/
public static void main(String[] args) {


BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
ArrayList peliculas= new ArrayList();



int op = 0;

while (op != 5)

try{
System.out.println(" PELICULAS");
System.out.println(" 1. Agregar Película");
System.out.println(" 2. Listar Películas VHS");
System.out.println(" 3. Listar Películas DVD");
System.out.println(" 4. Buscar");
System.out.println(" 5. Salir");
System.out.println("ESCOJA UNA OPCIÓN");

/* Almacena el valor de la opción escogida en op */

op = Integer.parseInt(stdIn.readLine());


/* switch que controla la opción escogida*/
switch (op){
case 1:
System.out.println("Ingrese la pelicula");
System.out.println("Es VHS o DVD");

String respuesta = stdIn.readLine();

System.out.println("Ingrese de la siguiente manera:");
if (respuesta.equals("VHS")) {
System.out.println(
"Titulo , Actores: Actor Principal, Actor Secundario," +
"Director, Formato, Idioma");

StringTokenizer strToken =
new StringTokenizer(stdIn.readLine(), ",");

String titulo = strToken.nextToken();
ArrayList actores = new ArrayList();
actores.add(strToken.nextToken());
actores.add(strToken.nextToken());
String director = strToken.nextToken();
String formato = strToken.nextToken();
String idioma = strToken.nextToken();

Pelicula pelicula = new PeliculaVHS(titulo,actores,director,formato,idioma);
peliculas.add(pelicula);

} else {
System.out.println(
"Titulo , Actores: Actor Principal, Actor Secundario," +
"Director, codigo, subtitulos: sub 1 ; sub 2 ; etc, Pistas : pista1; pista2;etc");

StringTokenizer strToken =
new StringTokenizer(stdIn.readLine(), ",");

String titulo = strToken.nextToken();
ArrayList actores = new ArrayList();
actores.add(strToken.nextToken());
actores.add(strToken.nextToken());
String director = strToken.nextToken();
int codigoRegion = Integer.parseInt(strToken.nextToken());


StringTokenizer strToken2 =
new StringTokenizer(strToken.nextToken(), ";");

ArrayList subtitulos = new ArrayList();
while (strToken2.hasMoreTokens()) {
subtitulos.add(strToken2.nextToken());
}

StringTokenizer strToken3 =
new StringTokenizer(strToken.nextToken(), ";");

ArrayList pistas = new ArrayList();
while (strToken3.hasMoreTokens()) {
pistas.add(strToken3.nextToken());
}

Pelicula pelicula = new PeliculaDVD(titulo,actores,director,codigoRegion,subtitulos,pistas);
peliculas.add(pelicula);
}

break;
case 2:
String lista = "";

for (Pelicula item : peliculas){
if(item instanceof PeliculaVHS){

lista += item.toString() + "\n";
}
}
System.out.println(lista);

case 3:

String lista1 = "";

for (Pelicula item : peliculas){
if(item instanceof PeliculaDVD){

lista1 += item.toString() + "\n";
}
}
System.out.println(lista1);




break;
case 4:

System.out.println("Ingrese mediante el titulo la pelicula a buscar");
String titulo = stdIn.readLine();

for(Pelicula item : peliculas){

if(item.getTitulo().equalsIgnoreCase(titulo)){

System.out.println(item);
}else{
System.out.println("NO EXISTE");
}


}


break;



}
}catch(NumberFormatException e) {
System.out.println("error "+e.getMessage());
}catch (IOException e) {
System.out.println("error "+e.getMessage());
}catch (NullPointerException e) {
System.out.println("error "+e.getMessage());
}catch (Exception e) {
System.out.println("error "+e.getMessage());
}
}
}

PROYECTO: Clasificación y listado de peliculas.

En el proyecto se propone un programa capaz de permitirnos almacenar peliculas, clasificarlas si son del tipo VHS o DVD, y posteriormente desplegar todas las peliculas ingresadas en una lista, e incluso muestra una opción de búsqueda de títulos de películas, todo esto con un menú para la interacción.

Acá se muestra el diseño del menú en donde se aprecia el alcance del programa:

Se utilizó Eclipse en la realización del proyecto, pero qué es Eclipse?

El entorno de desarrollo Eclipse

¿Qué es Eclipse?

Eclipse es una plataforma de desarrollo open source basada en Java. Es un desarrollo de IBM cuyo código fuente fue puesto a disposición de los usuarios. En sı mismo Eclipse es un marco y un conjunto de servicios para construir un entorno de desarrollo a partir de componentes conectados (plug-in). Hay plug-ins para el desarrollo de Java (JDT Java Development Tools) ası como para el desarrollo en C/C++, COBOL, etc.

Trabajando con Eclipse

Eclipse contiene una serie de perspectives. Cada perspectiva proporciona una serie de funcionali- dades para el desarrollo de un tipo especıfico de tarea. Por ejemplo la perspectiva Java combina un conjunto de views que permiten ver información útil cuando se está escribiendo código fuente, mientras que la perspectiva de depuración contiene vistas que muestran información útil para la depuración de los programas Java.

PERFIL CREADO

El perfil está listo y ahora se investigará un poco más sobre la manera de subir la información del proyecto final mientras se progresa en su elaboración.