next_inactive up previous contents
Subir: Introducción a Java y Anterior: 10 Programación Multihilo (Multihebra)   Índice General

Subsecciones

11 Connected Limited Device Configuration: CLDC

1 ¿Qué son las configuraciones en J2ME?

2 La configuración CLDC

1 La máquina virtual Java de CLDC

3 La librería de clases de CLDC

1 Paquete java.lang

$ \Diamond$ La clase Object

Clases de envoltura para tipos simples

Existe una clase de envoltura por cada uno de los tipos simples.

$ \Diamond$ Clases de envoltura para tipos numéricos

$ \Diamond$ Clase Character: envoltura para char

$ \Diamond$ Clase Boolean: envoltura para boolean

$ \Diamond$ Características de reflexión

$ \Diamond$ Propiedades del sistema

$ \Diamond$ Las clases System y Runtime

2 Paquete java.util

Contiene clases de colección y clases relacionadas con la fecha y la hora, y la clase Random usada para generar n'umeros aleatorios.

$ \Diamond$ Clases de colección

CLDC incluye las siguientes clases e interfaz para manejar colecciones de objetos:

$ \Diamond$ Interfaz Enumeration

Define los métodos que permiten enumerar (obtener uno cada vez) los elementos de un conjunto de objetos. Esta interfaz define los dos métodos siguientes:

Ejemplo: P60/EnumerateDemo.java 

import java.util.Enumeration;
class Enum implements Enumeration {
  private int count = 0;
  private boolean more = true;
  public boolean hasMoreElements() {
    return more;
  }
  public Object nextElement() {
    count++;
    if(count > 4)
      more = false;
      return new Integer(count);
  }
}
class EnumerateDemo {
  public static void main(String args[]) {
    Enumeration enum = new Enum();

    while(enum.hasMoreElements()) {
      System.out.println(enum.nextElement());
    }
  }
}

Salida del programa 

1
2
3
4
5

$ \Diamond$ Clase Vector

Los arrays o matrices de Java son de longitud fija. Una vez creados no se puede modificar su tamaño, lo que implica que necesitamos conocer a priori el número de elementos que van a almacenar.
Para resolver este problema, Java define la clase Vector.

Ejemplo: P61/VectorDemo.java 

import java.util.Vector;
import java.util.Enumeration;
class VectorDemo {
  public static void main(String args[]) {
    Vector v = new Vector(3, 2);
    System.out.println("Tamaño inicial: " + v.size());
    System.out.println("Capacidad inicial: " + v.capacity());
    v.addElement(new Integer(1));
    v.addElement(new Integer(2));
    v.addElement(new Integer(3));
    v.addElement(new Integer(4));
    System.out.println("Capacidad después de añadir 4 elementos: " +
                       v.capacity());
    v.addElement(new Double(5.45));
    System.out.println("Capacidad actual: " + v.capacity());
    v.addElement(new Double(6.08));
    v.addElement(new Integer(7));
    System.out.println("Capacidad actual: " +
                       v.capacity());
    v.addElement(new Float(9.4));
    v.addElement(new Integer(10));
    System.out.println("Capacidad actual: " +
                       v.capacity());
    v.addElement(new Integer(11));
    v.addElement(new Integer(12));
    System.out.println("Primer elemento: " +
                       (Integer)v.firstElement());
    System.out.println("Último elemento: " +
                       (Integer)v.lastElement());
    if(v.contains(new Integer(3))) 
      System.out.println("El Vector contiene 3.");
    Enumeration vEnum = v.elements();
    System.out.println("\nElementos en el vector:");
    while(vEnum.hasMoreElements())
      System.out.print(vEnum.nextElement() + " ");
    System.out.println();
  }
}

Salida del programa 

Tamaño inicial: 0
Capacidad inicial: 3
Capacidad después de añadir 4 elementos: 5
Capacidad actual: 5
Capacidad actual: 7
Capacidad actual: 9
Primer elemento: 1
Último elemento: 12
El Vector contiene 3.

Elementos en el vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12

$ \Diamond$ Clase Stack

Es una subclase de la clase Vector que implementa una pila del tipo último en entrar, primero en salir

Ejemplo: P62/StackDemo.java 

import java.util.Stack;
import java.util.EmptyStackException;
class StackDemo {
  static void showpush(Stack st, int a) {
    st.push(new Integer(a));
    System.out.println("push(" + a + ")");
    System.out.println("stack: " + st);
  }
  static void showpop(Stack st) {
    System.out.print("pop -> ");
    Integer a = (Integer) st.pop();
    System.out.println(a);
    System.out.println("stack: " + st);
  }


