Java introduccion conceptos basicos una mira

Temario
• El lenguaje de programación Java
• Tipos de aplicaciones en Java
• Tipos de datos primitivos
• Variables
• Constantes
• Arreglos
• Operadores
• Control de flujo
• String y StringBuffer
2

Java
• Java (1995) fue desarrollado en
Sun Microsystems por
James Gosling, Bill Joy y
Guy Steele
• Influenciado por C++
• Soporta clases, encapsulación, herencia simple,
polimorfismo, interfaces, garbage collection
3

Java
• Objetivo inicial: un lenguaje de programación para
dispositivos de consumo
• Requerimientos: pequeño, rápido, confiable y
portable
• En 1994 se produce la explosión del Web, y Sun
advierte que Java es ideal para aplicaciones Internet:
– Independiente de la plataforma
– Pequeño
– Seguro
4

El Lenguaje Java
• Independiente de la plataforma
• Seguro
• Simple
• Robusto
• Orientado a Objetos
• Distribuido
• Multi-threaded
• Ref:
http://www.oracle.com/technetwork/java/javase/documentation/index.h
tml
5

El Modelo Java
• Al compilar un programa Java, se genera un
código de máquina intermedio definido por
Sun, que recibe el nombre de bytecode
6

El Modelo Java
• El código bytecode es portable entre
diferentes plataformas
7

Java Standard Edition
• Java SE es la edición estándar de Java, sobre la cual están construidas
Java ME (Mobile Edition) y Java EE (Enterprise Edition)
8

Tipos de Aplicaciones
• Usando Java es posible escribir:
– Aplicaciones stand-alone
– Aplicaciones Web (servlets,
JSP, applets)
– Componentes (JavaBeans,
Enterprise JavaBeans)
– Web Services
9

Tipos de Archivos Java
• Todo archivo define una clase o una interfaz
• Clase:
– Define e implementa un tipo de objeto
– Variables (representación)
– Procedimientos (funciones)
• estáticos (especial: main)
• y dinámicos (se ejecutan sobre un objeto)
• Interfaz
– Define la firma de un procedimiento
10

Un archivo básico para hacer un programa
que corra
11
public class MiClase {
static public void main(String[] args) {
Aqui van las instrucciones que se ejecutarán cuando se eche a
correr la clase
}
}
• El programa debe ser escrito en un archivo llamado MiClase.java
(MiClase es el nombre de la “clase” y lo inventa el programador, por
convención empieza con mayúscula
• Al compilarse se generará el archivo MiClase.class, que es el que
se ejecuta
• Si se cambia algo en el programa hay que compilarlo de nuevo para
que se refleje el cambio en el archivo class

Ejemplo 1
12
import java.util.*; //para usa Scanner
Scanner s = new Scanner(System.in);
System.out.print(″Numero de hombres ? ″);
int h = s.nextInt();
System.out.print(″Numero de mujeres ? ″);
int m = s.nextInt();
double ph = 100.0*h/(h+am);
System.out.println(″% hombres : ″+ph);
System.out.println(″% mujeres : ″+pm);
}
}

Ejemplo de una clase con mas cosas
int a; //variable de instancia
static int b; //variable de clase
public void miMetodo1( ) {
//método para objetos de la clase
...
}
static public void miMetodo2 {
//método general
...
}
...
}
}
13

Características del Lenguaje
• Case-sensitive
• Todas las sentencias terminan con un punto-
coma (;)
• Los espacios blancos (incluyendo tabs y fines
de línea) se ignoran, excepto al interior de
strings
14

Comentarios
// comentario Caracteres desde //
hasta el fin de línea
son ignorados
/* comentario */ Caracteres entre /* y
*/ son ignorados
/** comentario */ Caracteres entre /**
y */ son ignorados e
incluidos en la
documentación javadoc
15

