Programación

1. Conceptos básicos.
Estructura inicial de public class MiPrimerPrograma {
programa
public static void main (String [ ] args) {
algoritmo
}
}

Salida por consola System.out.print(“Mensaje”);

Para pedirle al usuario import.java.util.Scanner;

datos Scanner teclado=new Scanner(System.in);
teclado.nextInt(); //lee un número entero(int por el teclado)
teclado.nextDouble();//lee el número real (double)
teclado.nextLine();//lee una cadena de caracteres(una frase)

Tipos primitivos nº enteros: byte, short, int, long

nº reales: float, double
lógico (true o false): boolean
un carácter: char

Hacer comentarios //comentario de una línea

/* comentarios que se
extiende en
varias líneas */

Salida por consola System.out.print(“Se muestra el mensaje literal”);

System.out.println(“igual, pero tras el mensaje se inserta un salto de línea”);

4. Funciones.
Una función es un conjunto de instrucciones agrupadas bajo un nombre y con un objetivo
común, que se ejecuta al ser invocada. La definición de una función puede hacerse antes o
después del main( ).

Con esto evitamos la duplicidad del código y la dificultad en las modificaciones. Las
funciones se comportan de la siguiente manera:
1. Se ejecuta el código hasta que encuentra la llamada.
 2. La ejecución salta a la definición de la función.
3. Se ejecuta el cuerpo de la función.
4. Cuando la ejecución del cuerpo termina retomamos el código sigue su función.

Cómo usar las funciones.

Sintaxis de // llamada de la función en el main
una función. nombreFunción ( edad );

public static tipo nombreFuncion( int edad) {

cuerpo de la función
}

Ámbito de las Variables locales: que son las que se declaran en la propia función y no pueden
variables utilizarse fuera de ella.
Variables de bloques: siempre y cuando su nombre no coincida con una variables
declarada antes, fuera del bloque, ya que esto producirá un error.

Paso de información a una función

Es más práctico implementar una función que se llame variosSaludos( ) a la que se le pasa el número
de veces que queremos saludar, si ejecutamos variosSaludos(7), saludará 7:
static void variosSaludos (int veces) {
for ( int i = 0; i < veces, i++) {
System.out.println ( “Hola.”);
}
}

Valores en la A la función variosSaludos( ) se le pasa un número entero (nº de saludos).

llamada. variosSaludos (2); // llamada con un literal
int n = 3;
variosSaludos (2*n); // llamada con una expresión

Parámetros Para una función que calcula y muestra la suma de dos números, la llamada sería:
de entrada. int a = 3;
suma (a, 2); //muestra la suma de a ( que vale 3 ) más 2.
Cada dato utilizado en la llamada a una función será asignado a un parámetro de
entrada, especificado en la definición de esta:
tipo nombreFuncion( int a, int b ) {
cuerpo de la función
}
Los static void variosSaludos ( int veces ) {
parámetros int i;
de la función //disponemos de las variables locales: i y veces
toman su
// el valor de veces se determina en la llamada
valor en la
llamada for ( i = 0; i < veces ; i++) {
System.out.println ( “Hola.” );
}
}
Si invocamos la función con
variosSaludos (7); //7 se asigna al primer parámetro: veces

Cómo int a= 20
funciona el compruebaHora( a, 4, 2*b+1);
paso de void compruebaHora ( int hora, int minutos, int segundos ) {
parámetro por
…
valor o copia.
} // copia de valores hora= 20 , minutos= 4, segundos= (2*4+1)= 15;
// cualquier cambio en un parámetro de entrada dentro de la función no repercute en la
variable utilizada en la llamada, ya que se modifica una copia.

Para devolver un parámetro por función.

