Chuletario Java

Formato : switch(valor_a_comprobar){ For-Each****************************

tipo_devuelto case valor1: sentencia…; for(Tipo elemento : EstructuraTipo){

método(tipo_parámetros, ...)
break; print(elemento);
String*********************************
case valor 2: sentencia…; }
char charAt(int)
break;
int compareTo(String)
default: sentencia; Constantes de caracter**************
int compareToIgnoreCase(String)
break; '\”' Dobles comillas
String concat(String)
} '\’' Comillas simples
String copyValueOf(char[])
Regex Java**************************** '\b' Retroceso
boolean endsWith(String)
Pattern p = Pattern.compile("regex"); '\t' Tabulador
boolean equals(String)
Matcher m = p.matcher( “Str”); '\n' Nueva línea
boolean equalsIgnoreCase(String)
boolean m.matches() '\f' Alimentación de página
int indexOf(String || char)
boolean m.lookingAt() '\r' Retorno de carro
int lastIndexOf(String || char)
boolean m.find() '\\' El propio backslash (\)
int length()
int m.start() '\uA2C7' Hexadecimal el carácter
boolean matches(String) Unicode
int m.end()
String replace(char, char)
m.reset()
String replaceFirst(String, String) Conversiones de tipo**************
Regex ********************************
String replaceAll(String, String) int i = (int) (a/(b+c)); Casting a int
[a-z] Carácter entre la a y la z
boolean startsWith(String) String -> int/float/double
Cuantificadores : ? + * {}
String substring(int, int) float f =
(pal1|pal2) Una palabra o la otra Float.valueOf(numString).floatValue()
char[] toCharArray()
(?i)[REGEX] Case insensitive float f=Float.parseFloat(cadena)
String toLowerCase()
. Un carácter de cualquier tipo double d =
String toUpperCase() Double.valueOf(numString).doubleValue(
\d digito; \s espacio; )
String trim()
\w caracterPalabra double d=Double.parseDouble(cadena)
String valueOf(boolean || char ||
double || int|| float || long || char[] Random******************************** int i =
|| Object) Integer.valueOf(numString).intValue()
Math.random() -> [0,1)
String[] split(String regex) int i = Integer.parseInt(cadena)
[0,n) -> Math.random() * n
String[] split(String regex, int limit) int -> String
[i,n) -> ( (n - i) * Math.random())+i
Math********************************* String s=String.valueOf(numEntero);

double random() //Número aleatorio de 0 String s=Integer.toString(numEntero);

a 1

double sqrt(double x) //Calcula la raíz

cuadrada de x

double pow(double x,double y) //Calcula

x^y

double exp(double x) //Calcula e^x

double log(double x) //Calcula el

logaritmo neperiano de x
 Chuletario Java

Colecciones: Pilas: ClassCastException

Int size() Void push(E e) EOFException

Boolean isEmpty() E pop() ArithmeticException
Boolean contains(Object obj) E peek() ArrayIndexOutOfBoundsException
Boolean add(E element) Deque: InputMismatchException
addAll(Collection<? extends E> c) Add(element) NumberFormatException
Boolean remove(E element) addFirst(element) NullPointerException
Boolean containsAll(Collection c) addLast(element) IOException
Boolean removeAll(Collection c) offer(element) Excepcion
Boolean retainAll(Collection c) offerFirst(element)

void clear() offerLast(element) **Leer y escribir ficheros******

Object[] toArray() iterator()
// Leer.
Listas: descendingIterator()
FileReader fr = new
E get(int index) push(element) FilerReader("archivo.txt");

E set(int index, E element) pop(element) int c = fr.read();

Void add(int index, E element) removeFirst() char letra = (char)c;

E remove(int index); removeLast() fr.close();

Boolean addAll(int index, Collection c) // Escribir.

Int indexOf(Object obj) Varios FilerWriter fw = new

FilerWriter("archivo.txt"); // Si
Int lastIndexOf(Object obj) Object.hashCode() ponemos no ponemos true, sobreescribe.

List subList(int from, int to) Objects.hash( ………… ) fw.write(frase.charAt(i));

Boolean addAll(int index, Collection<? Collections.sort( coll [, objOrden ] ) fw.close();
extends E> c)
Collections.shuffle(lista) // BufferedReader y BufferedWritter.
Mapas:
Collections.fill(lista,elemento) BufferedReader br = new
V put(K key, V value) BufferedReader(fichero);
Arrays.fill(array,elemento)
V get(Object key) br.readLine();
List<Tipo> lista = Arrays.asList(array)
V remove(Object key) BufferedWritter bw = new
Tipo[] array = new Tipo[lista.size()] + BufferedWritter(fichero);
Boolean containsKey(Object key) lista.toArray(array)
br.writeLine();
Boolean containsValue(Object value) Collections.reverse(lista)
Int size() String[] split(String regex) //regex es
el delimitador de separacion
Boolean isEmpty()

Void clear() public static String join(CharSequence

delimiter, CharSequence... elements)
Public [Set<Map.Entry<K,V>> entrySet()]
String message = String.join("-",
Set<K> keyset() "This", "is", "a", "String");

Collection<V> values() // message returned is: "This-is-a-

String"
Entry

getKey()
Excepciones:
getValue()
Class MiExcepcion extends Exception{}
Colas:
throw new MiExcepcion;
Boolean add(E e)
TIPOS :
Boolean offer(E e)
FileNotFoundException
E poll() y E peek()
ClassNotFoundException