  public static void main(String args[]) {
    Stack st = new Stack();
    System.out.println("stack: " + st);
    showpush(st, 42);
    showpush(st, 66);
    showpush(st, 99);
    showpop(st);
    showpop(st);
    showpop(st);
    try {
      showpop(st);
    } catch (EmptyStackException e) {
      System.out.println("pila vacía");
    }
  }
}

Salida del programa 

stack: []
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: []
pop -> pila vacía

$ \Diamond$ Clase Hashtable

Se usa para almacenar una colección de objetos que están indexados por cualquier otro objeto arbitrario.

Ejemplo: P63/HTDemo.java 

import java.util.Hashtable;
import java.util.Enumeration;
class HTDemo {
  public static void main(String args[]) {
    Hashtable balance = new Hashtable();
    Enumeration names, negbal;
    String str;
    double bal;
    balance.put("John Doe", new Double(3434.34));
    balance.put("Tom Smith", new Double(123.22));
    balance.put("Jane Baker", new Double(1378.00));
    balance.put("Tod Hall", new Double(99.22));
    balance.put("Ralph Smith", new Double(-19.08));
    names = balance.keys();
    while(names.hasMoreElements()) {
      str = (String) names.nextElement();
      System.out.println(str + ": " + balance.get(str));
    }
    System.out.println();
    bal = ((Double)balance.get("John Doe")).doubleValue();
    balance.put("John Doe", new Double(bal+1000));
    System.out.println("El nuevo saldo de John Doe es: " +
                       balance.get("John Doe"));
  }
}

Salida del programa 

Tod Hall: 99.22
Ralph Smith: -19.08
John Doe: 3434.34
Jane Baker: 1378.0
Tom Smith: 123.22

El nuevo saldo de John Doe es: 4434.34

$ \Diamond$ La clase Date

$ \Diamond$ La clase TimeZone

$ \Diamond$ La clase Calendar

Ejemplo 

Calendar cal = Calendar.getInstance();
Date date = new Date();
cal.setTime(date);
int month = cal.get(Calendar.MONTH);
int day = cal.get(Calendar.DAY_OF_MONTH);

Otro ejemplo 

// Obtenemos un Calendar y obtenemos los milisegundos
// de la fecha actual
Calendar cal = Calendar.getInstance();
Date date = new Date();
long offset = date.getTime();

// Sumamos 20 días a la fecha actual
final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000L;
offset += 20 * MILLIS_PER_DAY;
date.setTime(offset);

// Instanciamos la nueva fecha en el offset del Calendar
cal.setTime(date); 

// Obtenemos la fecha ya ajustada
month = cal.get(Calendar.MONTH);
day = cal.get(Calendar.DAY_OF_MONTH);

Otro ejemplo 

// Obtenemos día y mes de fecha actual
Calendar cal = Calendar.getInstance();
Date date = new Date();
cal.setTime(date);
int month = cal.get(Calendar.MONTH);
int day = cal.get(Calendar.DAY_OF_MONTH);

// Sumamos 20 días al campo día en el Calendar
cal.set(Calendar.DAY_OF_MONTH, day+20);

// Obtenemos la fecha ya ajustada: NO FUNCIONA BIEN
month = cal.get(Calendar.MONTH);
day = cal.get(Calendar.DAY_OF_MONTH);

$ \Diamond$ La clase Random

Se usa para generar una secuencia de n'umeros seudoaleatorios.

4 Entrada/salida en Java

1 Introducción

2 Clases de CLDC para E/S de datos: Paquete java.io

Image javaioJerarquia

3 Clases para flujos de bytes

Las clases InputStream y OutputStream son superclases abstractas de todos los flujos orientados a bytes, tal como en J2SE.

$ \Diamond$ Clase java.io.InputStream

Superclase abstracta de todos los flujos orientados a entrada de bytes.
Los m'etodos de esta clase lanzan una IOException si se producen condiciones de error.

Ejemplo 

try{
  InputStream is = Conector.openInputStream(
                            "socket://127.0.0.1:8888");
  int ch;
  while((ch = in.read()) >0) {
    // hacer algo con el dato leido
  }
} catch (IOException x) {
  // Manejar la excepción
}

$ \Diamond$ Clase java.io.OutputStream

Superclase de todos los flujos orientados a salida de bytes.
Los m'etodos de esta clase devuelven void y lanzan una IOException si se producen condiciones de error.

$ \Diamond$ Clase ByteArrayInputStream

Flujo de entrada que usa un array de bytes como origen de los datos.

Ejemplo de uso de ByteArrayInputStream: P70/ByteArrayInputStreamDemo.java 

