\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{Sara (lasago)}
\pdfinfo{
  /Title (java-2-0.pdf)
  /Creator (Cheatography)
  /Author (Sara (lasago))
  /Subject (Java - 2.0 Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{5BA1DE}
\definecolor{LightBackground}{HTML}{F4F9FC}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{Java - 2.0 Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{Sara (lasago)} via \textcolor{DarkBackground}{\uline{cheatography.com/70899/cs/19520/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}Sara (lasago) \\
  \uline{cheatography.com/lasago} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Not Yet Published.\\
   Updated 6th November, 2019.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.


\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{P. O. O. en Java : modelo de clase}}  \tn
% Row 0
\SetRowColor{LightBackground}
Variables miembro | atributos : & Guardan valores del objeto, representan una propiedad determinada suya. \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
 & Pueden ser tipos primitivos o otros objetos (agregación). \tn 
% Row Count 7 (+ 3)
% Row 2
\SetRowColor{LightBackground}
Métodos | Rutinas : & Componente de un objeto que lleva a cabo una determinada acción o tarea con los atributos. \tn 
% Row Count 12 (+ 5)
% Row 3
\SetRowColor{white}
 & En principio, todas las variables y rutinas de un programa de Java deben pertenecer a una clase. \tn 
% Row Count 17 (+ 5)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{-} \tn 
% Row Count 18 (+ 1)
% Row 5
\SetRowColor{white}
Clases: & Una clase representa al conjunto de objetos que comparten una estructura y un comportamiento comunes. \tn 
% Row Count 24 (+ 6)
% Row 6
\SetRowColor{LightBackground}
 & Una clase es una combinación específica de atributos y métodos y puede considerarse un tipo de dato de cualquier tipo no primitivo. \tn 
% Row Count 31 (+ 7)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{P. O. O. en Java : modelo de clase (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
 & Una clase también puede estar compuesta por métodos estáticos que no necesitan de objetos (como main). \tn 
% Row Count 6 (+ 6)
% Row 8
\SetRowColor{white}
 & {[}modificadores{]} class IdentificadorClase \{ //Declaraciones de atributos y metodos\} \tn 
% Row Count 11 (+ 5)
% Row 9
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Constructor} \tn 
% Row Count 12 (+ 1)
% Row 10
\SetRowColor{white}
llamar a constructor principal para coger ya definidas & public KeywordTest(String name, int age) \{     this(); \tn 
% Row Count 15 (+ 3)
% Row 11
\SetRowColor{LightBackground}
call the parameterized constructor from the no argument constructor and pass some arguments: & public KeywordTest() \{     this("John", 27); \} \tn 
% Row Count 20 (+ 5)
% Row 12
\SetRowColor{white}
a reference to the current instance. & \seqsplit{printInstance(this);} \tn 
% Row Count 22 (+ 2)
% Row 13
\SetRowColor{LightBackground}
access the outer class instance from within the inner class: & public class KeywordTest \{       private String name;       class ThisInnerClass \{           boolean isInnerClass = true;           public ThisInnerClass() \{             KeywordTest thisKeyword = KeywordTest.this;             String outerString = \seqsplit{KeywordTest.this.name;}         \}     \} \} \tn 
% Row Count 37 (+ 15)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{P. O. O. en Java : modelo de clase (cont)}}  \tn
% Row 14
\SetRowColor{LightBackground}
acceder a constructor de la superclase & super() \tn 
% Row Count 2 (+ 2)
% Row 15
\SetRowColor{white}
Atributos de instancia & Diferentes para cada objeto \tn 
% Row Count 4 (+ 2)
% Row 16
\SetRowColor{LightBackground}
Atributos de clase & public static int cantidadDeOjos = 2; \tn 
% Row Count 6 (+ 2)
% Row 17
\SetRowColor{white}
Variable local & variable en scope de método \tn 
% Row Count 8 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.908 cm} x{10.362 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Scope}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{El segmento del programa donde la variable es válida y puede usarse.} \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
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 \tn 
% Row Count 8 (+ 6)
% Row 2
\SetRowColor{LightBackground}
de método (variable local) & Variable declarada dentro de un método que sólo peude usarse dentro de ese método. \tn 
% Row Count 12 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{5.181 cm} x{12.089 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Acceso a miembros de una clase}}  \tn
% Row 0
\SetRowColor{LightBackground}
Nivel general & public o sin modificar explícito \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
Nivel de miembros & public, private, protected o sin modificar explícito \tn 
% Row Count 4 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{3.1086 cm} x{14.1614 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Modificadores de visibilidad}}  \tn
% Row 0
\SetRowColor{LightBackground}
public & acceso desde cualquier clase \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\seqsplit{protected} & acceso desde la misma clase o clases heredadas, acceso desde su mismo paquete (package-private) \tn 
% Row Count 4 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{private} & acceso desde la misma clase que los define \tn 
% Row Count 6 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.7353 cm} x{10.5347 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Modificadores}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{static} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
 & static means that the method belongs to the MyClass class and not an object of the MyClass class. \tn 
% Row Count 6 (+ 5)
% Row 2
\SetRowColor{LightBackground}
 & Se crea una sóla copia o instancia del miembro, no importa cuántas instancias de clase se creen. \tn 
% Row Count 11 (+ 5)
% Row 3
\SetRowColor{white}
 & Se pueden llamar sin instancia. \tn 
% Row Count 13 (+ 2)
% Row 4
\SetRowColor{LightBackground}
 & Es posible acceder a ellos sin crear instancias de clase. \tn 
% Row Count 16 (+ 3)
% Row 5
\SetRowColor{white}
 & Usar cuando el valor es común para todos los objetos. \tn 
% Row Count 19 (+ 3)
% Row 6
\SetRowColor{LightBackground}
 & USAR CUANDO SU VALOR ES INDEPENDIENTE DEL OBJETO. \tn 
% Row Count 22 (+ 3)
% Row 7
\SetRowColor{white}
 & Cuando tiene sentido usar el mimebro aunque el objeto aún no se haya construído \tn 
% Row Count 26 (+ 4)
% Row 8
\SetRowColor{LightBackground}
 & Cuando el mimebro no va a cambiar entre instancias de Clase u Objeto \tn 
% Row Count 29 (+ 3)
% Row 9
\SetRowColor{white}
static (en variables) & Delimita un valor para la variable de clase que compartirán todas las instancias de ese objeto \tn 
% Row Count 33 (+ 4)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.7353 cm} x{10.5347 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Modificadores (cont)}}  \tn
% Row 10
\SetRowColor{LightBackground}
 & Declarándoles un valor como variable de clase, hacemos que esa variable sea común para todas las instancias del objeto. \tn 
