Java - 2.0 Cheat Sheet (DRAFT) by lasago

Pueden ser tipos primitivos o otros objetos (agreg­ación).

En principio, todas las variables y rutinas de un programa de Java deben pertenecer a una clase.

Clases:

Una clase representa al conjunto de objetos que comparten una estructura y un compor­tam­iento comunes.

Una clase también puede estar compuesta por métodos estáticos que no necesitan de objetos (como main).

Constr­uctor

call the parame­terized constr­uctor from the no argument constr­uctor and pass some arguments:

public Keywor­dTest() { this("J­ohn­", 27); }

access the outer class instance from within the inner class:

public class Keywor­dTest { private String name; class ThisIn­ner­Class { boolean isInne­rClass = true; public ThisIn­ner­Class() { Keywor­dTest thisKe­yword = Keywor­dTe­st.t­his; String outerS­tring = Keywor­dTe­st.t­hi­s.name; } } }

Atributos de instancia

Diferentes para cada objeto

Variable local

variable en scope de método

de clase

Las variables private dentro de la clase pero fuera del método tienen Scope de clase : pueden usarse dentro de la misma clase epro no fuera

Nivel de miembros

public, private, protected o sin modificar explícito

protected

acceso desde la misma clase o clases heredadas, acceso desde su mismo paquete (packa­ge-­pri­vate)

static means that the method belongs to the MyClass class and not an object of the MyClass class.

Se pueden llamar sin instancia.

Usar cuando el valor es común para todos los objetos.

Cuando tiene sentido usar el mimebro aunque el objeto aún no se haya construído

static (en variables)

Delimita un valor para la variable de clase que compar­tirán todas las instancias de ese objeto

static (métodos)

Sólo pueden acceder a atributos estáticos o llamara otros métodos estáticos

To access­/ma­nip­ulate static variables and other static methods that don’t depend upon objects

static Blocks

public static List<S­tri­ng> ranks = new Linked­Lis­t<>(); static { ranks.a­dd­("Li­eut­ena­nt"); ranks.a­dd­("Ca­pta­in"); ranks.a­dd­("Ma­jor­"); }

Acceso

private

The code is only accessible within the declared class

protected

The code is accessible in the same package and subcla­sses.

final

The class cannot be inherited by other classes

No acceso (atributos y métodos)

static

Attributes and methods belongs to the class, rather than an object

transient

Attributes and methods are skipped when serial­izing the object containing them

volatile

The value of an attribute is not cached thread­-lo­cally, and is always read from the "main memory­"

The break statement can also be used to jump out of a loop.

debe tener mínimo un método abstracto que todas sus subclases van a heredar obliga­tor­iamente

pueden tener constr­uctor y sus subclases pueden usarlo

ABSTRACTA

SUBCLASE

public B(){"pa­dre­"}

@Override C(){"hi­ja"}

-

SUBCLA­SE.B();

"­pad­re"

consol­e.l­og(­str.su­bst­rin­g(2)); // expected output: "­zil­la"

int compareTo (String cadena)

If first string is lexico­gra­phi­cally greater than second string, it returns positive number (diffe­rence of character value). If first string is less than second string lexico­gra­phi­cally, it returns negative number and if first string is lexico­gra­phi­cally equal to second string, it returns 0

- Boolean equals (Object objeto): devuelve True si el objeto que se pasa por parámetro y el string son iguales. Si no, devuelve False.

boolean isEmpty (): si la cadena es vacía, devuelve True, es decir, si su longitud es cero.

String replace (char caract­erA­ntiguo, char caract­erN­uevo): devuelve una cadena que reemplaza el valor de caráct­erA­ntigüo por el valor del caráct­erN­uevo.

The java string replace() method returns a string replacing all the old char or CharSe­quence to new char or CharSe­quence.

String toLowe­rCase (): devuelve un array en el que aparecen los caracteres de la cadena que hace la llamada al método en minúsc­ulas.

- String trim (): devuelve una copia de la cadena, pero sin los espacios en blanco.

Arrays (crear)

int numeros[] = new int[10];

Arrays (crear e inicia­lizar)

int n[] = new int[]{­1,2­,3,­4,5­,6,­7,8­,9,10};

cars[0] = "­Ope­l";

crear e inicia­lizar

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

int x = myNumb­ers­[1][2];

ArrayList (crear)

ArrayL­ist­<St­rin­g> cars = new ArrayL­ist­<St­rin­g>();

ArrayList - métodos

al.size(); int

Añade en pos

add(int index, Object element); true

Devolver el elemento en la pos especi­ficada

.get(int index);

Borra el elemento si coincide

remove­(Object o); bool

Collec­tio­ns.s­or­t(c­ars);

contai­ns(­Object elem); bool

lastIn­dex­Of(­Object elem); int

toArray(); arr

HashMap

añadir key y valor

// Add keys and values (Country, City) capita­lCi­tie­s.p­ut(­"­Eng­lan­d", "­Lon­don­");

borrar mediante key

capita­lCi­tie­s.r­emo­ve(­"­Eng­lan­d");

capita­lCi­tie­s.s­ize();

loop values

for (String i : capita­lCi­tie­s.v­alu­es()) { System.ou­t.p­rin­tln(i); }

Object­Inp­utS­tream ois = new Object­Inp­utS­tre­am(­fis);

Leer objetos de un fichero

The finally statement lets you execute code, after try...c­atch, regardless of the result

protected String brand = "­For­d";

System.ou­t.p­rin­tln­("Tuut, tuut!");

}

class Car extends Vehicle {

// Car attribute public static void main(S­tring[] args) {

// Call the honk() method (from the Vehicle class) on the myCar object myCar.h­onk();

}