import java.io.*;
class ByteArrayInputStreamDemo {
  public static void main(String args[]) throws IOException {
    String tmp = "abcdefghijklmnopqrstuvwxyz";
    byte b[];
    b=tmp.getBytes();
    ByteArrayInputStream input1 = new ByteArrayInputStream(b);
    ByteArrayInputStream input2 = new ByteArrayInputStream(b, 0, 3);
  }
}

Otro ejemplo de ByteArrayInputStream: P71/ByteArrayInputStreamReset.java 

import java.io.*;
class ByteArrayInputStreamReset {
  public static void main(String args[]) throws IOException {
    byte b[] = { 'a', 'b', 'c' };
    ByteArrayInputStream in = new ByteArrayInputStream(b);
    for (int i=0; i<2; i++) {
      int c;
      while ((c = in.read()) != -1) {
        if (i == 0) {
          System.out.print((char) c);
        } else {
          System.out.print(Character.toUpperCase((char) c));
        }
      }
      System.out.println();
      in.reset();
    }
  }
}

Salida 

abc
ABC

$ \Diamond$ Clase ByteArrayOutputStream Flujo de salida que usa un array de bytes como destino de los datos.

Ejemplo: P72/ByteArrayOutputStream.java 

import java.io.*;
class ByteArrayOutputStreamDemo {
  public static void main(String args[]) throws IOException {
    ByteArrayOutputStream f = new ByteArrayOutputStream();
    String s = "Esto se meterá en el array";
    byte buf[] ;
    buf=s.getBytes();
    f.write(buf);
    System.out.print("Se escribe el bufer como un string: ");
    System.out.println(f.toString());
    System.out.print("Se lee del buffer y guardamos en array: ");
    byte b[] = f.toByteArray();
    for (int i=0; i<b.length; i++) { 
      System.out.print((char) b[i]); 
    }
    System.out.println("\nHacemos un reset");
    f.reset();
    for (int i=0; i<3; i++) f.write('X');
    System.out.println("Volvemos a escribir el bufer"+
                       " como un string: " + f.toString());
  }
}

Salida del programa 

Se escribe el bufer como un string: Esto se meterá en el array
Se lee del buffer y guardamos en array: Esto se meter? en el array
Hacemos un reset
Volvemos a escribir el bufer como un string: XXX

$ \Diamond$ Clase DataOutputStream

Esta subclase de OutputStream proporciona métodos para escribir tipos de datos básicos de Java de un forma independiente de la máquina, en el subyacente flujo de salida.

Ejemplo de DataOutputStream usando un RecorStore 

public class Record{
  public String nombreJugador;
  public int puntos;
}

Record record = new Record();
record.nombreJugador = "Tomas";
record.puntos = 12345678;
// Crear los flujos de salida
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream os = new DataOutputStream(baos);
// Escribir los valores en los flujos
os.writeUTF(record.nombreJugador);
os.writeInt(record.puntos);
os.close();
//Obtener el array de bytes con los valores guardados
byte[] data = baos.toByteArray();
//Escribir el record en el record store
int id = recordStore.addRecord(data,0,data.length);

$ \Diamond$ Clase DataInputStream

Esta subclase de InputStream proporciona métodos para leer tipos de datos básicos de Java de un forma independiente de la máquina, a partir del subyacente flujo de entrada.



Ejemplo de DataInputStream con el anterior RecordStore 

byte[] data = recordStore.getRecord(recordId);
DataInputStream is = new DataInputStream(
                         new ByteArrayInputStream(data));
Record record = new Record();
record.nombreJugador = is.readUTF();
record.score = is.readInt();
is.close();

$ \Diamond$ Clase PrintStream

Extiende OutputStream y es usada para añadir funcionalidad a otro flujo de salida de bytes.
Esta funcionalidad es la capacidad de convertir los distintos tipos básicos de Java y objetos, en un formato que puede imprimirse en el subyacente OutputStream pasado al constructor de PrintStream.

4 Clases para flujos de caracteres

$ \Diamond$ Clase Reader

Es una clase abstracta que proporciona soporte para leer flujos de caracteres.

$ \Diamond$ Writer

Es de nuevo una clase abstracta que define m'etodos implementados por las subclases para proporcionar salida de caracteres.

$ \Diamond$ InputStreamReader

Esta clase extiende la clase Reader y proporciona una implementación para leer caracteres (8 bits) de un flujo de bytes InputStream convirtiéndolos en caracteres Unicode.

$ \Diamond$ OutputStreamWriter

Extiende la clase Writer y proporciona la implementación necesaria para poder escribir caracteres Unicode en un flujo de bytes OutputStream (escribe 8 bits por cada car'acter).

5 Paquete javax.microedition.io

Image javaxmicroeditionio

next_inactive up previous contents
Subir: Introducción a Java y Anterior: 10 Programación Multihilo (Multihebra)   Índice General
Andres Cano Utrera 2006-09-23