% Row Count 6 (+ 6)
% Row 11
\SetRowColor{white}
static (métodos) & Sólo pueden acceder a atributos estáticos o llamara otros métodos estáticos \tn 
% Row Count 10 (+ 4)
% Row 12
\SetRowColor{LightBackground}
 & Usan propiedades del objeto sin crearlo. \tn 
% Row Count 12 (+ 2)
% Row 13
\SetRowColor{white}
 & To access/manipulate static variables and other static methods that don't depend upon objects \tn 
% Row Count 16 (+ 4)
% Row 14
\SetRowColor{LightBackground}
 & tatic methods in Java are resolved at compile time. Since method overriding is part of Runtime Polymorphism, so static methods can't be overridden \tn 
% Row Count 23 (+ 7)
% Row 15
\SetRowColor{white}
static Blocks & public static List\textless{}String\textgreater{} ranks = new LinkedList\textless{}\textgreater{}();       static \{         \seqsplit{ranks.add("Lieutenant");}         ranks.add("Captain");         ranks.add("Major");     \} \tn 
% Row Count 30 (+ 7)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.7353 cm} x{10.5347 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Modificadores (cont)}}  \tn
% Row 16
\SetRowColor{LightBackground}
clases estáticas anidadas & public class Singleton  \{         private Singleton() \{\}           private static class SingletonHolder \{             public static final Singleton instance = new Singleton();     \} \tn 
% Row Count 8 (+ 8)
% Row 17
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{} \tn 
% Row Count 8 (+ 0)
% Row 18
\SetRowColor{LightBackground}
final & Define valor permanente a variable. \tn 
% Row Count 10 (+ 2)
% Row 19
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Acceso} \tn 
% Row Count 11 (+ 1)
% Row 20
\SetRowColor{LightBackground}
public & The code is accessible for all classes \tn 
% Row Count 13 (+ 2)
% Row 21
\SetRowColor{white}
private & The code is only accessible within the declared class \tn 
% Row Count 16 (+ 3)
% Row 22
\SetRowColor{LightBackground}
default & The code is only accessible in the same package. \tn 
% Row Count 18 (+ 2)
% Row 23
\SetRowColor{white}
protected & The code is accessible in the same package and subclasses. \tn 
% Row Count 21 (+ 3)
% Row 24
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{No acceso (clase)} \tn 
% Row Count 22 (+ 1)
% Row 25
\SetRowColor{white}
final & The class cannot be inherited by other classes \tn 
% Row Count 24 (+ 2)
% Row 26
\SetRowColor{LightBackground}
abstract & The class cannot be used to create objects (To access an abstract class, it must be inherited from another class. \tn 
% Row Count 29 (+ 5)
% Row 27
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{No acceso (atributos y métodos)} \tn 
% Row Count 30 (+ 1)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.7353 cm} x{10.5347 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Modificadores (cont)}}  \tn
% Row 28
\SetRowColor{LightBackground}
final & Attributes and methods cannot be overridden/modified \tn 
% Row Count 3 (+ 3)
% Row 29
\SetRowColor{white}
static & Attributes and methods belongs to the class, rather than an object \tn 
% Row Count 6 (+ 3)
% Row 30
\SetRowColor{LightBackground}
abstract & Can only be used in an abstract class, and can only be used on methods. The method does not have a body, for example abstract void run();. The body is provided by the subclass (inherited from). \tn 
% Row Count 15 (+ 9)
% Row 31
\SetRowColor{white}
transient & Attributes and methods are skipped when serializing the object containing them \tn 
% Row Count 19 (+ 4)
% Row 32
\SetRowColor{LightBackground}
synchronized & Methods can only be accessed by one thread at a time \tn 
% Row Count 22 (+ 3)
% Row 33
\SetRowColor{white}
volatile & The value of an attribute is not cached thread-locally, and is always read from the "main memory" \tn 
% Row Count 27 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{? - Si no pongo static y modifico una variable de una instancia con this, cambia de valor en la instancia?}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{17.67cm}}{\bf\textcolor{white}{Dudas}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{17.67cm}}{? - Sumar hasta llegar a un número \newline % Row Count 1 (+ 1)
-  \newline % Row Count 2 (+ 1)
int num = 10; \newline % Row Count 3 (+ 1)
        int sumas = 0; \newline % Row Count 4 (+ 1)
        int suma = 0; \newline % Row Count 5 (+ 1)
        while(suma \textless{} num)\{ \newline % Row Count 6 (+ 1)
~~~~suma += sumas; \newline % Row Count 7 (+ 1)
\seqsplit{~~~~System.out.println("sumas} "+sumas+" suma:"+suma); \newline % Row Count 9 (+ 2)
~~~~ sumas++; \newline % Row Count 10 (+ 1)
        \} \newline % Row Count 11 (+ 1)
? -Conseguir método privado desde main \newline % Row Count 12 (+ 1)
- Hacer un método que devuelva el método privado (si es un boolean, p. e.) \newline % Row Count 14 (+ 2)
?Simplificar if var x == x, x == y etc \newline % Row Count 15 (+ 1)
?Clases abstractas en Java \newline % Row Count 16 (+ 1)
?Suclases y sueprclases en java \newline % Row Count 17 (+ 1)
?Ficheros aleatorios \newline % Row Count 18 (+ 1)
?Interfaces \newline % Row Count 19 (+ 1)
?métodos sobrecargados% Row Count 20 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{p{1.727 cm} x{15.543 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Bucles}}  \tn
% Row 0
\SetRowColor{LightBackground}
 & for ( int n : numeros)\{\} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
 & The break statement can also be used to jump out of a loop. \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
 & The continue statement breaks one iteration (in the loop), if a specified condition occurs, and continues with the next iteration in the loop. \tn 
% Row Count 7 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{3.9721 cm} x{13.2979 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Clase Scanner}}  \tn
% Row 0
\SetRowColor{LightBackground}
Leer char & char x1 = sc.next().charAt(0); \tn 
% Row Count 1 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.2896 cm} x{8.9804 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Abstracción}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Clase sobre la que no se peuden ahcer objetos} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{debe tener mínimo un método abstracto que todas sus subclases van a heredar obligatoriamente} \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{puede tener otros métodos normales, los cuales se puden hacer override o llamar desde subclase o superclase para el método original(el override -\textgreater{} especialización)} \tn 
% Row Count 7 (+ 4)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{pueden tener constructor y sus subclases pueden usarlo} \tn 
% Row Count 9 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{a diferencia de als interfaces, no hay por qué heredar todos los métodos} \tn 
% Row Count 11 (+ 2)
% Row 5
\SetRowColor{white}
ABSTRACTA & SUBCLASE \tn 
% Row Count 12 (+ 1)
% Row 6
\SetRowColor{LightBackground}
abstract A(); & @Override A()\{"a"\} \tn 
% Row Count 13 (+ 1)
% Row 7
\SetRowColor{white}
public B()\{"padre"\} & @Override C()\{"hija"\} \tn 
% Row Count 15 (+ 2)
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{public C()\{"padre"\}} \tn 
% Row Count 16 (+ 1)
% Row 9
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{-} \tn 
% Row Count 17 (+ 1)
% Row 10
\SetRowColor{LightBackground}
SUBCLASE.A(); & "a" \tn 
% Row Count 18 (+ 1)
% Row 11
\SetRowColor{white}
SUBCLASE.B(); & "padre" \tn 
% Row Count 19 (+ 1)
% Row 12
\SetRowColor{LightBackground}
SUBCLASE.C(); & "hija" \tn 
% Row Count 20 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{| SUBCLASE \newline            \newline    @Override}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{p{1.727 cm} p{1.727 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Interfaces}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{} \tn 
% Row Count 0 (+ 0)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Métodos de String}}  \tn
% Row 0
\SetRowColor{LightBackground}
str.substring(indexStart{[}, indexEnd{]}) & \seqsplit{console.log(str.substring(1}, 3)); // expected output: "oz" \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
 & \seqsplit{console.log(str.substring(2));} // expected output: "zilla" \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{char charAt (int indice): devuelve el carácter que se encuentra en la posición de índice.} \tn 
