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 cla | Mismo pa | Sub | Otro pa | |
| pri | Sí | No | No | No |
| de | Sí | Sí | No | No |
| pro | Sí | Sí | Sí/No | No |
| pu | Sí | Sí | Sí | Sí |
Abreviaturas
psvm >> public static void main(String[] args) {
sout >> System.out.println(«»);
Deja una respuesta