Identificadores
• Nombre dado a una variable, clase, o método
• Comienza con una letra Unicode (incluyendo _
y $), a la que pueden seguir letras y dígitos
• Puede tener cualquier tamaño
• Ejemplos
– apellido
– $
– 
17

Unicode
• Versión extendida de la tabla de caracteres
ASCII
– Los caracteres ASCII tienen 7 bits
– Los caracteres Unicode tienen 16 bits
• Diseñado para manejar múltiples lenguajes
• La secuencia udddd permite codificar
caracteres Unicode (d es un dígito
hexadecimal)
18

Tipos, Valores y Variables
• En Java existen 2 categorías de tipos:
– Primitivos: boolean, char, byte, short, int, long, float, double
– Referencias: objetos, interfaces, arreglos
• Un objeto es una instancia de una clase o de un arreglo
• Una variable es un espacio de memoria que puede almacenar:
19
Tipo de la variable Puede almacenar
Primitivo Un valor del tipo que se declaró
Clase El valor null, o una referencia a una instancia de la
clase o de alguna subclase de la clase
Interfaz El valor null, o una referencia a una instancia de
alguna clase que implemente la interfaz
Arreglo El valor null, o una referencia a un arreglo de
elementos del tipo del arreglo

Tipos de Datos Primitivos
Tipo Valores
boolean true o false
char Carácter Unicode (de 16 bits)
byte Entero de 8 bits (con signo)
short Entero de 16 bits (con signo)
int Entero de 32 bits (con signo)
long Entero de 64 bits (con signo)
float Número flotante de 32 bits
double Número flotante de 64 bits
20

Variables
• Una variable es un espacio de almacenamiento de
datos, con un nombre y un tipo de datos asociado
• La existencia de una variable está dada por su
alcance:
– static (variable "de clase"): se crea una vez, sin importar
cuántas instancias de la clase existan
– no static (variable "de instancia"): se crea una vez por cada
instancia de la clase
– local: se crea al ejecutarse la declaración, y desaparece al
finalizar el bloque en el que fue creada
21

Variables Locales
• La declaración puede aparecer en cualquier
punto del código fuente de un método
• La variable existe mientras se ejecuta el
bloque que contiene la declaración
22

Bloque
• Cualquier número de sentencias agrupadas
entre un par de llaves { }
• Puede ser usado en cualquier lugar donde se
acepta una sentencia simple
• El bloque define el ámbito (scope) de las
variables
• El bloque provee contornos para el control de
flujo del procesamiento
23

Ambito de Variables
int a;
static int b;
public void miMetodo( ) {
int c;
if (condicion) {
int d;
} d fuera de ámbito
} c fuera de ámbito
} a y b fuera de ámbito
24

Valores Iniciales
• Variables de instancia y de clase
– tipos primitivos numéricos 0
– char 'u0000'
– boolean false
– referencias null
• Variables locales
– Deben ser inicializadas explícitamente antes de ser
usadas; de lo contrario se produce un error de
compilación
25

Precedencia de Variables
1. Variables locales
2. Parámetros de métodos
3. Variables de clase y de instancia
Ej:
class Punto {
private double x, y;
public void setX(double x) {
this.x = x;
}
}
26

Constantes
• Una vez inicializadas, no pueden ser modificadas
• Se utiliza la palabra reservada final para definir una
constante
• Típicamente las constantes se definen como static,
para no instanciarlas con cada objeto
• Ejemplo
class Circulo {
static final double PI = 3.1416;
}
27

Conversión de Tipos
• Java es fuertemente tipeado
– Chequea compatibilidad de tipos en tiempo de
compilación
– Permite hacer cast entre tipos
– Provee operadores para determinar el tipo de un
objeto en tiempo de ejecución
28

Conversion Implícita
• Cualquier valor numérico puede ser asignado
a una variable numérica que seoporte un
rango de valores más amplio
byte short int long float double
más chico más grande
• Ejemplo
int i = 1000;
double d = i;
29