Usamos la instrucción return que finaliza la ejecución de la función y devuelve el valor indicado.
tipo nombreFuncion (parámetros) {
…
return (valor);
}
Se implementa de la siguiente manera:
static int suma ( int x, int y) { // cada llamada devuelve un int
int resultado;
resultado = x + y;
return ( resultado ); //sustituye la llamada por el valor de resultado
La última instrucción de la función debe ser return, ya que en caso de existir instrucciones posteriores
no se ejecutan.

Sobrecarga de funciones.
Significa que dos o más funciones compartan el mismo identificador en un mismo programa.
// función sobrecargada
static int suma ( int a, int b ) {
int suma;
suma = a + b;
return ( suma );
}
// función sobrecargada
static double suma ( int a, double pesoA, int b, double pesoB) {
double suma;
suma = a * pesoA / (pesoA + pesoB) + b * pesoB / (pesoA + pesoB);
return (suma);

Si invocamos la función suma( ) de la forma: suma (2, 3) se ejecutará la primera versión y devolverá 5.
En cambio, si se llama suma (2, 0.25, 3, 0.75) devolverá 3,25.

Recursividad.
Cuando una función se invoca a sí misma, diremos que es una función recursiva. Hay que hacer un
mecanismo que detenga en algún momento la serie de llamadas recursivas, porque sino nos lleva a un
ciclo infinito de llamadas a la función.

int funcionRecursiva (datos) {

int resultado;
if (caso base) {
resultado = valorBase;
} else {
resultado = funcionRecursiva(nuevosDatos); //llamada recursiva
…
}
return (resultado);
}
Solo cuando la condición sea false, se hará una nueva llamada recursiva. En el caso de que sea true
se romperá la cadena de llamadas.
 5. Arrays (tablas).
Introducción.
Una array es una variable que permite guardar más de un valor del mismo tipo
simultáneamente. Se utilizan cuando desconocemos cuantos datos vamos a gestionar, ya
que la cantidad de elementos que guardaremos en ella se puede elegir dinámicamente.

Índices.
El índice es el número que se le asigna a cada elemento, para así diferenciar el lugar de
cada elemento. Empezando siempre desde cero hasta el número total de elementos menos
uno.

System.out.println (edad [0] ); //muestra el primer elemento: 18

edad[3] = 67 //asigna un nuevo valor al cuarto elemento

Si introducimos un índice que se encuentre fuera del rango el programa dará un error en
ejecución y finalizará.

Construcción de tablas.
Para declarar una variable. int edad[ ];
Para crear una variable. edad =new int [5];

Para declarar la variable y int edad[ ] = new int [5];

la tabla juntos. El operador new inicializa todas sus variables a 0.

Para asignar datos. edad [0] = 8 / edad

Tablas como parámetros int t[ ]= new int[5];

de funciones ejemploFuncion(t);
void ejemploFuncion (int x[ ]) { // la variable x copia la tabla de datos
//cuerpo de la función
} // tanto la variable t como x referencian a la misma tabla

Para hacer operaciones.

Para hacer operaciones. java.util.Arrays;

Para saber el número de edad.length;

elementos. int edad[ ] = new int [10];
System.out.println(“Longitud de la tabla edad: “edad.length);
Muestra por pantalla: Longitud de la tabla edad: 10

Para inicializar la tabla con static void fill (tabla, valor);

el valor que quieras. static void fill (edad, 18); // inicializa todos los elementos a 18

Para inicializar solo static void fill (tabla, int desde, int hasta, tipo valor);
algunos elementos. static void fill (tabla, 3, 6, 18) // inicializa sólo el rango 3…6

Para recorrer la tabla. for (int i = desde; i<= hasta ; i++){

// procesado de t [i]
}
for ( int i = 0; i < edad.length; i++){
edad [i] = edad [i] +10; // procesamos
}

Para mostrar una tabla. int edad[ ] = {8, 41, 37, 22, 19}
System.out.println ( Arrays.toString(edad))
Otra forma:
for (i = 0; i < edad.length; i++){ // recorremos toda la tabla
System.out.println(edad [i]); //mostramos cada elemento

Para ordenar una tabla. int edad[ ] = {8, 41, 37, 22, 19}
System.out.println ( Arrays.sort(edad));
// Ahora edad = [8, 19, 22, 37, 41]

Para buscar un elemento int indiceBusqueda=0; //índice que usamos para recorrer la tabla
en una tabla no ordenada. while (indiceBusqueda < edad.length && // no es el último elemento
edad[ induceBusqueda] !=claveBusqueda) { // y no encontrado
indiceBusqueda++; //incrementamos el índice de
}
if (indiceBusqueda < edad.length){
… //claveBusqueda se encuentra en la posición indiceBusqueda
 } else { //el índice se ha salido de rango
… //no encontrado
}

Para buscar un elemento int pos = Arrays.binarySearch (tabla, valor);

en una tabla ordenada.
int pos = Arrays.binarySearch ( edad, 37);
Si el elemento no se if (pos >= 0){
encuentra se devuelve un System.out.println(“Encontrado en el índice: “ +pos);
valor negativo: informa la } else {
posición donde tendría que System.out.println(“Lo sentimos, no se ha encontrado.”);
colocarse. }

Para buscar un elemento Arrays.binarySearch (tabla, int desde, int hasta, tipo clave Busqueda);
en solo un rango.

Para hacer una copia de la Arrays.copyOf(tipo origen[ ], int longitud)

tabla.
int edad [ ]= {12, 27, 53, 6, 23} //tabla origen
int a [ ], b [ ]; //tablas destino
a = Arrays.copyOf (edad, 3); //a = [12, 27, 53]
b = Arrays. copyOf (edad, 8); //b = [12, 27, 53, 6, 23, 0 , 0 , 0 ]

Para hacer una copia de Arrays.copyOfRange( tipo origen [ ], int desde, int hasta)
un rango de la tabla. int t [ ] = {7, 5, 3, 1, 0, -2}
int a [ ] = Arrays.copyOfRange (t, 1, 4); //a = [5, 3, 1]
System.arraycopy(tablaOrigen, int posOrigen, tablaDestino, int
posDestinio, int longitud); //copia la tablaDestino a partir de posDestino
los datos de la tablaOrigen, comenzando en posOrigen y el parámetro
longitud dice los elementos que se copiarán

Para añadir un elemento a edad = ArrayscopyOf (edad, edad.length+1); //la copia incrementa la
una tabla no ordenada. longitud
edad (edad.length-1) = nuevo;

Para añadir un elemento a int t[ ] = {1, 2, 3, 4, 6, 7, 8};

una tabla ordenada. int nuevo = 5;
int indiceInsercion = Arrays.binarySearch (t, nuevo);
//si indiceInsercion >= 0, el nuevo elemento (que está repetido) se inserta
en el lugar en que ya estaba, desplazando al original. Si por el contrario:
if (indiceInsercion < 0 ) {// si no lo encuentra
//calcula donde debería estar
indiceInsercion= -indiceInsercion - 1;
}
int copia [] = new int[t.length + 1]; // nueva tabla con longitud+1
//copiamos los elementos antes del “hueco”
System.arraycopy (t, 0, copia, 0, indiceInsercion);
//copiamos desplazados los elementos tras el “hueco”
System.arraycopy (t, indiceInsercion, copia, indiceInsercion+1,
t.length - indiceInsercion);
copia[indiceInsercion] = nuevo; //asignamos el nuevo elemento
edad=copia; //edad referencia la nueva tabla
System.out.println(Arrays.toString( t )); //mostramos
Para eliminar un elemento …//algoritmo de búsqueda, que devuelve el índice del elemento a borrar si
en una tabla no ordenada existe, o -1 si no existe.
if {indiceBorrado != -1) { //encontrado
t [indiceBorrado]=t [t.length - 1]; //copia el último en indiceBorrado
t = Arrays.copyOf (t, t.length -1); //disminuimos la longitud de t
System.out.println(Arrays.toString(t)); //mostramos
} else {
…// no podemos borrar nada, ya que no lo hemos encontrado }

Para eliminar un elemento int t [ ]= {12, 27, 33, 38, 72, 92};
en una tabla ordenada int aBorrar=new Scanner (System.in).nextInt();
//usamos el algoritmo de búsqueda dicotómica
int indiceBorrado = Arrays.binarySearch(t, aBorrar);
if (indiceBorrar >=0) {
//desplazamos los elementos posteriores a indiceBorrado
System.arraycopy (t, indiceBorrado+1, t, t.length- indiceBorrado - 1);
System.out.println{ Arrays.toString(t)); //mostramos
} else {
… //no podemos borrar nada, ya que no lo hemos encontrado
}

Para comparar dos tablas int t1[ ]= {7, 9, 20};

int t2[ ] = {7, 9, 20}; // t1 y t2 tienen los mismo elementos
System.out.println (Arrays.equals(t1, t2)); //muestra true porque son
iguales

Arrays bidimensionales

Para mostrar la array System.out.println( Array.deepToString(tabla))

Integer.MAX_VALUE es una constante en Java que representa el valor máximo que

puede almacenar un tipo de dato int. En Java, un int es un tipo de dato primitivo
que ocupa 32 bits y puede almacenar valores enteros que van desde -2,147,483,648
a 2,147,483,647 (inclusive).

Math.random() * (max - min) + min

frase,contains

6. Cadenas de caracteres.
Introducción.
El tipo char, que almacena un solo carácter, es insuficiente para manejar textos complejos
que se denominan cadenas de caracteres. Para manipular textos tenemos las clases
Character, que trabaja con un solo carácter y String, que trabaja con textos de cualquier
longitud, ubicadas en el paquete java.lang.

Char se define como una letra, un número, un ideograma o cualquier símbolo que se
escribe entre comillas simples (‘ ‘). El Unicode identifica cada carácter mediante un número
entero que se utiliza para símbolos que no se pueden escribir por teclado. El hecho de que
un carácter se identifique con un número crea una relación entre char e int asignando a
cada carácter un valor entero.

Secuencias de escape
\b Borrado a la izquierda \f Nueva página

\n Nueva línea \’ Comilla simple

\r Retorno de carro \” Comilla doble

\t Tabulador \\ Barra invertida

Conversión char-int.
Existe una relación entre las dos variables, por ejemplo ‘a’ tiene asociado el code point
/u0061 que si lo pasamos a decimal obtenemos 97. Por ejemplo:
char c = ‘a’;
System.out.println((int) c)); //muestra 97
int e = 97;
System.out.println( (char) e); //muestra ‘a’;

Aritmética de caracteres.
La relación existente entre int y char en unicode permite realizar operaciones aritméticas
con ellos: System.out.println(‘a’ + 1); //se muestra una ‘b’ por pantalla.

Clase Character.
La clase Character amplía la funcionalidad del tipo char simplificando mucho el trabajo.
CLASIFICACIÓN DE CARACTERES.
- Dígitos: ‘0’, ‘1’, ‘2’, ‘3’, … .
- Letras: formado por los elementos del alfabeto, tanto en minúscula (‘a’, ‘b’, …) como
mayúscula (‘A’, ‘B’, …).
- Carácteres blancos: como espacio o el tabulador.
- Otros caracteres: signos de puntuación, matemáticos, … .
 Métodos de la clase Character
boolean isDigit (char c): indica si el carácter c char c1= ‘8’, c2= ‘p’;
es un dígito. Devuelve true en caso afirmativo boolean b;
y false en caso contrario. b= Character.isDigit(c1); //b es true;
b= Character.isDigit(c2); //b es false;

boolean isLetter (char c): determina si el Character.isLetter(‘8’): //false;

carácter es una letra (minúscula o mayúscula). Character.isLetter(e); // true;

boolean isLetterOrDigit (char c): indica si el boolean b;

carácter es alfanumérico (o letra o dígito). b = Character.isLetterOrDigit (‘%’); // ‘%’ es false;
b = Character.isLetterOrDigit (‘p’); //true, ‘p’ es letra;
b = Character.isLetterOrDigit (‘2’); //true, ‘2’ es dígito

boolean isLowerCase (char c): especifica si c char c1 = ‘q’, c2 = ’Q’;

es una letra y, además si está en minúscula. Character.isLowerCase(c1); //true
Character.isLowerCase(c2); //false

boolean isUpperCase (char c): si c es una letra Character.isSpaceChar(‘t’); //devuelve true

mayúscula. Character.isSpaceChar(‘T’); //devuelve false

boolean isSpaceChar (char c): devuelve true si Character.isSpaceChar(“ “); //devuelve true
es un espacio. Character.isSpaceChar(‘a’); //devuelve false

boolean isWhitespace (char c): amplía el Espacio en blanco (‘__’);

método anterior devolviendo true si es Retorno de carro (‘\r’);
cualquier carácter blanco. Nueva línea (‘\n’);
Tabulador (‘\t’);

Clase String.
Una variable de tipo String almacenará una cadena de caracteres. Los literales carácter y
cadena se diferencian en el tipo de comillas utilizado; mientras ‘a’ es un carácter, “a” es una
cadena que está compuesta por un único carácter.

Inicialización de cadenas cad new String (“literal cadena”);

cad = “literal cadena”;

Valores de otros tipos String cad;

static String valueOf (tipo valor): construye y cad= String.valueOf(1234); //cad = “1234”
devuelve una cadena con la representación del cad= String.valueOf(-12.34); //cad = “-12.34”
valor pasado como parámetro. cad= String.valueOf(‘C’); //cad = “C”
cad= String.valueOf(false); //cad = “false”

Comparación
Igualdad (==)
 boolean equals (String otra): compara la cadena String cad1 = “Hola mundo”;
que invoca el método con otra. String cad2 = “Hola mundo”;
String cad3 =”HOLA MUNDO”;
boolean equalsIgnoreCase(String otraCadena): boolean iguales;
funciona igual que equals() pero sin distinguir iguales = cad1.equals(cad2) ;// true
mayúsculas y minúsculas. iguales = cad1.equals(cad3); //false
iguales =cad1. equalsIgnoreCase(cad2); //true

boolean regionMatches( int inicio, String otraCad,

int inicioOtra, int longitud):

Obtención de caracteres.
Obtención de un carácter char charAt (int posicion): devuelve el carácter que ocupa el índice
posición que se le da.
String frase = “Hola como estás”;
Sout( frase.charAt( 4 ) ); //muestra ‘a’

Obtención de una subcadena - String substring(int inicio): devuelve la subcadena desde la

posición inicio que se le da hasta el final de la cadena.
String cad1 = “Una mañana, al despertar de un sueño intranquilo”
String cad2= cad1.substring(28); //cad2 vale “un sueño intranquilo”

- String substring(int inicio, int fin): devuelve una subcadena

comprendida entre los índices inicio y el anterior a fin.
String cad1 = “Una_mañana,_al_despertar_de_un_sueño_intranquilo”;
String cad2= cad1.substring(15,36); //cad2 = “despertar de un sueño”

Comprobaciones
Cadena vacía String cadena= “ “;
- boolean isEmpty( ): indica con un boolean true si está vacia y false en caso
contrario.
String cad1= “ “, cad2 = “Hola…”;
cad1.isEmpty(); //true
cad2.isEmpty(); //false

Si una cadena contiene - boolean contains (CharSequence subcadena): devuelve true si en la

otra subcadena cadena se encuentra subcadena en cualquier posición.
String frase = “En un lugar de la Mancha”;
String palabra = “lugar”;
System.out.println(frase.contains(palabra)); //muestra true
System.out.println(frase.contains(“silla”)); //muestra false

Prefijos y sufijos - boolean startsWith(String prefijo): comprueba si la cadena comienza con

la cadena prefijo.
String frase = “Hola mundo…”;
boolean empieza = frase.startsWith(“Hol”); //true
empieza = frase.startsWith(“mun”); //false, frase no comienza por “mun”
-boolean startsWith(String prefijo, int inicio): hace lo mismo, comenzando la
comprobación en la posición inicio.
String frase= “Hola mundo…”, prefijo1 = “Hol”, prefijo2 = “num”