% Row Count 8 (+ 2)
% Row 3
\SetRowColor{white}
int compareTo (String cadena) & If first string is lexicographically greater than second string, it returns positive number (difference of character value). If first string is less than second string lexicographically, it returns negative number and if first string is lexicographically equal to second string, it returns 0 \tn 
% Row Count 23 (+ 15)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{int compareToIgnoreCase (String cadena): compara dos cadenas (igual que el anterior) pero no diferencia entre mayúsculas y minúsculas.} \tn 
% Row Count 26 (+ 3)
% Row 5
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{- Boolean equals (Object objeto): devuelve True si el objeto que se pasa por parámetro y el string son iguales. Si no, devuelve False.} \tn 
% Row Count 29 (+ 3)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{int indexOf (int carácter): devuelve la posición de la primera vez que aparece el carácter en la cadena de caracteres. Como el carácter es de tipo entero, se debe introducir el valor del carácter correspondiente en código ASCII.} \tn 
% Row Count 34 (+ 5)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Métodos de String (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{boolean isEmpty (): si la cadena es vacía, devuelve True, es decir, si su longitud es cero.} \tn 
% Row Count 2 (+ 2)
% Row 8
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{- int length (): devuelve el número de caracteres de la cadena.} \tn 
% Row Count 4 (+ 2)
% Row 9
\SetRowColor{LightBackground}
String replace (char caracterAntiguo, char caracterNuevo): devuelve una cadena que reemplaza el valor de carácterAntigüo por el valor del carácterNuevo. & The java string replace() method returns a string replacing all the old char or CharSequence to new char or CharSequence. \tn 
% Row Count 12 (+ 8)
% Row 10
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{String {[}{]} Split (String expresión): devuelve un array de String con los elementos de la cadena expresión.} \tn 
% Row Count 15 (+ 3)
% Row 11
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{String toLowerCase (): devuelve un array en el que aparecen los caracteres de la cadena que hace la llamada al método en minúsculas.} \tn 
% Row Count 18 (+ 3)
% Row 12
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{String toUpperCase (): devuelve un array en el que aparecen los caracteres de la cadena que hace la llamada al método en mayúsculas} \tn 
% Row Count 21 (+ 3)
% Row 13
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{- String trim (): devuelve una copia de la cadena, pero sin los espacios en blanco.} \tn 
% Row Count 23 (+ 2)
% Row 14
\SetRowColor{white}
String valueOf (tipo variable): devuelve la cadena de caracteres que resulta al convertir la variable del tipo que se pasa por parámetro & Returns the string representation of the x argument. \tn 
% Row Count 30 (+ 7)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Estructuras de lista}}  \tn
% Row 0
\SetRowColor{LightBackground}
Arrays & -Permiten guardar valores del mismo tipo\{\{nl\}\}-Tamaño fijo \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
Arrays (crear) & int numeros{[}{]} = new int{[}10{]}; \tn 
% Row Count 5 (+ 2)
% Row 2
\SetRowColor{LightBackground}
inicializar & myNum = \{10, 20, 30, 40\}; \tn 
% Row Count 7 (+ 2)
% Row 3
\SetRowColor{white}
Arrays (crear e inicializar) & int n{[}{]} = new int{[}{]}\{1,2,3,4,5,6,7,8,9,10\}; \tn 
% Row Count 10 (+ 3)
% Row 4
\SetRowColor{LightBackground}
acceder & System.out.println(cars{[}0{]}); \tn 
% Row Count 12 (+ 2)
% Row 5
\SetRowColor{white}
 & cars{[}0{]} = "Opel"; \tn 