Cast Explícito
• Cuando una conversión implícita no es
posible, un cast explicita la conversión a
realizar
• Sólo se permiten casts que tienen sentido
30

Cast de Tipos Primitivos
• Puede perderse precisión
double d = 20.5;
long l = (long) d;
System.out.println(l);
• Pueden perderse dígitos
long l = 1000000;
short s;
s = (short) l;
System.out.println(s);
31
20
16960

Tipos de Operadores
• Asignación
• Aritméticos
• Relacionales
• Lógicos
32

Operador de Asignación
• Se usa el símbolo = para asignar un valor
• Ejemplo
sueldo = 1000000;
validado = true;
• La asignación puede ocurrir en la declaración
String nombre = "Paula";
33

Operadores Aritméticos
+ Suma
- Resta
* Multiplicación
/ División
% Resto
34

Métodos Estáticos
• Se identifican con el selector static
• Devuelven o no un resultado de un cierto
tipo
• Reciben un número determinado de
parámetros de tipo determinado
• Métodos de igual nombre pero con distinto
número o tipo de parámetros son métodos
distintos !
35

Métodos en la misma clase
36
public int suma(int x, int y ) {
return x+y;
}
static public int suma(int x, int y, int z) {
return x+y+z
}
System.out.println(suma(5,4)+” “+suma(2,3,4));
}
}

Métodos en otra clase
37
public class MiClase { //En archivo MiClase.java
System.out.println(Sumas.suma(5,4)+” “+
Sumas.suma(2,3,4));
}
}
Ver EjemplosFunciones.ppt
public class Sumas { //En archivo Sumas.java
public int suma(int x, int y ) {
return x+y;
}
static public int suma(int x, int y, int z) {
return x+y+z
}
}

Incremento y Decremento
• i++ es equivalente a i = i + 1
i-- es equivalente a i = i - 1
• El valor de la expresión es el valor de la variable antes o
después de la operación, según si el operador se encuentra a
la izquierda o a la derecha del operando
• Ejemplo
int x = 10;
System.out.println( x++ ); // x=11, print 10
System.out.println( ++x ); // x=12, print 12
System.out.println( x ); // print 12
38

Operadores Abreviados
var op= expression
es equivalente a:
var = var op (expression)
• Ejemplo
a *= b + 1;
es equivalente a:
a = a * (b + 1);
39

Sentencias de Control de Flujo
• if / else
• switch
• for
• while
• do / while
40

if
if ( result == 0 ) {
System.out.println("No encontrado!");
}
41

if / else
if (rol.equals("administrador")) {
// acceso a administración;
} else {
// no tiene acceso a administración
}
42

Operadores Relacionales
> Mayor
>= Mayor o igual
< Menor
<= Menor o igual
== Igual
!= Distinto
43

Operadores Lógicos
&& and
|| or
! not
• Ejemplo
boolean fin =
eof ||
(str != null && str.equals(patron));
44

Operador "?"
• Expresión condicional:
– condición ? expresión 1 : expresión 2
• El valor de la expresión es expresión 1 si la condición
es verdadera, y expresión 2 de lo contrario
• Ejemplo
montoNeto = hayImpuesto ? p * 1.05 : p;
es equivalente a:
45
if (hayImpuesto) {
montoNeto = p * 1.05;
} else {
montoNeto = p;
}

if / else if / else
if ( años < 5 ) {
vacaciones = 10;
} else if ( años < 10 ) {
vacaciones = 15;
} else {
vacaciones = 20;
}
46

while y do while
• Sintaxis 1: se ejecuta 0 o más veces
while ( condición )
{ sentencias }
• Sintaxis 2: se ejecuta 1 o más veces
do
{ sentencias }
while ( condición );
47

break
• break causa el fin del ciclo en el que se
encuentra
while ( condición ) {
sentencias…
if (condición de salida) {
break;
}
más sentencias…
}
48

