Java [Guía Rápida]

Hello World

public class MiPrimeraAplicacion {
  public static void main (String[] args) {
    System.out.println("Hola Mundo");
  }
}

Tipos de datos

boolean Puede contener los valores true o false.
byte Enteros. Tamaño 8-bits. Valores entre -128 y 127.
short Enteros. Tamaño 16-bits. Entre -32768 y 32767.
int Enteros. Tamaño 32-bits. Entre -2147483648 y 2147483647.
long Enteros. Tamaño 64-bits. Entre -9223372036854775808 y 9223372036854775807.
float Números en coma flotante. Tamaño 32-bits.
double Números en coma flotante. Tamaño 64-bits.
char Caracteres. Tamaño 16-bits. Unicode. Desde ‘u0000’ a ‘uffff’ inclusive. Esto es desde 0 a 65535

System.out.printf("Hello %s!%n", "World");

1	Hello World!

• s Formats strings
• S String en mayuscula
• d  Formats decimal integers
• f  Formats the floating-point numbers
• t Formats date/time values
• n Salto linea
• b Boolean
• c Char unicode

1	%[flags][width][.precision]conversion-character

The [flags] define standard ways to modify the output and are most common for formatting integers and floating point numbers.

The [width] specifies the field width for outputting the argument. It represents the minimum number of characters written to the output.

The [.precision] specifies the number of digits of precision when outputting floating-point values. Additionally, we can use it to define the length of a substring to extract from a String.

12	System.out.printf(Locale.US, "%,d %n", 10000);System.out.printf(Locale.ITALY, "%,d %n", 10000);

12	10,000 10.000

1	System.out.printf("%f%n", 5.1473);

1

5.147300

1	System.out.printf("'%5.2f'%n", 5.1473);

1

' 5.15'

1	System.out.printf("'%5.2e'%n", 5.1473);

1	'5.15e+00'

• ‘H’, ‘M’, ‘S’  – characters are responsible for extracting the hours, minutes and second from the input Date
• ‘L’, ‘N’  – to represent the time in milliseconds and nanoseconds accordingly
• ‘p’ – adds am/pm formatting
• ‘z’ – prints out the timezone offset

12	Date date = new Date();System.out.printf("%tT%n", date);

1

13:51:15

1	System.out.printf("hours %tH: minutes %tM: seconds %tS%n", date, date, date);

1	hours 13: minutes 51: seconds 15

1	System.out.printf("%1$tH:%1$tM:%1$tS %1$tp %1$tL %1$tN %1$tz %n", date);

1	13:51:15 pm 061 061000000 +0400

• ‘A’ – prints out the full day of the week
• ‘d’ – formats a two-digit day of the month
• ‘B’ – is for the full month name
• ‘m’ – formats a two-digit month
• ‘Y’ – outputs a year in four digits
• ‘y’ – outputs the last two digits of the year

1	System.out.printf("%1$tA, %1$tB %1$tY %n", date);

1	Thursday, November 2018

1	System.out.printf("%1$td.%1$tm.%1$ty %n", date);

Sentencias

int valor = 2;
valor = 2;
valor++;
System.out.println("Hola Mundo");
Circulo miCirculo = new Circulo(2,3);
if (valor>1) { … }
if (expresion) {
    // Bloque 1
} else {
    // Bloque 2
}

Manejo de Cadenas

.length() Nos devuelve el tamaño que tiene la cadena.

char charAt(int index) Devuelve el carácter indicado como índice. Si intentamos acceder a un índice de carácter que no existe nos devolverá una excepción IndexOutOfBoundsException.

boolean equals(Object anObject) Nos permite comparar si dos cadenas de texto son iguales. Si queremos omitir la validación de mayusculas/minusculasesta validación tenemos dos opciones. La primera es convertir las cadenas a mayúsculas o minúsculas con los métodos .toUpperCase() y .toLowerCase() respectivamente. O puedes es utilizar el método .equalsIgnoreCase().

boolean equalsIgnoreCase(String anotherString) Compara dos cadenas de caracteres omitiendo si los caracteres están en mayúsculas o en minúsculas.

int compareTo(String anotherString) Compara a las cadenas léxicamente. Para ello se basa en el valor Unicode de los caracteres. Se devuelve un entero menor de 0 si la cadena sobre la que se parte es léxicamente menor que la cadena pasada como argumento. Si las dos cadenas son iguales léxicamente se devuelve un 0.

s1 = "Cuervo"
s2 = "Cuenca"
s1.compareTo(s2);

int compareToIgnoreCase(String str) Este método se comportará igual que el anterior. Pero ignorando las mayúsculas.

Búsqueda de caracteres

