entradas_salidas

Entradas (System.in)
La clase System define un objeto de la clase BufferedInputStream, cuya
referencia viene dada por in. El objeto esta asociado al flujo estándar de entrada
que por defecto es el teclado entre los métodos de la clase se encuentra read,
que devuelve el carácter actual en el buffer de entrada.
Char c;
C=(char) System.in.read():
import java.io.*;
class Letras
{
public static void main(String [] args)
{
char primero, ultimo;
System.out.print("Introduzca su primera y ultima inicial");
System.out.flush();
primero = (char) System.in.read();
ultimo = (char) System.in.read();
System.out.print("Hola, " + primero + "." + ultimo + ".");
}
}
Para
leer
línea
por
línea
utilizamos
primero
la
clase
InputStreamReader(System.in), que permite captar líneas de caracteres del
teclado con el método readLine();
InputStreamReader en = new InputStreamReader(System.in);
Ejemplo Dada la base y la atura de un triangulo calcular su área
import java.io.*;
class Area
{
public static void main(String ar[ ] ) throws IOException
{
Double base, altura;
Double d;
String cd;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
System.out.print("Base del trinagulo : ");
System.out.flush();
cd = entrada.readLine();
d=Double.valueOf(cd);
base= d.doubleValue();
System.out.print("Altura del trinagulo : ");
System.out.flush();
cd = entrada.readLine();
d=Double.valueOf(cd);
altura= d.doubleValue();
System.out.println("El area = " + base*altura/2);
}
}
Operadores y Expresiones
Operador de asignación =
Operadores aritméticos +, -, *, /, y % (modulo)
Operadores de Incremento y decremento ++, -- (variables enteras)
Operadores relacionales ==, ¡=, >,<, >=, <=
Operadores lógicos ¡ (negación), ^ (o exclusiva), && (y), || (o logica)
Operadores de manipulación de bits & (and), | (or), ^ (xor), ~ (complemento a
uno), << (desplazamiento de bits a izquierda), >> desplazamiento de bits
derecha
Operadores especiales (), [], . ,
Operador instanceof
Estructuras de control
Son aquellas que controlan el comportamiento de un método.
Estructuras de Selección
Sentencia if
Simple
if ( a!=0 )
{ resultado + a/b; }
doble
if (a >=0 )
{ System.out.println( a + “es positiveo); }
else
{ System.out.println( a + “es negativo”); }
Multiple
switch (sig_car)
{
Case ‘a’ :
System.out.println(“Sobresaliente”);
Break;
Case ‘ab :
System.out.println(“Notable”);
Break;
default :
System.out.println(“nota no valida”);
Break;
}
Ejemplo escriba un programa que determine si un numero n1 es mayor o menor
que un numero n2
import java.io.*;
class Mayormenor {
public static void main(String [] args) throws IOException
{
float n1, n2;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Introduzca dos numeros reales ");
Float f = Float.valueOf(entrada.readLine());
n1 = f.floatValue();
f = Float.valueOf(entrada.readLine());
n2 = f.floatValue();
if (n1 > n2)
System.out.println(n1 + " es mayor");
else
System.out.println(n2 + " es mayor");
}
}
Estructuras de control
Son aquellas que controlan el comportamiento de un método.
Sentencia While
Int x=10;
While (x<10)
{
System.out.println(“X: “ + x++);
}
// Programa calculo de calorias uso del while
import java.io.*;
class Calorias {
public static void main(String [] a) throws IOException
{
int calorias_por_alimento, cuenta, numero_de_elementos,
calorias_total;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Cuantos Alimentos has comido hoy ");
System.out.flush();
numero_de_elementos = Integer.parseInt(entrada.readLine());
System.out.println("Introducir el numero de calorias de " +
"cada uno de los " + " " + numero_de_elementos +
"Alimentos comidos hoy ");
calorias_total = 0;
cuenta=1;
while (cuenta++ <= numero_de_elementos)
{
calorias_por_alimento=Integer.parseInt(entrada.readLine());
calorias_total += calorias_por_alimento;
}
System.out.println("Las calorias comidas hoy son : " +
calorias_total);
}
}
Bucles controlados pos centinelas
centinela = -1;
while (nota !=centinela)
Bucles controlados pos banderas
digito_leido = false;
while ( !digito_leido)
La sentencia break en los bucles
Int clave = -9;
boolean activo = true;
while (activo)
{
Int dato;
dato=Integer.parseInt(entrada.readLine());
if (dato ¡= clave)
System.out.println(dato);
else
break;
//listado while true
import java.io.*;
class Buclesinfin
{
public static void main(String [] args)
{
boolean flag = true; int contador=0;
while (flag)
{
contador ++;
if (contador > 10)
break;
}
System.out.print("Contador : " + contador);
}
}
La sentencia break con etiqueta
Bucle for
for (Inicializacion; Condicion; Incremento)
//Ejemplo ciclo for
// valores de funcion
import java.io.*;
class Valorfuncion
{
public static void main(String [] args) throws IOException
{
final int veces = 15;
BufferedReader entrada = new BufferedReader (
new InputStreamReader(System.in));
for (int i = 1; i<=veces; i++)
{
double x,f;
System.out.println("Valor de X : ");
System.out.flush();
x = Double.valueOf(entrada.readLine()).doubleValue();
f = Math.exp(2*x) - x;
System.out.println("f(" + x + " ) = " + f);
}
}
}
For anidados
//Ejemplo ciclo for
// Imprime una tabla de m filas por n columnas con un caracter prefijado
import java.io.*;
class Tabla
{
public static void main(String [] args) throws IOException
{
int filas, columnas, elcar;
BufferedReader entrada = new BufferedReader (
new InputStreamReader(System.in));
System.out.println("Cuantas filas: ");
System.out.flush();
filas = Integer.parseInt(entrada.readLine());
System.out.println("Cuantas columnas: ");
System.out.flush();
columnas = Integer.parseInt(entrada.readLine());
System.out.println("Que Caracter: ");
System.out.flush();
elcar = System.in.read();
for (int i = 0; i<=filas; i++)
{
for (int j = 0; j<=columnas; j++)
{
System.out.print((char) elcar);
}
System.out.println();
}
}
}
Métodos
Un método es un mini programa dentro de un programa. Los métodos contienen
varias sentencias bajo un mismo nombre que un programa puede utilizar una o
mas veces para ejecutar dichas sentencias.
Sintaxis
tipo nombre (lista parámetros)
{
Declaracion variables locales;
I1;
In;
}
Nota….. una sentencia en el interior de un método puede ser la llamada a otro
método
Metodo main()
public class Parrafo
{
public static void main(String [] ar)
{
System.out.println("Este es el verbo " + ar[0]);
}
}
Devolución de variables de un método
La sentencia return se utiliza para salir del metido actual y devolver elvalor
especificado por el tipo de retorno del método, si el método es tipo void la
palabra return se utiliza sola.
Sintaxis
return;
return objeto;
public class Pruebaretorno
{
public static void main(String [] ar)
{
Rectangulo r = new Rectangulo(3.0, 7.0);
System.out.println("El área es " + r.calcularArea());
}
}
class Rectangulo
{
private double base, altura;
//Constructor explicito
public Rectangulo(double b, double h)
{
base=b;
altura=h;
}
public double calcularArea()
{
return base*altura;
}
}
Nota Validar variables private.
Nota un método declarado como
void marco() {…}
Es un método que no devuelve ninguna valor.
Los métodos se pueden sobrecargar … dos métodos con diferentes listas de
paramentos pueden tener el mismo nombre.
Llamada a un método
Los métodos para ser ejecutados han de ser llamados o invocados.
Normalmente la llamada a un metido se realizara desde un método de otra clase
o del main().
class Matem
{
static long factorial (int m)
{
long p=1;
for (int i=2; i<=m; i++)
{
p*=i;
}
return p;
}
}
class CalculoFact
{
public static void main(String [] a)
{
final int M=15;
for (int i=1; i<=M; i++)
{
System.out.println(i + "! = " + Matem.factorial(i));
}
}
}
Acceso a métodos
Cada método tiene un tipo asociado que se utiliza para controlar el acceso al
método. El tipo de acceso puede estar ausente (no se especifica), public,
private, protected.
Un metido public puede ser llamado por cualquier código que tenga acceso a la
clase. El metido main(), por ejemplo se declara public ya que se llama por el
sistema en tiempo de ejecución.
Un método private solo se puede llamar desde otro método de la clase en que
el método esta definido.
Un metodo protected, se puede llamar desde otro método de la clase en que el
método esta definido y de cualquier otro metodo de la clase que heredan de la
clase en que esta definido el metodo. También esta disponible en cualquier
objeto de las clases pertenecientes al mismo paquete que la clase en que esta
definido el metodo.
Si no se especifica ningún tipo de acceso, se utiliza el acceso por defecto, que
significa que el metodo es accesible a todas las clases contenidas en el mismo
paquete, pero no es accesible fuera del paquete.
Crear un Subdirectorio del nombre del paquete (md suma)
Crear la clase Sumatoria con nombre Sumatoria.java dentro del subdirectorio
Crear la clase Resta con nombre Resta.java dentro del subdirectorio
Crear el progrma principal con las declaraciones import
package suma;
public class Sumatoria
{
int n,p;
public int sumar()
{
int k,e;
k=10;
n=71;
p=e=5;
return n+k+e+p;
}
}
package suma;
public class Resta
{
int n,p;
public int restar()
{
int k,e;
k=10;
n=71;
p=e=5;
return n-k-e-p;
}
}
import suma.Sumatoria;
import suma.Resta;
class Principal
{
//public int res;
public static void main(String [] args)
{Sumatoria s = new Sumatoria();
System.out.println(s.sumar());
Resta r = new Resta();
System.out.println(r.restar());}
}
Validar restricciones de public, private, protected
Paso de argumentos a métodos
Paso por valor
class PasoPorValor
{
public static void main(String [] args)
{
int n=10;
System.out.println("\n\n\n\nAntes de LLamar a metodoLocal n = " +
n);
metodoLocal(n);
System.out.println("Despues de LLamar a metodoLocal n = " + n);
}
static void metodoLocal(int valor)
{
System.out.println("Dentro de metodoLocal valor = " + valor);
valor=999;
System.out.println("Dentro de metodoLocal con nueva asignacion
valor = " + valor);
}
Paso por Valor Objeto
class PaPorValObjeto
{
public static void main(String [] args)
{
Tecnologico tec = new Tecnologico();
System.out.println("\n\n\n\n Propiedades del Objeto de creacion ");
tec.mostrar();
modifica(tec);
System.out.println("Propiedades del objeto Modificado ");
tec.mostrar();
}
static void modifica(Tecnologico obj)
{
obj.fecha="01-Octubre-2005";
obj.dias = 2;
}
class Tecnologico
{
String fecha;
int dias;
public Tecnologico()
{
fecha = "01-octurbre-1975";
dias = 1;
}
void mostrar()
{
System.out.println("Fecha de Actual = " + fecha + “ “ + dias + “
dias”);
}
}
Modificadores de acceso
Dentro del cuerpo del metodo el parámetro o argumento se utiliza como
cualquier variable, de modo que el valor pasado a la variable no cambie será
preciso que en la declaración de parámetros al nombre del mismo se anteceda
la palabra final.
double polinomio(final double x)
{
return x*x + x*2 – 5.0
}
Metodos abstractos
Los métodos abstractos se utilizan en clases abstractas para imponer una cierta
funcionalidad a las subclases de las clases abstractas. Los métodos abstractos
se designan por la palabra reservada abstract y no tienen cuerpo.
Sobrecarga de Métodos (implementación del polimorfismo)
En java es posible definir dos o más métodos dentro de una misma clase con el
mismo nombre pero con diferentes declaraciones de parámetros, a lo que se
conoce como sobrecarga de métodos. La sobrecarga es uno de los
procedimientos mediante el cual java implementa el polimorfismo.
En las llamadas a los métodos sobrecargados, el compilador determina cual es
el metodo invocado en base al número de parámetros o el tipo de los
parámetros (argumentos pasados).
Regla
La llamada a un metodo sobrecargado no debe ser ambigua, para que el
compilador decida inequívocamente cual es el metodo llamado.
class SobreCarga{
public void demo()
{
System.out.println("Metodo Sin Argumentos ");
}
//Sobre Carga demo() con un tipo int
public void demo(int x)
{
System.out.print("Metodo Con un Argumento ");
System.out.println("x = " + x);
}
public void demo(int x, int y)
{
System.out.print("Metodo Con dos Argumento ");
System.out.println("x = " + x + " y = " + y);
}
public void demo(double x, double y)
{
System.out.print("Metodo Con dos tip double Argumento ");
System.out.println("x = " + x + " y = " + y);
}
}
class DemoSobrecarga{
public static void main(String [] arg)
{
SobreCarga objeto = new SobreCarga();
objeto.demo();
objeto.demo(10);
objeto.demo(20, 30);
objeto.demo(2.8, 4.5);
}
}
Sobrecarga de Constructores
La clase describe un conjunto de objetos con las mismas propiedades y
comportamientos. El objeto cuando es creado se inicializa con unos valores por
defecto o bien con unos valores transmitidos al momento de la instanciacion. El
metodo que realiza la inicialización del objeto es el metodo constructor. Este
debe tener el mismo nombre que la clase y no tiene tipo de retorno.
class Racional
{
int private numerador, denominador;
public Racional()
{
numerador = 0;
denominador = 1;
}
public Racional(int numerador, int denominador)
{
this.numerador = numerador;
this.denominador = denominador;
}
public Racional(Racional r)
{
numerador = r.numerador;
denominador = r.denominador;
}
public Racional sumar(Racional r2)
{
Racional suma = new Racional(numerador + r2.numerador,
denominador + r2.denominador);
return suma;
}
public void mostrar()
{
System.out.println(numerador + "/" + denominador);
}
}
Al crear objetos Racional se puede hacer uso de cualquier constructor según
como se desee inicializar.
class DemoRacional
{
public static void main(String[] arg)
{
Racional r1, r2, r3;
r1 = new Racional();
r2 = new Racional(1, 5);
r1 = new Racional(r2);
r3 = r2.sumar(r1);
System.out.print("r1 = "); r1.mostrar();
System.out.print("r2 = "); r2.mostrar();
System.out.print("r1 + r2 = "); r3.mostrar();
}
}
Objeto que envía un mensaje. Comando this
Un metodo de una clase referencia a un miembro, variable o metodo,
simplemente escribiendo su identificador, no es cualificado con el selector (.)
AMBITO (ALCANCE)
El ámbito o alcance de una variable determina cuales son los métodos que
reconocen ciertas variables. Si un metodo reconoce una variable, la variable es
visible en ese metodo. Java reconoce tres tipos de ámbitos.
Ámbito de la clase.
Las variables instancia (atributos de los objetos)
declaradas en una clase tienen como ámbito todos los métodos de la clase.
Class Radio
{
Int potencia;
Int numsintonia;
{
Metodo1(){}
Metodo2(){}
Metodon(){}
}
Las variables instancia de una clase se inicializan por defecto; las de tipo
numérico a 0, las de tipo bolean a false y las referencias a null.
Se recomienda utilizar constructores para inicialización explicita.
Ámbito de Metodo. Las variables que tienen ámbito de metodo pueden
reverenciarse desde cualquier parte del metodo. Las variables de metodo no
pueden ser utilizadas fuera del ambito del metodo en que están definidas.
Public class MIxto
{
Private int n;
Public double valor(itn y)
{
Float n = 12.0f; /* oculta la variable int n en el ámbito de clase
}
}
Las variables de metodo no son inicializadas por el complilador de java. Es un
error acceder al valor de una variable sin haberla inicializado.
Ambito de Bloque. Un bloque es una agrupación de sentencias por {}. Dentro
de un bloque se pueden declarar variables y su ambito queda circunscrito al
bloque.
Los identificadores definidos en un bloque deben ser distinto a de los
identificadores definidos en el bloque que los contiene. El compilador genera un
error. Identificador ya definido.
{
bolean sw;
itni = 0
while (i>0)
{
string sw; i++;
}
}
Recursividad
Un metodo recursivo es un metodo que se llama así mismo directa o
indirectamente, la recursividad directa es el proceso por el cual un metodo se
llama así mismo desde el propio cuerpo del metodo. La recursividad indirecta
implica más de un metodo.
Para poder aplicar la recursividad es importante que el proceso sea
recursivo y tenga una condición de terminación.
Ejemplo de recursividad directa
import entradas.LeeEntero;
import java.io.*;
class Factorial
{
public static void main(String [] args) throws IOException
{
int n;
LeeEntero l = new LeeEntero();
do {
System.out.print("Introduzca un Numero n: ");
n=l.lee();
}while (n < 0);
System.out.println("\n\t" + n + "!= " + factorial(n));
}
static long factorial(int n)
{
if (n<= 0)
return 1;
else
{
long resultado = n * factorial(n-1);
return resultado;
}
}
}
Recursividad indirecta: métodos mutuamente recursivos
public class Alfabeto
{
public static void main(String a[])
{
System.out.println();
metodoA('z');
System.out.println();
}
static void metodoA(char c)
{
if (c > 'A')
metodoB(c);
System.out.print(c);
}
static void metodoB(char c)
{
metodoA(--c);
}
}
Arreglos
Un array lista o tabla) es una secuencia de datos del mismo tipo, los datos se
llaman elementos del array y se numeran consecutivamente 0, 1, 2 .. el tipo de
elemento almacenado en el array puede ser de cualquier tipo de dato simple o
de tipo previamente declarado.
Un array puede por ejemplo contener las edades de los alumnos de una clase,
sus calificaciones, la temperatura de los días de un mes en una ciudad, etc.
Los subíndices localizan la posición exacta del elemento dentro del array
proporcionando acceso directo al array. Si el nombre del array es a entonces
a[0] es el nombre del elemento que esta en la posición 0 y así sucesivamente
a
25.1
0
a[0] contiene 25.1
a[1] contiene 34.2
34.2
1
5.25
2
7.45
3
6.09
4
Declaración de un array
Int [ ]v;
Flota w[ ];
El primer formato indica que todos los identificadores son arrays del tipo
El segundo formato es array sole el identificador al que le siguen los [ ]
Char cad[ ], p;
Int [ ] w, x;
Nota: la declaración int notas[10]: produce un error.
Los array son un objeto y por tal motivo para indicar el numero de elementos se
utiliza el operador new.
float notas[ ];
notas = new float[10];
Se puede escribir en la misma sentencia
float [ ] notas = new float [10];
char letras [] new char [30];
Los arrays de caracteres funcionan igual que los numéricos
char nombre[] = {‘A’, ‘n’, ‘a’};
El tamaño de los arrays : Atributo length
double [] v = new double[15];
System.out.print(v.length); // escribe 15, números de elementos de v
class Longitud{
public static void main(String a[])
{
double d[] = {4.6, 3.4, 4.5};
System.out.print(suma (d));
}
static double suma(double w[] )
{
double s=0.0;
for (int i=0; i< w.length; i++)
s+=w[i];
return s;
}
}
Verificación del rango de un array
Java al contrario de c verifica el valor del índice de la variable que representa
al array si se tiene v[5], el acceso a v[6]; produce un error.
Protección frente a errores en el intervalo (rango) de los valores de una variable
índice que representa un array.
import entradas.LeeEntero;
import java.io.*;
class Proteccion{
public static void main(String a[])throws IOException
{
double d[];
d = new double[5];
if (datos(d)==0)
System.out.print("Rango incorrecto");
else
System.out.print("Rango correcto");
}
static int datos(double w []) throws IOException
{
int l;
LeeEntero n = new LeeEntero();
System.out.println("Cuantos datos : ");
l=n.lee();
if (l > w.length)
return 0;
// se leerian los valores
return 1;
}
}
Inicializacion de un array
Se deben asignar los valores a los elementos de un array antes de utilizarlos
como se asignan valores a las variables
P/E precios[0] =10;
precios[1]=20;
precios[2]=30;
se puede inicializar el array de la siguiente forma
int numeros[] = {10, 20, 30, 50, 50};
char tecnologico[] = {‘I’, ’T’, ’H’};
se pueden asignar valores numéricos representados mediante variables
protegidas con la cláusula final
final int ENE =33, FEB=28, MAR =31, ABR = 30, MAY = 31, JUN = 30,
JUL = 31, AGO=31. SEP = 30, OCT = 31, NOV =30, DIC = 31;
Int meses[ ]= {ENE, FEB, MAR, ABR, MAY, JUN, JUL, AGO, SEP, OCT,
NOV, DIC};
se pueden asiganr utilizando un bucle, for o while/do while.
Los arrays en java se inicializan a 0 por defecto
class Cero{
public static void main(String a[])
{
int lista[] = new int[5];
for (int i=0; i < lista.length; i++)
System.out.print(lista[i]);
}
}
se pueden asiganr utilizando un bucle, for o while/do while.
for (i=0; i< numeros.length; i++)
numeros[1] = -1;
import java.io.*;
import entradas.LeeEntero;
class Inicial{
public static void main(String a[]) throws IOException
{
final int NUM=10;
int nums[] = new int[NUM];
int total = 1;
LeeEntero l = new LeeEntero();
System.out.println("Por Favor Introduzca " + NUM + " datos");
for (int i=0; i < NUM; i++)
{
nums[i]=l.lee();
}
System.out.print("\nLista de numeros : ");
for (int i=0; i < NUM; i++)
{
System.out.print(" " +nums[i]);
total *= nums[i];
}
System.out.print("\nEl producto de los numeros es : " + total);
}
}
ARRAYS DE CARACTERES Y CADENAS DE TEXTO
Una cadena de texto es un conjunto de caracteres como “ABCDEF”. Java
soporta cadenas de texto utilizando la clase String y StringBuffer implementadas
en el paquete Java.ang.
String cadena = “ABCDEF”;
Es importante comprender la diferencia entre un array de caracteres y
una cadena de caracteres. Los string son objetos donde se almacenan las
cadenas, tienen diversos constructores y métodos. Los arrays de tipo char son
una secuencia de caracteres, con las mismas características que los arrays de
otros tipos.
String datos = “Archivo”;
crea objeto cadena
char datos1[] = {‘A’, ‘r’, ‘c’, ‘h’, ‘i’, ‘v’, ‘o’};
define array de 7 elementos
String datos2 = new String(datos1);
crea un objeto tipo cadena con el constructor que tiene como
argumento un array de caracteres.
System.out.println(datos2);
System.out.println(datos1);
muestra la cadena datos1: Fichero
es un error, datos no es una cadena
Las cadenas definidas con String no se pueden modificar
Las cadenas definidas con StringBuffer pueden cambiar longitud de la cadena y
contenido.
StringBuffer cc = new StringBuffer(“cadena variable”):
cc.replace(‘c’, ‘C’);
Para concatenar cadenas se utilize el operador
String c1 = “Mi pueblo es “;
String c2 = “San Antonio de la Huerta”;
System.out.println(c1 + c2);
System.out.println(c1.concat(c2));
+
o el metodo concat
La longitud de una cadena se obtiene con el metodo length() de la clase String
String cadena = “Cama de piedra”
char cadena1[] = new char[6];
System.out.println(“Longitud de cadena : “ + cadena.length( ));
System.out.println(“Longitud de cadena1 : “ + cadena.length);
Elaborar un programa que crea un array de cadenas con líneas de textos leídas
desde teclado.
import entradas.LeeCadena;
import java.lang.String;
import java.io.*;
class Cadena{
public static void main (String [] a) throws IOException
{
final int NUM = 3;
LeeCadena l = new LeeCadena();
String [] cads = new String[NUM];
System.out.println("\n Escriba " + NUM + " lineas");
for (int i=0; i<NUM; i++)
cads[i]=l.lee();
System.out.println("\nLineas tecleadas");
for(int i=0; i<NUM; i++)
System.out.println(i + ": " + cads[i]);
}
}
Copia de arreglos
Metodo de la clase System arrayCopy()
System.arrayCopy(v1, posinicial, v2, posicioninicio, numeroelementos)
Arrays multidimensionales
Son aquellos que tienen mas de una dimensión y en consecuencia mas de un
índice. Los array mas usuales son los de 2 dimensiones, conocidos también con
el nombre de tablas o matrices.
Int equipo [ ] [ ] = new int[3] [4];
Inicialización de arrays
Int tabla [ ] [ ] = { {14, 15, 16},{4,6,8}};
Int tablas [ ] [ ] = { {2,4,5}, {2,1}
Ordenación de listas (arreglos)
Algoritmo de la burbuja
import java.io.*;
class Burbuja {
public static void main(String [] ar)
{
int a [] = {25, 34, 27, 15, 3, 5, 6, 4, 11, 18, 20};
imprime(a);
ordena(a);
imprime(a);
}
static void imprime(int a[])
{
int i=0;
System.out.println("\n\tElementos del vector");
for(; i<a.length; i++)
System.out.println(a[i]);
}
static void ordena(int a[])
{
int i,j;
for (i=a.length-1; i>0; i--)
for (j=0; j<i; j++)
if (a[j] > a[j+1])
{
int aux;
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
Búsqueda en listas
Búsqueda secuencial
Archivos y flujos
Flujos
Un flujo (stream) es una abstracción que se refiere a un flujo o corriente de datos
que fluyen entre un origen o fuente (productor) y un destino o sumidero
(consumidor). Entre el origen y el destino debe existir una conexión o canal
(pipe) por la que circulen los datos. La apertura de un archivo supone establecer
la conexión del programa con el dispositivo que contiene el archivo; el canal que
comunica el archivo con el programa va a fluir la secuencia de datos. Abrir un
archivo supone crear un objeto y quedar asociado con un flujo.
En java se generan automáticamente 3 canales que quedan abiertos. Estos son
objetos definidos en la clase system.
System.in; System.out; System.err.
Los flujos de datos de caracteres de caracteres, de bytes se pueden clasificar en
flujos de entradas (InputStream) y en flujos de salida (OutputStream).
InputStream
FileInputStream
ByteArrayInputStream
PipeInputStream
SequenceInputStream
StringBufferInputStream
FilterInputStream
OutputStream
FileOutputStream
ByteArrayOutputStream
PipeOutputStream
FilterOutputStream
La clase FileInputStream se utiliza para leer bytes desde un archivo.
Proporciona operaciones básicas para leer bytes o una secuencia de bytes.
Los métodos más importantes de esta clase son:
FileInputStream(String nombre) throws FileNotFoundException;
Crea un objeto inicializado con el nombre de archivo que se pasa como
argumento
FileInputStream(File nombre) throws FileNotFoundException;
Crea un objeto inicializado con el objeto archive pasado como argumento
int read() throws IOException;
Lee un byte del flujo asociado. Devuelve -1 si alcanza el fin del archivo
int read(byte [] s) throws IOException;
Lee una secuencia de bytes del flujo y lo almacena en el array s. devuelve
–1 si alcanza el fin del archivo.
int read(byte [] s, int org, int len) throws IOException;
Lee una secuencia de bytes del flujo y lo almacena en el array s desde la
posición org y un máximo de len bytes. Devuelve –1 si alcanza el fin del archivo.
La clase FileOutputStream
Con esta clase se pueden escribir bytes en un flujo de salida asociado a
un archivo. Los constructores y métodos mas comunes son:
FileOutputStream(String nombre) throws FileNotFoundException;
Crea un objeto inicializado con el nombre de archivo que se pasa como
argumento
FileOutputStream(File nombre) throws FileNotFoundException;
Crea un objeto inicializado con el objeto archivo pasado como argumento
void write (byte arg) throws IOException;
Escribe el byte arg en el flujo asociado
void write (byte [] arg) throws IOException;
Escribe el array de byte en el flujo asociado
void write (byte [] arg, int org, int len) throws IOException;
Escribe el array arg desde la posición org y un máximo de len bytes en el
flujo asociado.
Ejemplo:
Crear un archivo con los caracteres de una cadena.