continue
• continue causa el fin de la iteración actual y
el paso a la siguiente
while ( condición ) {
sentencias…
if (condición siguiente iteración) {
continue;
}
más sentencias…
}
(ver ejemplos instrucciones especiales)
49

Recursividad
• Java soporta que un método se invoque a sí
mismo, de manera recursiva:
// sumatoria
int f(int n)
{
if (n == 0) {
return 0;
} else {
return n + f(n – 1);
}
}
50

switch
• Selección múltiple
• switch <expresión> debe
evaluar un int
• case <expresión> debe ser
un literal o un campo static
final
• break abandona el bloque
del switch (de otra manera
los siguientes cases son
ejecutados sin ser
evaluados)
• El bloque default es opcional
51
switch (<expresión>)
{
case <expresión>:
...
break;
case <expresión>:
...
break;
default:
...
}

Ejemplo de switch
public static void main(String[] args) {
switch (args.length) {
case 0:
FileEditor e = new FileEditor();
break;
case 1:
FileEditor e = new FileEditor(args[0]);
break;
default:
// mensaje de error y fin
}
}
52

for
• Sintaxis
for (inicialización; condición; reinicialización)
{ sentencias }
• Nota
– inicialización y reinicialización pueden ser listas
de expresiones separadas por comas
53

Ejemplo de for
for ( x=0; x<10; x++ ) {
// ejecuta el bloque mientras x < 10
}
for ( x=0, y=0; y<20; x++, y+=x ) {
// ejecuta el bloque mientras y < 20
}
54

Etiquetas (Labels)
• Los labels se usan típicamente en bloques y
ciclos
• Un label es un identificador seguido de dos
puntos:
Label1:
• El label identifica la siguiente sentencia
55

Ejemplo
search:
for (...) {
for (…) {
if (...) {
break search;
}
}
}
56

Arreglos
• Un arreglo es un objeto
• Colecciones ordenadas de elementos
– Tipos de datos primitivos (int, …)
– Referencias a objetos
• El tamaño es definido en la creación (new) y
no puede ser modificado
57

Arreglos de Tipos Primitivos
int[] x; // equivalente a int x[]
58
X
10
20
30
x[1] = 20;
x[2] = 30;
x[0] = 10;
x = new int[3];
Nota: x.length es una variable final que entrega el
tamaño del arreglo

Arreglos de Objetos
59
X
Referencias
Circulo[] x;
x[1] = new Circulo();
x = new Circulo[3];

Arreglos de Arreglos
• Java permite crear arreglos de arreglos con la
siguiente sintaxis
int[][] matriz = new int[4][];
for (int i = 0; i < matriz.length; i++) {
matriz[i] = new int[5];
for (int j = 0; j < matriz[i].length; j++) {
matriz[i][j] = i + j;
}
}
60

Inicialización de Arreglos
• Un arreglo puede inicializarse con la siguiente
sintaxis:
boolean[] respuestas = {true, false, true};
String[] nombres = {"Ana María", "Carlos"};
Circulo[] circulos = {
new Circulo(),
new Circulo(20),
new Circulo(5.5)
};
String[][] humor = {
{ "Coco Legrand", "Alvaro Salas" },
{ "Les Luthiers" },
{ "Groucho Marx", "Buster Keaton",
"Jerry Lewis", "Woody Allen" }
}; 61

for-each (desde Java 5.0)
• Java 5.0 introdujo un for simplificado para recorrer arreglos y
otras estructuras
• El siguiente método retorna la suma de los elementos de un
arreglo
62
// Java 1.4 o anterior
int sum(int[] a) {
int result = 0;
for (int i=0; i<a.length; i++) {
result += a[i];
}
return result;
}
// Java 5.0
int sum(int[] a) {
int result = 0;
for (int i : a) {
result += i;
}
return result;
}