int indexOf(int ch) Nos devuelve la posición de un carácter dentro de la cadena de texto. En el caso de que el carácter buscado no exista nos devolverá un -1.

int indexOf(int ch, int fromIndex) Lo mismo pero desde el índice (fromIndex) que le indiquemos.

int lastIndexOf(int ch) Nos indica cual es la última posición que ocupa un carácter dentro de una cadena. Si el carácter no está en la cadena devuelve un -1. 

int lastIndexOf(int ch, int fromIndex) Lo mismo que el anterior, pero a partir de una posición indicada como argumento.

int indexOf(String str) Busca una cadena dentro de la cadena origen. Devuelve un entero con el índice a partir del cual está la cadena localizada. Si no encuentra la cadena devuelve un -1.

int indexOf(String str, int fromIndex) Misma funcionalidad que indexOf(String str), pero a partir de un índice indicado como argumento del método.

int lastIndexOf(String str) Si la cadena que buscamos se repite varias veces en la cadena origen podemos utilizar este método que nos indicará el índice donde empieza la última repetición de la cadena buscada.

lastIndexOf(String str, int fromIndex) Lo mismo que el anterior, pero a partir de un índice pasado como argumento.

boolean startsWith(String prefix) Probablemente mucha gente se haya encontrado con este problema. El de saber si una cadena de texto empieza con un texto específico. La verdad es que este método podía obviarse y utilizarse el indexOf(), con el cual, en el caso de que nos devolviese un 0, sabríamos que es el inicio de la cadena.

boolean startsWith(String prefix, int toffset) Más elaborado que el anterior, y quizás, y a mi entender con un poco menos de significado que el anterior.

boolean endsWith(String suffix) Y si alguien se ha visto con la necesidad de saber si una cadena empieza por un determinado texto, no va a ser menos el que se haya preguntado si la cadena de texto acaba con otra. De igual manera que sucedía con el método .startsWith() podríamos utilizar una mezcla entre los métodos .indexOf() y .length() para reproducir el comportamiento de .endsWith(). Pero las cosas, cuanto más sencillas, doblemente mejores.

Métodos con subcadenas

String substring(int beginIndex) Este método nos devolverá la cadena que se encuentra entre el índice pasado como argumento (beginIndex) hasta el final de la cadena origen.

String substring(int beginIndex, int endIndex) Si se da el caso que la cadena que queramos recuperar no llega hasta el final de la cadena origen, que será lo normal, podemos utilizar este método indicando el índice inicial y final del cual queremos obtener la cadena.

Manejo de caracteres

String toLowerCase(); Convierte todos los caracteres en minúsculas.

String toUpperCase(); Convierte todos los caracteres a mayúsculas.

String trim(); Elimina los espacios en blanco de la cadena.

String replace(char oldChar, char newChar) Este método lo utilizaremos cuando lo que queramos hacer sea el remplazar un carácter por otro. Se reemplazarán todos los caracteres encontrados.

Conversión a String: valueOf()

• String valueOf(boolean b);
• String valueOf(int i);
• String valueOf(long l);
• String valueOf(float f);
• String valueOf(double d);
• String valueOf(Object obj);

Arrays

tipo_dato nombre_array[];
nombre_array = new tipo_dato[tamanio];

char arrayCaracteres[];
arrayCaracteres = new char[10];

char array[];
array = new char[10];

for (int x=0;x<array.length;x++)
  System.out.printnln(array[x]);

Matrices o Arrays de varios subindices

tipo_dato nombre_array[][];
nombre_array = new tipo_dato[tamanio][tamanio];

int matriz[][];
matriz = new int[2][2];

int x = matriz[1][1]; // Para leer el contenido de un elemento
matriz[1][1] = x;     // Para asignar un valor.

int matriz[][];
matriz = new int[4][4];
for (int x=0; x < matrix.length; x++) {
  for (int y=0; y < matriz[x].length; y++) {
      System.out.println (matriz[x][y]);
  }
}

Incialización de Arrays en Java

tipo_dato array[] = {elemento1,elemento2,...,elementoN};

// Tenemos un array de 5 elementos.
char array[] = {'a','b','c','d','e'};

// Tenemos un array de 4x4 elementos.
int array[][] = { {1,2,3,4}, {5,6,7,8}};

Listas

Una Lista es una construcción de colección que, por definición, es una colección ordenada, también conocida como una secuencia.

Una colección de Lista Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

La Lista es una interfaz, por lo que usted no puede crear una instancia de ella directamente. Trabajará con su implementación más comúnmente usada, ArrayList:

1	List<Object> listOfObjects = new ArrayList<Object>();

Tipo formal

¿Qué sucede con el <Object> en el recorte anterior del código? Se llama el tipo formal y le comunica al compilador que esta Lista contiene una colección de tipo Object, lo que significa que puede poner prácticamente lo que quiera en la Lista.