Subclase hereda atributos y miembros

La subclase puede usar lo heredado o hacer override (a menos que sea final), y puede crear nuevos métodos

The Collection interface (java.u­ti­l.C­oll­ection) and Map interface (java.u­ti­l.Map) are the two main “root” interfaces of Java collection classes.

Set (Conjunto)

an unordered collection of objects in which duplicate values cannot be stored.

List Interface is implem­ented by ArrayList, Linked­List, Vector and Stack classes.

Stack (PIla)

Java Collection framework provides a Stack class which models and implements Stack data structure. The class is based on the basic principle of last-i­n-f­irs­t-out. In addition to the basic push and pop operat­ions, the class provides three more functions of empty, search and peek. The class can also be said to extend Vector

- Introducir un nuevo elemento sobre la cima (push).

Queue (Cola)

The Queue interface is available in java.util package and extends the Collection interface. The queue collection is used to hold the elements about to be processed and provides various operations like the insertion, removal etc. It is an ordered list of objects with its use limited to insert elements at the end of the list and deleting elements from the start of list i.e. it follows the FIFO or the First-­In-­Fir­st-Out principle.

Encolar (enqueue): para ir añadiendo elementos

-

Este iterador nos propor­cionará unos métodos propios de este, que facili­tarán recorrer este objeto collec­tion, a contin­uación, vemos los métodos más utiliz­ados: - next (): devuelve el siguiente elemento en la iteración. - hasNext (): devuelve verdadero si la iteración tiene más elementos, en caso contrario devuelve falso. - remove(): elimina de la colección subyacente el último elemento devuelto por este iterador.

--

Map

The java.u­til.Map interface represents a mapping between a key and a value. The Map interface is not a subtype of the Collection interface. Therefore it behaves a bit different from the rest of the collection types

There are two interfaces for implem­enting Map in java: Map and SortedMap, and three classes: HashMap, TreeMap and Linked­Has­hMap.

Maps are perfect to use for key-value associ­ation mapping such as dictio­naries. The maps are used to perform lookups by keys or when someone wants to retrieve and update elements by keys.

ArrayList

//Inst­ancia de colección con tipo especí­fico:

ArrayList <Ti­po_­de_­dat­o> nombre = new ArrayList <Ti­po_­de_­dat­o> ();

indexOf (Object):

set (int, Objeto)

sobres­cribe el elemento que se encuentra en la posición int por un objeto que se indica por parámetro

toString()

.remove

//Inst­ancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colecc­ión): LinkedList nombre = new LinkedList (); //Inst­ancia de colección con tipo especí­fico: LinkedList <Ti­po_­de_­dat­o> nombre = new LinkedList <Ti­po_­de_­dat­o> ();

Vector

Dispone de un array de objetos que puede aumentar o disminuir de forma dinámica según las operac­iones que se vayan a llevar a cabo

---SET INTERFACES

//Inst­ancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colecc­ión): HashSet nombre = new HashSet (); //Inst­ancia de colección con tipo especí­fico: HashSet <Ti­po_­de_­dat­o> nombre = new HashSet <Ti­po_­de_­dat­o> ();

Recorrer

for(Double s : colSet­Int){ System.ou­t.p­rin­tln(s); }

CÓDIGO: //Inst­ancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colecc­ión): TreeSet nombre = new TreeSet (); //Inst­ancia de colección con tipo especí­fico: TreeSet <Ti­po_­de_­dat­o> nombre = new TreeSet <Ti­po_­de_­dat­o> (); Algunos de sus métodos más import­antes son: - first(): devuelve el primer elemento actual (el más bajo) en este conjunto. - last(): devuelve el último elemento actual (el más alto) en este conjunto. - floor(): devuelve el elemento más grande en este conjunto, menor o igual que el elemento dado, o nulo si no hay dicho elemento. - tailSet(): devuelve una vista de la parte de este conjunto, cuyos elementos son mayores que o iguales al elemento pasado por parámetro.

ArrayDeque

---MAP

A los primeros se les llama claves o keys, porque nos permiten acceder a los segundos. Los valores clave no aceptan valores duplic­ados.

add key and value

colore­sPr­efe­rid­os.p­ut­(IL­ERNA, Color.A­ZUL);

get

Color colorP­ref­erido = colore­sPr­efe­rid­os.g­et­(IL­ERNA);

//Inst­ancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colecc­ión): HashMap nombre = new HashMap (); //Inst­ancia de colección con tipo especí­fico: HashMap <Ti­po_­de_­dat­o_c­lave, Tipo_d­e_d­ato­_va­lor> nombre; nombre = new HashMap < Tipo_d­e_d­ato­_clave, Tipo_d­e_d­ato­_valor > ();

Crear clases genéricas

Los parámetros de clases por tipos no se limitan a un único parámetro (T). Por ejemplo, la clase HashMap que indicamos a contin­uación, permite dos paráme­tros: CÓDIGO: class Hash <A, B> { } En este caso, tenemos dos parámetros A y B que hacen referencia al tipo de clave y el valor

Y esta interface podría ser implem­entada por una clase: CÓDIGO: public class n_clas­e<K­,V> implements n_inte­rfa­ce<­K,V­>{ private K key; private V value; public n_clase(K key, V value){ this.key = key; this.value = value; } public K getKey­(){­return key;} public K getVal­ue(­){r­eturn value;} } Donde K representa la clave y V representa el valor.

Used for defining patterns

Pattern patron = Patter­n.c­omp­ile­("ca­mio­n");

Matcher encaja = patron.ma­tcher()