String
• En Java los strings son objetos de la clase String
• Los objetos String son inmutables, es decir,
permanecen con el string que se les asignó en la
inicialización
• Si se desea modificar un String, debe usarse la clase
StringBuffer
• Un literal de tipo String ("hola, mundo!") da origen a
un objeto de tipo String instanciado por la máquina
virtual
63

Concatenación de Strings
• El operador + permite concatenar Strings
• El operador + no modifica los operandos, sino
que genera un nuevo objeto String con la
concatenación
String s1 = "Hola";
String s2 = ", mundo!";
s1 = s1 + s2; // s1: "Hola, mundo!"
64

Problema. Leer una lista de palabras y escribir la más larga
(de más letras) y la mayor (alfabeticamente). El fin de la
lista se indica con la palabra “fin”
Ejemplo:
Palabra(o fin) ? calculo
Palabra(o fin)? algebra
Palabra(o fin)? fisica
Palabra(o fin)? computacion
Palabra(o fin) ? fin
Más larga = computacion
Mayor = fisica

String masLarga="", mayor="";
Scanner U = new Scanner(System.in);
while(true) {
System.out.print("palabra(o fin)?")
String palabra=U.nextLine();
if(palabra.equals("fin")) break;
if(palabra.length() > masLarga.length())
masLarga=palabra;
if( palabra.compareTo(mayor) > 0)
mayor=palabra;
}
System.out.println("mas larga=" + masLarga);
System.out.println("mayor=" + mayor);
Programa

 para caracteres individuales (letra, dígito, signo especial)
 cada caracter se representa en 16 bits (2 bytes)
 convención UNICODE (extensión de ASCII)
 variables: ej: char c;
 constantes: ‘un caracter’ (entre apóstrofes)
ej: ‘ ‘, ’a’, ‘A’, ’8’, ’=’
 asignación: ej: c=’a’;
 comparación: caracter operador-relación caracter
orden entre caracteres:
‘ ‘ < ’0’ < ’1’ < ... < ’9’ <
’A’ < ... < ’Z’ < ’a’ < ... < ’z’
 operaciones aritméticas (entre representaciones internas)
ej: ‘c’-‘a’ entrega 2 (tipo int)
(char)(‘a’+2) entrega ‘c’
Tipo Char

import java.util.*;
class Caracteres {
 public static void main(String args[]) {
 Scanner C = new Scanner(System.in);
 System.out.print("ingrese numeros n1 n2 ");
 int in = C.nextInt(),
 fn = C.nextInt();
 for (int i = in; i <= fn; i++)
 System.out.println(i+" <-> "+(char)i);
 C.nextLine();
 System.out.print("ingrese letras x1 Enter x2");
 char ic = C.nextLine().charAt(0),
 fc = C.nextLine().charAt(0);
 for (int i = ic; i <= fc; i++)
 System.out.println(i+" <-> "+(int)i);
 }
}
Caracteres y enteros

Sintaxis Significado tipo Ej: String s=“casa”
x.length( ) Nº de caracteres int s.length( )=4
x.equals(y) ¿ x es igual a y ? boolean s.equals(“casa”)=true
s.equals(“Casa”)=false
x.compareTo(y) 0 si x == y
Nº < 0 si x < y
Nº > 0 si x > y
int s.compareTo(“casa”)=0
s.compareTo(“casas”)<0
s.compareTo(“Casa”)>0
x.charAt(i) carácter ubicado
en el indice i
(desde 0)
char s.charAt(2)=’s’
s.charAt(0)=’c’
s.charAt(4) error
x.indexOf(y) índice de primer
y en x
(-1 si no está)
int s.indexOf(“as”)=1
s.indexOf(“a”)=1
s.indexOf(“hola”)=-1
x.indexOf(y,i) índice de y en x
(a partir de i)
int s.indexOf(“a”,2)=3
Métodos de Strings

Ej: cuenta(‘a’,“abracadabra”) entrega 5
Solución
static public int cuenta(char x,String y)
{
int n=0;
for(int i=0; i<y.length(); ++i)
if(y.charAt(i)== x)
++n;
return n;
}
Contar las apariciones de un carácter
en un String