% Row Count 13 (+ 1)
% Row 6
\SetRowColor{LightBackground}
Arrays multidimensionales (crear) & int{[}{]}{[}{]} temperaturas = new int{[}7{]}{[}2{]}; \tn 
% Row Count 15 (+ 2)
% Row 7
\SetRowColor{white}
crear e inicializar & int{[}{]}{[}{]} myNumbers = \{ \{1, 2, 3, 4\}, \{5, 6, 7\} \}; \tn 
% Row Count 18 (+ 3)
% Row 8
\SetRowColor{LightBackground}
Arrays multidimensionales (acceder) & for (int i = 0; i \textless{} myNumbers.length; ++i) \{       for(int j = 0; j \textless{} myNumbers{[}i{]}.length; ++j) \{ \tn 
% Row Count 23 (+ 5)
% Row 9
\SetRowColor{white}
 & int x = myNumbers{[}1{]}{[}2{]}; \tn 
% Row Count 25 (+ 2)
% Row 10
\SetRowColor{LightBackground}
ArrayList & -Permiten crear listas de objetos.\{\{nl\}\}-Tamaño dinámico \tn 
% Row Count 28 (+ 3)
% Row 11
\SetRowColor{white}
ArrayList (crear) & ArrayList\textless{}String\textgreater{} cars = new ArrayList\textless{}String\textgreater{}(); \tn 
% Row Count 31 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Estructuras de lista (cont)}}  \tn
% Row 12
\SetRowColor{LightBackground}
ArrayList de más de un tipo (crear) & ArrayList a = new ArrayList\textless{}\textgreater{}();         a.add("a");         a.add(true);         a.add(1); \tn 
% Row Count 5 (+ 5)
% Row 13
\SetRowColor{white}
ArrayList - métodos & al.size(); int \tn 
% Row Count 6 (+ 1)
% Row 14
\SetRowColor{LightBackground}
Añade al final & add(E e); true \tn 
% Row Count 7 (+ 1)
% Row 15
\SetRowColor{white}
Añade en pos & add(int index, Object element); true \tn 
% Row Count 9 (+ 2)
% Row 16
\SetRowColor{LightBackground}
Sustituye el elemento en la pos con el nuevo & cars.set(0, "Opel"); el elemento anterior \tn 
% Row Count 12 (+ 3)
% Row 17
\SetRowColor{white}
Devolver el elemento en la pos especificada & .get(int index); \tn 
% Row Count 15 (+ 3)
% Row 18
\SetRowColor{LightBackground}
Borra el elmento en la pos especificada & remove(int index); el elemento borrado \tn 
% Row Count 17 (+ 2)
% Row 19
\SetRowColor{white}
Borra el elemento si coincide & remove(Object o); bool \tn 
% Row Count 19 (+ 2)
% Row 20
\SetRowColor{LightBackground}
 & clear() \tn 
% Row Count 20 (+ 1)
% Row 21
\SetRowColor{white}
 & \seqsplit{Collections.sort(cars);} \tn 
% Row Count 22 (+ 2)
% Row 22
\SetRowColor{LightBackground}
 & isEmpty(); bool \tn 
% Row Count 23 (+ 1)
% Row 23
\SetRowColor{white}
 & contains(Object elem); bool \tn 
% Row Count 25 (+ 2)
% Row 24
\SetRowColor{LightBackground}
 & indexOf(Object elem); int \tn 
% Row Count 27 (+ 2)
% Row 25
\SetRowColor{white}
 & lastIndexOf(Object elem); int \tn 
% Row Count 29 (+ 2)
% Row 26
\SetRowColor{LightBackground}
 & clone(); arrList \tn 
% Row Count 30 (+ 1)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Estructuras de lista (cont)}}  \tn
% Row 27
\SetRowColor{LightBackground}
 & toArray(); arr \tn 
% Row Count 1 (+ 1)
% Row 28
\SetRowColor{white}
 & No se puede añadir en pos donde esa pos no existe aka arrl está vacío \tn 
% Row Count 5 (+ 4)
% Row 29
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{HashMap} \tn 
% Row Count 6 (+ 1)
% Row 30
\SetRowColor{white}
Create a HashMap object called capitalCities that will store String keys and String values: & HashMap\textless{}String, String\textgreater{} capitalCities = new HashMap\textless{}String, String\textgreater{}(); \tn 
% Row Count 11 (+ 5)
% Row 31
\SetRowColor{LightBackground}
añadir key y valor & // Add keys and values (Country, City)     \seqsplit{capitalCities.put("England"}, "London"); \tn 
% Row Count 16 (+ 5)
% Row 32
\SetRowColor{white}
acceder emdiante key & \seqsplit{capitalCities.get("England");} \tn 
% Row Count 18 (+ 2)
% Row 33
\SetRowColor{LightBackground}
borrar mediante key & \seqsplit{capitalCities.remove("England");} \tn 
% Row Count 20 (+ 2)
% Row 34
\SetRowColor{white}
 & \seqsplit{capitalCities.clear();} \tn 