Si usted quisiera intensificar las restricciones sobre lo que pudiera o no ir en la Lista, la definiría de modo diferente:

1	List<Person> listOfPersons = new ArrayList<Person>();

Ahora su Lista solo puede tener instancias de Person.

Uso de las Listas

add()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));

size()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Current List size: " + listOfIntegers.size());

get()

List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
Logger l = Logger.getLogger("Test");
l.info("Item at index 0 is: " listOfIntegers.get(0))

Iterable

Si una colección implementa java.lang.Iterable, se llama una colección iterable. Eso significa que usted puede comenzar por un extremo y recorrer la colección elemento por elemento hasta que se le acaben los elementos.

for (objectType varName : collectionReference) {  
   // Start using     
   objectType (via varName) right away...
}

Iteración en una Lista

List<Integer> listOfIntegers = obtainSomehow();
Logger l = Logger.getLogger("Test");
for (Integer i : listOfIntegers) {
    l.info("Integer value is : " + i);
}

Conjuntos

Un Conjunto es una construcción de colecciones que por definición contiene elementos únicos, — es decir, ningún duplicado. Mientras que una Lista puede contener el mismo objeto cientos de veces, un Conjunto solo puede contener cierta instancia una vez. Una colección de Conjunto Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

Set<Integer> setOfIntegers = new HashSet<Integer>();
setOfIntegers.add(Integer.valueOf(10));
setOfIntegers.add(Integer.valueOf(11));
setOfIntegers.add(Integer.valueOf(10));
for (Integer i : setOfIntegers) {
    l.info("Integer value is: " + i);
}

Puede que usted espere que el Conjunto tenga tres elementos en él pero de hecho solo tiene dos porque el objeto Integer que contiene el valor 10 solo se agregará una vez.

Es posible que los objetos se impriman en un orden diferente del que usted los agregó porque un Conjunto garantiza la singularidad, no el orden. Verá esto por usted mismo si pega el código anterior en el método main() de su clase Person y lo ejecuta.

Mapas

Un Mapa es una construcción de colección útil porque le permite asociar un objeto (la clave) con otro (el valor). Como puede imaginar, la clave para el Mapa debe ser única y se usa para recuperar el valor en un momento posterior. Una colección de Mapa Java solo puede tener objetos y define un contrato estricto sobre cómo se comporta.

Uso de los Mapas

Para poner algo en un Mapa, necesita tener un objeto que represente su clave y un objeto que represente su valor:

public Map<String, Integer> createMapOfIntegers() {
    Map<String, Integer> mapOfIntegers = new HashMap<String, Integer>();
    mapOfIntegers.put("1", Integer.valueOf(1));
    mapOfIntegers.put("2", Integer.valueOf(2));
    mapOfIntegers.put("3", Integer.valueOf(3));
    // . . .
    mapOfIntegers.put("168", Integer.valueOf(168));
}

Es este ejemplo, el Mapa contiene Integers, con la clave hecha por una String, que resulta ser su representación de String. Para recuperar un valor Integer particular, necesita su representación String:

12	mapOfIntegers = createMapOfIntegers(); Integer oneHundred68 = mapOfIntegers.get("168");

Uso del Conjunto con el Mapa

En ocasiones, usted puede encontrarse con una referencia a un Mapa y simplemente quiere recorrer todo el conjunto de contenidos. En este caso, necesitará un Conjunto de las claves para el Mapa:

Set<String> keys = mapOfIntegers.keySet();
Logger l = Logger.getLogger("Test");
for (String key : keys) {
    Integer value = mapOfIntegers.get(key);
    l.info("Value keyed by '" + key + "' is '" + value + "'");
}

Observe que el método toString() del Integer recuperado desde el Mapa se llama automáticamente cuando se usa en la llamada del Logger. El Mapa no devuelve una Lista de sus claves porque se hace una clave para el Mapa y cada clave es única; la singularidad es la característica distintiva de un Conjunto.