Métodos que devuelven String (y no modifican string original)
x.substring(i,j) string con caracteres
entre índices i y j-1
s.substring(1,3)
s.substring(2,3)
“as”
“s”
x.substring(i) x.substring(i,x.length()) s.substring(1) “asa”
x.concat(y) concatena x e y
(añade y al final de x)
s.concat(“do”)
s + “do”
“casado”
x.replace(y,z) reemplaza todos los
caracteres y por z
s.replace(‘a’,’e’) “cese”
x.toUpperCase() reemplaza minúsculas
por mayúsculas
s.toUpperCase() “CASA”
x.toLowerCase() reemplaza mayúsculas
por minúsculas
s.toLowerCase() “casa”
x.trim() elimina espacios al
comienzo y fin
“ a b “.trim() “a b”
Más métodos

static public String siOno(String x){
String r; //respuesta
while(true){
System.out.print(x+“ si o no?”)
r=U.nextLine().trim().toLowerCase();
if(r.equals(“si”)||r.equals(“no”))break;
}
return r;
}
Uso
if(siOno(“otro?”).equals(“si”))...else...
alternativamente
switch(siOno(“otro?”).charAt(0)){//admite char
case ‘s’: ...
case ‘n’: ...
}
Función para respuesta “si” o “no”

Ej: cuenta(“abra”,“abracadabra”) entrega 2
static public int cuenta(String x,String y)
iterativa
int n=0, l=x.length();
//repetir mientras se encuentre x
for(int i=0; (i=y.indexOf(x,i))>=0; i+=l)
++n;
return n;
recursiva
int i=y.indexOf(x);
if(i<0) return 0;
return 1+cuenta(x,y.substring(i+x.length()));
Apariciones de un string en otro

Ejemplos:
String s = “”+n; //si n=123, s=“123”
String s = “”+x; //si x=4.5, s=“4.5”
Conversión de String a nº entero
int n = Integer.parseInt(s);//s=”123”,n=123
class Integer{//clase predefinida
…
static public int parseInteger(String x){…}
}
Conversion de String a nº real
double x = Double.parseDouble(s);//s=”4.5”,x=4.5
class Double{//clase predefinida
…
static public double parseDouble(String x){…}
}
Conversion entre números y Strings

StringBuffer y StringBuilder
• StringBuffer y StringBuilder implementan una
secuencia de caracteres modificable
• StringBuffer realiza sincronización, y puede ser
utilizado simultáneamente por múltiples
threads
• StringBuilder (desde Java 5) no realiza
sincronización, está orientado a ser utilizado
sin concurrencia
75

Métodos de StringBuffer
• StringBuffer(String str): crea un StringBuffer a
partir de un String
• StringBuffer append(int i): concatena la
variable i en el StringBuffer
• StringBuffer append(String str): concatena la
variable str en el StringBuffer
• StringBuffer delete(int start, int end): elimina
el substring indicado
76

Métodos de StringBuffer
• int length(): retorna el número de caracteres
del StringBuffer
• StringBuffer replace(int start, int end, String
substr): reemplaza el substring entre start y
end por substr
• String substring(int start, int end): retorna un
nuevo string con el substring indicado
• String toString(): retorna un nuevo String a
partir del StringBuffer
77

La clase StringTokenizer
El Constructor de esta clase recibe un string (y optativamente también un
separador).
El string es separado en varios sub-strings, de acuerdo al separador
(espacio si no se recibe nada). Estos pueden ser recuperados
secuencialmente por el método nextToken().
También existe el método hasMoreTokens() que retorna true si todavía
quedan más substrings por retornar.
we are a happy
String s1 = “we are a happy family”
StringTokenizer st = new StringTokenizer(s1);
family
st
String s = st.getToken();
are a happy family
st
s = “we”