% Row Count 22 (+ 2)
% Row 35
\SetRowColor{LightBackground}
 & \seqsplit{capitalCities.size();} \tn 
% Row Count 24 (+ 2)
% Row 36
\SetRowColor{white}
loop keys & // Print keys for (String i : \seqsplit{capitalCities.keySet())} \{   \seqsplit{System.out.println(i);} \} \tn 
% Row Count 29 (+ 5)
% Row 37
\SetRowColor{LightBackground}
loop values & for (String i : \seqsplit{capitalCities.values())} \{   \seqsplit{System.out.println(i);} \} \tn 
% Row Count 33 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{IlXi}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{6.5626 cm} x{10.7074 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Ficheros}}  \tn
% Row 0
\SetRowColor{LightBackground}
Ler dende ficheiro & FileInputStream fis = new \seqsplit{FileInputStream(ficheiro);} \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
 & ObjectInputStream  ois = new ObjectInputStream(fis); \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
Leer objeto de un fichero & Humidade objL = \seqsplit{(Humidade)ois.readObject();} \tn 
% Row Count 8 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Leer objetos de un fichero} \tn 
% Row Count 9 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{3.9721 cm} x{13.2979 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Excepciones}}  \tn
% Row 0
\SetRowColor{LightBackground}
 & \} catch (Exception e) \{ \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
 & The finally statement lets you execute code, after try...catch, regardless of the result \tn 
% Row Count 4 (+ 3)
% Row 2
\SetRowColor{LightBackground}
custom error & f (age \textless{} 18) \{       throw new \seqsplit{ArithmeticException("Access} denied - You must be at least 18 years old."); \tn 
% Row Count 8 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{p{1.8997 cm} x{15.3703 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Packages}}  \tn
% Row 0
\SetRowColor{LightBackground}
Crear & package mypack;  class MyPackageClass \{javac MyPackageClass.java \tn 
% Row Count 2 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{2.5905 cm} x{14.6795 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Herencia}}  \tn
% Row 0
\SetRowColor{LightBackground}
\seqsplit{Heredar} & class Vehicle \{ \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
 & protected String brand = "Ford"; \tn 
% Row Count 3 (+ 1)
% Row 2
\SetRowColor{LightBackground}
 & public void honk() \{ \tn 
% Row Count 4 (+ 1)
% Row 3
\SetRowColor{white}
 & System.out.println("Tuut, tuut!"); \tn 
% Row Count 5 (+ 1)
% Row 4
\SetRowColor{LightBackground}
 & \} \tn 
% Row Count 6 (+ 1)
% Row 5
\SetRowColor{white}
 & \} \tn 
% Row Count 7 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{-} \tn 
% Row Count 8 (+ 1)
% Row 7
\SetRowColor{white}
 & class Car extends Vehicle \{ \tn 
% Row Count 9 (+ 1)
% Row 8
\SetRowColor{LightBackground}
 & private String modelName = "Mustang";    // Car attribute \tn 
% Row Count 11 (+ 2)
% Row 9
\SetRowColor{white}
 & // Car attribute   public static void main(String{[}{]} args) \{ \tn 
% Row Count 13 (+ 2)
% Row 10
\SetRowColor{LightBackground}
 & // Create a myCar object     Car myCar = new Car(); \tn 
% Row Count 15 (+ 2)
% Row 11
\SetRowColor{white}
 & // Call the honk() method (from the Vehicle class) on the myCar object     myCar.honk(); \tn 
% Row Count 18 (+ 3)
% Row 12
\SetRowColor{LightBackground}
 & // Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class     \seqsplit{System.out.println(myCar.brand} + " " + myCar.modelName); \tn 
% Row Count 24 (+ 6)
% Row 13
\SetRowColor{white}
 & \} \tn 
% Row Count 25 (+ 1)
% Row 14
\SetRowColor{LightBackground}
 & \} \tn 
% Row Count 26 (+ 1)
% Row 15
\SetRowColor{white}
 & Subclase hereda atributos y miembros \tn 
% Row Count 28 (+ 2)
% Row 16
\SetRowColor{LightBackground}
- & Brand is protected so subclass can use it. \tn 
% Row Count 30 (+ 2)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{2.5905 cm} x{14.6795 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Herencia (cont)}}  \tn
% Row 17
\SetRowColor{LightBackground}
 & La subclase puede usar lo heredado o hacer override (a menos que sea final), y puede crear nuevos métodos \tn 
% Row Count 4 (+ 4)
% Row 18
\SetRowColor{white}
 & Sólo se puede heredar de una clase \tn 
% Row Count 6 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Poliformismo}}  \tn
% Row 0
\SetRowColor{LightBackground}
abstracción, herencia, especialización & \seqsplit{https://jarroba.com/polimorfismo-en-java-parte-i-con-ejemplos/} \tn 
% Row Count 4 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{p{1.727 cm} p{1.727 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Estructuras de control}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{switch(a)\{ case 1: break; default: \}} \tn 
% Row Count 1 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{p{1.727 cm} p{1.727 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Declarar un String}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{//Declaración de un array que pasaremos a String char {[}{]} array = new char{[}{]}\{'l','i','t','e','r','a','l'\}; //Formas de declarar un String String forma1 = new String \seqsplit{("literal\_cadena\_caracteres");} String forma2 = \seqsplit{"literal\_cadena\_caracteres";} String forma3 = new String (array); String forma4 = new String (forma2);} \tn 
% Row Count 7 (+ 7)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{A Collection is a group of individual objects represented as a single unit. Java provides Collection Framework which defines several classes and interfaces to represent a group of objects as a single unit.} \tn 
% Row Count 5 (+ 5)
% Row 1
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{The Collection interface (java.util.Collection) and Map interface (java.util.Map) are the two main "root" interfaces of Java collection classes.} \tn 
% Row Count 8 (+ 3)
% Row 2
\SetRowColor{LightBackground}
Need for Collection Framework : & Before Collection Framework (or before JDK 1.2) was introduced, the standard methods for grouping Java objects (or collections) were Arrays or Vectors or Hashtables. All of these collections had no common interface. \tn 
% Row Count 19 (+ 11)
% Row 3
\SetRowColor{white}
Set (Conjunto) & an unordered collection of objects in which duplicate values cannot be stored. \tn 
% Row Count 23 (+ 4)
% Row 4
\SetRowColor{LightBackground}
 & Set is implemented by HashSet, LinkedHashSet or TreeSet \tn 
% Row Count 26 (+ 3)
% Row 5
\SetRowColor{white}
 & \seqsplit{https://www.geeksforgeeks.org/set-in-java/} \tn 
% Row Count 29 (+ 3)
% Row 6
\SetRowColor{LightBackground}
List & an ordered collection of objects in which duplicate values can be stored. Since List preserves the insertion order, it allows positional access and insertion of elements. \tn 
% Row Count 38 (+ 9)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
 & List Interface is implemented by ArrayList, LinkedList, Vector and Stack classes. \tn 
% Row Count 5 (+ 5)
% Row 8
\SetRowColor{white}
 & \seqsplit{https://www.geeksforgeeks.org/list-interface-java-examples/} \tn 
% Row Count 8 (+ 3)
% Row 9
\SetRowColor{LightBackground}
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-in-first-out. In addition to the basic push and pop operations, the class provides three more functions of empty, search and peek. The class can also be said to extend Vector \tn 
% Row Count 25 (+ 17)
% Row 10
\SetRowColor{white}
 & \seqsplit{https://www.geeksforgeeks.org/stack-class-in-java/} \tn 
% Row Count 28 (+ 3)
% Row 11
\SetRowColor{LightBackground}
 & - Introducir un nuevo elemento sobre la cima (push). \tn 
% Row Count 31 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 12
\SetRowColor{LightBackground}
 & Eliminar un elemento de la cima (pop). \tn 
% Row Count 2 (+ 2)
% Row 13
\SetRowColor{white}
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-First-Out principle. \tn 
% Row Count 24 (+ 22)
% Row 14
\SetRowColor{LightBackground}
 & \seqsplit{https://www.geeksforgeeks.org/queue-interface-java/} \tn 
% Row Count 27 (+ 3)
% Row 15
\SetRowColor{white}
 & Encolar (enqueue): para ir añadiendo elementos \tn 
% Row Count 30 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 16
\SetRowColor{LightBackground}
 & Desencolar (dequeue): para eliminar elementos. \tn 
% Row Count 3 (+ 3)
% Row 17
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{-} \tn 
% Row Count 4 (+ 1)
% Row 18
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Iterators} \tn 
% Row Count 5 (+ 1)
% Row 19
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Este iterador nos proporcionará unos métodos propios de este, que facilitarán recorrer este objeto collection, a continuación, vemos los métodos más utilizados: - 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.} \tn 
% Row Count 14 (+ 9)
% Row 20
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Iterator \textless{}String\textgreater{} iterador = nombre.iterator(); while (iterador.hasNext()) \{ String nombre = iterador.next(); //código bucle while \} //Con las listas podemos utilizar un bucle for mejorado for (String.nombre : nombres) \{ //código bucle for each \}} \tn 
% Row Count 19 (+ 5)
% Row 21
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{-{}-} \tn 
% Row Count 20 (+ 1)
% Row 22
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Not a collection -} \tn 
% Row Count 21 (+ 1)
% Row 23
\SetRowColor{white}
Map & The java.util.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 \tn 
% Row Count 32 (+ 11)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 24
\SetRowColor{LightBackground}
 & A Map cannot contain duplicate keys and each key can map to at most one value. Some implementations allow null key and null value like the HashMap and LinkedHashMap, but some do not like the TreeMap. \tn 
% Row Count 10 (+ 10)
% Row 25
\SetRowColor{white}
 & There are two interfaces for implementing Map in java: Map and SortedMap, and three classes: HashMap, TreeMap and LinkedHashMap. \tn 
% Row Count 17 (+ 7)
% Row 26
\SetRowColor{LightBackground}
 & \seqsplit{https://www.geeksforgeeks.org/map-interface-java-examples/} \tn 
% Row Count 20 (+ 3)
% Row 27
\SetRowColor{white}
 & Maps are perfect to use for key-value association mapping such as dictionaries. The maps are used to perform lookups by keys or when someone wants to retrieve and update elements by keys. \tn 
% Row Count 30 (+ 10)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 28
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{-{}-{}-LIST INTERFACES} \tn 
% Row Count 1 (+ 1)
% Row 29
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{ArrayList} \tn 
% Row Count 2 (+ 1)
% Row 30
\SetRowColor{LightBackground}
//Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): & ArrayList nombre = new ArrayList (); \tn 
% Row Count 8 (+ 6)
% Row 31
\SetRowColor{white}
//Instancia de colección con tipo específico: & ArrayList \textless{}Tipo\_de\_dato\textgreater{} nombre = new ArrayList \textless{}Tipo\_de\_dato\textgreater{} (); \tn 
% Row Count 12 (+ 4)
% Row 32
\SetRowColor{LightBackground}
get (int): & obtiene el objeto que se encuentra en la posición pasada por parámetro. \tn 
% Row Count 16 (+ 4)
% Row 33
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{indexOf (Object):} \tn 
% Row Count 17 (+ 1)
% Row 34
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{isEmpty ()} \tn 
% Row Count 18 (+ 1)
% Row 35
\SetRowColor{white}
set (int, Objeto) & sobrescribe el elemento que se encuentra en la posición int por un objeto que se indica por parámetro \tn 
% Row Count 24 (+ 6)
% Row 36
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{toArray(): devuelve una lista de objetos y, en cada casilla de esta lista, inserta un objeto de ArrayList.} \tn 
% Row Count 27 (+ 3)
% Row 37
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{toString()} \tn 
% Row Count 28 (+ 1)
% Row 38
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{.add} \tn 
% Row Count 29 (+ 1)
% Row 39
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{.remove} \tn 
% Row Count 30 (+ 1)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 40
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{LinkedList} \tn 
% Row Count 1 (+ 1)
% Row 41
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{//Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): LinkedList nombre = new LinkedList (); //Instancia de colección con tipo específico: LinkedList \textless{}Tipo\_de\_dato\textgreater{} nombre = new LinkedList \textless{}Tipo\_de\_dato\textgreater{} ();} \tn 
% Row Count 7 (+ 6)
% Row 42
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{removeFirst(): elimina el primer elemento de la lista enlazada. - addFirst(): añade un elemento al principio de la lista. - addLast(): añade un elemento al final de la lista. - getFirst(): devuelve el primer elemento de la lista. - getLast(): devuelve el último elemento de la lista} \tn 
% Row Count 13 (+ 6)
% Row 43
\SetRowColor{white}
Vector & Dispone de un array de objetos que puede aumentar o disminuir de forma dinámica según las operaciones que se vayan a llevar a cabo \tn 
% Row Count 20 (+ 7)
% Row 44
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{//Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): Vector nombre = new Vector (); //Instancia de colección con tipo específico: Vector \textless{}Tipo\_de\_dato\textgreater{} nombre = new Vector \textless{}Tipo\_de\_dato\textgreater{} (); Algunos de sus métodos más importantes son: - firstElement (): devuelve el primer elemento del vector. - lastElemento (): devuelve el último elemento del vector. - capacity (): devuelve la capacidad del vector. - setSize (int): elige un nuevo tamaño para el vector. En el caso de que sea más grande que el que tenía en un principio, inicializa a null los nuevos valores. En el caso de que sea menor que el inicial, elimina los elementos restantes.} \tn 
% Row Count 34 (+ 14)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 45
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{-{}-{}-SET INTERFACES} \tn 
% Row Count 1 (+ 1)
% Row 46
\SetRowColor{white}
HashSet & Es rápida en cuanto a operaciones básicas (inserción, borrado y búsqueda), no admite duplicados, la iteración a través de sus elementos es más costosa, ya que, necesitará recorrer todas las entradas de la tabla y la ordenación puede diferir del orden en el que se han insertado los elementos. \tn 
% Row Count 17 (+ 16)
% Row 47
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{//Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): HashSet nombre = new HashSet (); //Instancia de colección con tipo específico: HashSet \textless{}Tipo\_de\_dato\textgreater{} nombre = new HashSet \textless{}Tipo\_de\_dato\textgreater{} ();} \tn 
% Row Count 22 (+ 5)
% Row 48
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{- isEmpty(): devuelve si el conjunto está vacío o contiene valores con un valor booleano. - clone(): devuelve una copia superficial de esta instancia de HashSet: los elementos en sí no están clonados. - clear(): borra todos los elementos del conjunto.} \tn 
% Row Count 28 (+ 6)
% Row 49
\SetRowColor{LightBackground}
Recorrer & for(Double s : colSetInt)\{ \seqsplit{System.out.println(s);} \} \tn 
% Row Count 31 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 50
\SetRowColor{LightBackground}
TreeSet & el coste para realizar las operaciones básicas será logarítmico con el número de elementos que tenga el conjunto. \tn 
% Row Count 6 (+ 6)
% Row 51
\SetRowColor{white}
 & CÓDIGO: //Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): TreeSet nombre = new TreeSet (); //Instancia de colección con tipo específico: TreeSet \textless{}Tipo\_de\_dato\textgreater{} nombre = new TreeSet \textless{}Tipo\_de\_dato\textgreater{} (); Algunos de sus métodos más importantes 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. \tn 
% Row Count 43 (+ 37)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 52
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{-{}-{}-QUEUE INTERFACES} \tn 
% Row Count 1 (+ 1)
% Row 53
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{ArrayDeque} \tn 
% Row Count 2 (+ 1)
% Row 54
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{- push(): añade un elemento al principio de la cola. - pop(): elimina el elemento de la cola que se ha insertado primero. - pollFirst(): elimina el primer elemento de la cola. - pollLast(): elimina el ultimo elemento de la cola.FMAP} \tn 
% Row Count 7 (+ 5)
% Row 55
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{-{}-{}-MAP} \tn 
% Row Count 8 (+ 1)
% Row 56
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Un map es un conjunto de valores, con el detalle de que cada uno de estos valores tiene un objeto extra asociado} \tn 
% Row Count 11 (+ 3)
% Row 57
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{A los primeros se les llama claves o keys, porque nos permiten acceder a los segundos. Los valores clave no aceptan valores duplicados.} \tn 
% Row Count 14 (+ 3)
% Row 58
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{get (Object): obtiene el valor correspondiente a una clave. Devuelve null si la clave no existe en el map. put (clave, valor): añade un par clave-valor al map. Si ya había un valor para esa clave lo remplaza. keySet(): devuelve todas las claves (devuelve un Set, es decir, sin duplicados). values(): todos los valores (en este caso sí pueden estar duplicados).entrySet(): todos los pares clave-valor (devuelve un conjunto de objetos Map.Entry, cada uno de los cuales devuelve la clave y el valor con los métodos getKey() y getValue() respectivamente)} \tn 
% Row Count 26 (+ 12)
% Row 59
\SetRowColor{white}
add key and value & \seqsplit{coloresPreferidos.put(ILERNA}, Color.AZUL); \tn 
% Row Count 29 (+ 3)
% Row 60
\SetRowColor{LightBackground}
change key value & \seqsplit{coloresPreferidos.put(ILERNA}, Color.AZUL); \tn 
% Row Count 32 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Colecciones/Collections (cont)}}  \tn
% Row 61
\SetRowColor{LightBackground}
get & Color colorPreferido = \seqsplit{coloresPreferidos.get(ILERNA);} \tn 
% Row Count 3 (+ 3)
% Row 62
\SetRowColor{white}
remove & \seqsplit{ColoresPreferidos.remove(ILERNA);} \tn 
% Row Count 5 (+ 2)
% Row 63
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{{\bf{HashMap}}} \tn 
% Row Count 6 (+ 1)
% Row 64
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Es rápida en cuanto a operaciones básicas (inserción, borrado y búsqueda), no admite duplicados, la iteración a través de sus elementos es más costosa, ya que necesitará recorrer todas las entradas de la tabla y la ordenación puede diferir del orden en el que se han insertado los elementos} \tn 
% Row Count 12 (+ 6)
% Row 65
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{//Instancia de tipo Genérico (Cuando no sabemos qué tipo de datos vamos a introducir en la colección): HashMap nombre = new HashMap (); //Instancia de colección con tipo específico: HashMap \textless{}Tipo\_de\_dato\_clave, Tipo\_de\_dato\_valor\textgreater{} nombre; nombre = new HashMap \textless{} Tipo\_de\_dato\_clave, Tipo\_de\_dato\_valor \textgreater{} ();} \tn 
% Row Count 19 (+ 7)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{\seqsplit{https://www.geeksforgeeks.org/collections-in-java-2/}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{Generic Methods and Classes}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{es posible que queramos crear alguna clase o método genético de forma que no sepamos previamente el tipo de dato con el que vamos a trabajar. A esto es a lo que llamamos clase y métodos genéricos} \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Crear clases genéricas} \tn 
% Row Count 5 (+ 1)
% Row 2
\SetRowColor{LightBackground}
\seqsplit{modificador\_de\_acceso} class nombre\_clase \textless{}T\textgreater{} \{ T variable; \} & Donde "T" representa un tipo de referencia válido en el lenguaje Java: String, Integer, Alumno, Libro, Coche o cualquier otro tipo \tn 
% Row Count 12 (+ 7)
% Row 3
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Los parámetros de clases por tipos no se limitan a un único parámetro (T). Por ejemplo, la clase HashMap que indicamos a continuación, permite dos parámetros: CÓDIGO: class Hash \textless{}A, B\textgreater{} \{ \} En este caso, tenemos dos parámetros A y B que hacen referencia al tipo de clave y el valor} \tn 
% Row Count 18 (+ 6)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{También podemos aplicar esta sintaxis en interfaces: CÓDIGO: public interface nombre\_interface\textless{}K,V\textgreater{}\{ public K getKey(); public V getValue(); \}} \tn 
% Row Count 21 (+ 3)
% Row 5
\SetRowColor{white}
\mymulticolumn{2}{x{17.67cm}}{Y esta interface podría ser implementada por una clase: CÓDIGO: public class n\_clase\textless{}K,V\textgreater{} implements n\_interface\textless{}K,V\textgreater{}\{ 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 getValue()\{return value;\} \} Donde K representa la clave y V representa el valor.} \tn 
% Row Count 28 (+ 7)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{Podemos crear métodos para que puedan utilizar los tipos parametrizados, bien sea en las clases genéricas o en las normales. La sintaxis para crear un tipo genérico es: CÓDIGO: public static \textless{}T\textgreater{} T metodogenerico (T parametroFormal) \{ //código método \} Y, para invocar este método: CÓDIGO: claseDelMetodoGenerico.\textless{}TipoConcreto\textgreater{} método (ParametroReal); Aunque, en algunos casos, puede que el compilador deduzca qué tipo de parámetro se va a utilizar y, en este caso, se puede obviar. CÓDIGO: \seqsplit{ClasedelMetodoGenerico.metodo} (parametroReal);} \tn 
% Row Count 39 (+ 11)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{17.67cm}{x{8.635 cm} x{8.635 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{17.67cm}}{\bf\textcolor{white}{java.util.regex}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{\textless{} \$, \textasciicircum{}, ., *, +, ?, {[}, {]}, . \textgreater{}} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
{\bf{util.regex.Pattern}} & Used for defining patterns \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
compile the given regular expression into a pattern & compile(String regex) \tn 
% Row Count 6 (+ 3)
% Row 3
\SetRowColor{white}
 & Pattern patron = \seqsplit{Pattern.compile("camion");} \tn 
% Row Count 9 (+ 3)
% Row 4
\SetRowColor{LightBackground}
{\bf{util.regex.Matcher}} & Used for performing match operations on text using patterns \tn 
% Row Count 12 (+ 3)
% Row 5
\SetRowColor{white}
 & Matcher encaja = patron.matcher() \tn 
% Row Count 14 (+ 2)
% Row 6
\SetRowColor{LightBackground}
\seqsplit{matcher(CharSequence} input) & It is used to create a matcher that will match the given input against this pattern. \tn 
% Row Count 19 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{17.67cm}}{???}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}



\end{document}