Programa básico

 /* Fichero Main.java */
 package helloworld; // Las clases del mismo paquete se pueden utilizar directamente. 
 public class Main {
     public static void main(String[] args) {
         Preguntas p = new Preguntas(); // Crea una objeto de la clase Preguntas
         System.out.println("Así que ves  "" + p.preguntar() + """); // Ejecuta el método de la clase.
    }
 }
 /* Fichero Preguntas.java */
 package helloworld;
 import java.util.Scanner; // Para importar librerías
 public class Preguntas {
     static final int MAX_COCHES = 3; // Crea una constante
     public int preguntar() {
         double velocidad = 110.5;
         // El (int) hace casting del número, lo adapta al tipo int antes de meterlo en la 
         // la variable de tipo int, sino daría error por intentar meter un double en un int. 
         int numObjetos = (int) (Math.random() * MAX_COCHES); 
         String objeto = "coches";
         System.out.printf("Veo %d %s por la carretera a %f Km/h n", numObjetos, objeto, velocidad);
         return cuantosVesTu();   
     }
     private int cuantosVesTu(){
         Scanner teclado = new Scanner(System.in);
         System.out.println("Cuantos ves tú?");
         int respuesta = teclado.nextInt();
         return respuesta;
     } 
 }
 public class Robot {
     // Accesible desde todos lados
     public int nivel1 = 100;
     // Accesible desde la clase, una subclase o desde el mismo paquete
     protected int nivel 2 = 200;
     // Accesible sólo desde clases del mismo paquete
     int nivel3 = 300;
     // Accesible solo dentro de la clase
     private int nivel4 = 400;
     // Constante
     final int CONSTANTE = 10;
     // Variables y metodos estática se puede acceder sin crear una instancia del objeto
     static valor1 = 10;
     // Constructor de la clase
     public Robot(){
     }
     public int habla() {
     }
     // Sobrecarga del método. Los constructores tambien se pueden sobrecargar.
     public int habla(String s) {
     }
     // Abstract, Obliga a q las clases hijas implementen este método
     public abstract void anda(){
     }
 }
 public class RobotGrande extends Robot {
     public int habla() {
     }
     // Sobrecarga del método. Los constructores tambien se pueden sobrecargar.
     public int habla(String s) {
     }
     public void anda(){
         // cosas
     }
 } 

Estructuras

 if (i < 10){
       // cosas
 }
 if (i < 10){
     // cosas
 }else if(i > 50){
     // otras cosas
 }else{
     // resto
 }
 switch (i){
     case 1:
           // cosas 1
           break;
     case 2:
           // cosas 2
           break;
  
    default
          // en cualquier otro caso
          break;
 }
 // A partir de Java 7, se pueden utilizar cadenas 
 // en el swicth
 for (int i = 1; i < 10; i++){
       // cosas
 }
 int i = 1;
 while(i < 10){
      // cosas
      i++;
 } 
 do{
    //cosas
 }while(i>10);
 // For each
 String[] lista = {"A", "E", "I"};
 for (String x:lista){
     System.out.println(x);
 }
 try{
      // operaciones
 } catch (ExceptionMasConcreta enc){
     // En caso de error concreto
     System.out.println(e);
 } catch (Exception e){
     // En caso de error generico
     System.out.println(e);
 }finally{
     // Se ejecuta cuando siempre haya error o no
     // No tiene acceso a objeto error
     // Ver https://programming.guide/java/try-finally.html
 } 

Tipos primitivos

char Caracter, 16 bits

boolean Verdadero/Falso, 16 bits

byte -128 a 127, 8 bits

short -32.768 a 32.767, 16 bits

int -2 millones a 2 millones, 32 bits

long un montón, 64 bits

float núm. grande con decimales, 32 bits

double número enorme con decimales, 64 bits

Operadores

+, -, *, /, % (Módulo de la división)

+ También sirve para concatenar Strings

++ Incrementar uno

— Decrementar uno

+= Incrementa un número

-= Decrementar un número

>, <, <=, >=, ==, != Operadores relaccionales

Arrays

tipoDato[] nombre = new tipoDato[numElemntos];

 // Ejemplo
 int[] lista = new int[5];
 int[][] posicion = new int[5][5];  // Array de 2 dimensiones
 lista[0] = 1;
 posicion[0][0] = 3;
 System.out.println(lista[0]);  // imprime 1
 System.out.println(posicion[0][0]);  // imprime 3
 System.out.println(lista.length);// imprime 5
  //Clase estandar, se puede instanciar
 public class MiClase(){
     public MiClase(){
     }
     public void miMetodo(){
     }
 }
 // Interface
 // Sirve para definir la estructura de una clase
 // NO se puede instanciar
 public interface MiInterface(){
     public void miMetodo();
 }
 // Clase Abstracta
 // Sirve para crear clases hijas
 // NO se puede instanciar
 public interface MiInterface(){
     public void miMetodo();
     // Debe haber al menos un metodo sin implementar
 } 

Clases estándar

String

Scanner

ArrayList

Accesibilidad

	Misma clase	Mismo paquete	Subclase	Otro paquete
private	Sí	No	No	No
default	Sí	Sí	No	No
protected	Sí	Sí	Sí/No	No
public	Sí	Sí	Sí	Sí

Abreviaturas

psvm >> public static void main(String[] args) {

sout >> System.out.println(«»);