Ejemplos
• Conversión de un número a string
String s = String.valueOf(100);
String s = new Double(100).toString();
• Conversión de un string a número
int i = Integer.parseInt(s);
int i = new Integer(s).intValue();
79

Los Archivos de Texto
 Se organizan en líneas de texto (Strings)
 Cada línea consiste una cadena de caracteres que
termina con una marca de fin de línea
 Después de la marca de fin de línea de la última
línea viene una marca de fin de archivo
 Por convención tienen la extensión .txt
 Se generan con un editor de texto (sin formato) o
por un programa

 Escribiendo archivos de texto
Apertura de un archivo para escritura:
PrintWriter x = new PrintWriter (
 new FileWriter(filename))
Se pueden escribir líneas con los siguientes métodos:
 x.print(string) x.println(string)
Si existía un archivo con ese nombre se borra y es
reemplazado por el que genere el programa
Es importante hacer que al final se ejecute la instrucción
x.close()
para asegurarse de que los datos que aún están en el buffer
sean traspasados.
• Hay que reportar que se usan métodos que pueden
causar excepciones con throws IOException

82
Leer líneas que terminan con la palabra “fin” y grabarlas en un
archivo en disco de nombre “archivo.txt”.
import java.io.*; import java.util.*;
class CrearArchivo {
static public void main(String[]args)
throws IOException{
PrintWriter a=new PrintWriter(
new FileWriter(“archivo.txt”));
while(true){
System.out.print (“linea(o fin)?“);
String linea=U.nextLine()
if( linea.equals(“fin”) ) break;
a.println(linea);
}
a.close();
}
}
Ejemplo: escritura

 Leyendo archivos de texto en JAVA
Abrir un archivo existente :
BufferedReader x = new BufferedReader(
new FileReader(filename))
Las líneas pueden ser leídas de la siguiente manera:
String line = x.readLine()
Archivos se tratan secuencialmente
Si no quedan líneas por leer en el archivo, el método
readLine() retornará el valor null.
Hay que “importar” las clases BufferedReader y FileReader
poniendo al comienzo del programa la instrucción
import java.io.*;
• Hay que “reportar” las llamadas a métodos que
pueden causar excepciones con throws IOException

84
Leer líneas que terminan con la palabra “fin” y grabarlas en un
archivo en disco de nombre “archivo.txt”.
import java.io.*;
class LeerArchivo{
static public void main(String[]args)
throws IOException {
BufferedReader a = new BufferedReader(
new FileReader(“archivo.txt”));
while(true){
String linea=a.readLine();
if(linea==null) break;
System.out.println(linea);
}
a.close();
}
}
Ejemplo: lectura

85
Lineas en el archivo “archivo.txt”: Nombre:nota Ej. Juan Perez:6.7
import java.io.*;
class LeerArchivo{
static public void main(String[] args) throws IOException {
BufferedReader a = new BufferedReader(
new FileReader(“archivo.txt”));
String linea; String nombre; double notamax = 0.0;
while(linea=a.readLine() != null){
int i = linea.indexOf(“:”);
double nota = Double.parseDouble(linea.substring(i+1));
if(nota > notamax) {
notamax = nota; n
nombre = linea.substring(0,i+1);
}
}
a.close();
System.out.println(“Nombre: “+nombre+” Nota: “+notamax);
}
}
Encontrar alumno con nota mayor

Otras Estructuras: Vector
• Una implementación de lista enlazada eficiente
• Puede contener objetos de cualquier clase
• Ultimas versiones de java apuntan a que todos sean de una sola
(super)clase
Vector v = new Vector(); //crea un vector vacio
v.add(“Hola”); v.add(new Scanner()); ...
//agregar elementos al final,
v.add(5, “chao”); //agrega en el indice 5
//mostrar los elementos
for(int i = 0; i < v.size(); i++)
System.out.println(v.get(i).toString());
86

Generics: chequeo de tipos
• Usando Generics se puede hacer que se chequee el tipo de
objeto
Vector<Tipo> v = new Vector<Tipo>();
Solo se pueden poner objetos de la Clase Tipo (o derivados)
v.add(“Hola”); //produciría error de compilación
87

for-each (Java 5.0)
• For-each para Vectores (con uso de generics)
88
// Java 5.0
void cancelAll(Vector<Socket> c) {
for (Socket t : c) {
t.close();
}
}
// Java 1.4 o anterior
void closeAll(Vector<Socket> c) {
Iterator i = c.iterator();
while (i.hasNext()) {
Socket t = (Socket)i.next();
t.close();
}
}

Otras Estructuras: Hashtable
• Una implementación de un diccionario eficiente
• Conviene usarlo con Generics
Hashtable<String, Integer> h = new
Hashtable<String, Integer>();
//crea una tabla de Hashing vacía
//Integer: clase Wrapper de int (Double, Char, ...)
Integer i = new Integer(5);
h.put(“Palabra”,i);
Integer x = h.get(“Palabra”);
int c = x.intValue()+1;
Enumeration e = x.keys(); 89

Otras Estructuras: Enumeration
• Los objetos Enumeration se crean como resultado de aplicar una
funcion a una estructura
• Retornan una enumeracion de los elementod de esa
estructructura que se pueden recorrer
Enumeration e = x.keys();
x.hasMoreElements() (true o false)
x.nextElement() retorna el siguiente elemento
while( x.hasMoreTokens()) {
String s = (String)x.nextElement();
Integer I = x.get(s);
System.out.println(s+” “+i);
} 90

Autoboxing (Java 5.0)
• A partir de Java 5.0, la conversión entre tipos primitivos y objetos
(entre int e Integer, por ejemplo) se produce de manera
automática cuando se requiere
– import java.util.*;
// Imprime la frecuencia de los parámetros
public class Frequency {
public static void main(String[] args) {
Hashtable<String, Integer> m =
new Hashtable<String, Integer>();
for (String word : args) {
Integer fr = m.get(word);
m.put(word, (fr == null ? 1 : fr + 1));
}
System.out.println(m);
}
}
91

Clases "Wrapper"
• Boolean, Byte, Char, Double, Float, Integer,
Long, Number, y Short
• Almacenan un valor de un tipo primitivo en un
objeto
• Del mismo modo que la clase String, estas
clases son inmutables
• Proveen métodos para manipular y convertir
los valores
92

Métodos de Integer
• Integer(int value): constructor
• Integer(String value): constructor
• boolean equals(Object o): compara con otro objeto
• int intValue(): retorna el valor del objeto como un int
• static int parseInt(String s): parsea el string y retorna
un int
• String toString(): retorna el objeto como string
• static String toString(int n): retorna el int indicado
como un string
93

Ejercicio 1
• Se tienen dos archivos: items.txt y ventas.txt
• Items tiene por cada línea el código de un
producto y el stock actual Ej: 12345 56
• Ventas tiene por cada línea el código de un
producto y cuanto se vendió EJ: 12345 20
• Generar un archivo llamado stockfinal.txt con el
stock para cada producto después de descontar
las ventas del día
94

Algoritmo sugerido
Crear tabla de hashing con formato <String, Integer>
abrir archivo stock.txt para lectura
por cada linea:
sacar el codigo y el stock,
poner en la tabla el par (codigo, stock)
abrir archivo ventas.txt
por cada linea:
sacar el codigo y la venta
obtener el par (codigo, stock) correspondiente
actualizar stock restandole la venta
abrir archivo stockfinal para escritura
por cada par (codigo,stock) de la tabla
escribir en el archivo codigo+” “+stock
Cerrar archivos
95

Java introduccion conceptos basicos una mira

Más contenido relacionado

Similar a Java introduccion conceptos basicos una mira

Más de ArisbethBernalSalina

Último

Java introduccion conceptos basicos una mira

Notas del editor