ESTRUCTURA DE
DATOS EN JAVA
Ingeniero José Leyder Gil López
 Un arreglo se usa para agrupar, almacenar y organizar datos de un
mismo
ARREGLOS
UNIDIMENSIONALES Y
BIDIMENSIONALES
 tipo. En un arreglo cada valor se almacena en una posición
numerada
 específica dentro del arreglo. El número correspondiente a cada
posición se
 conoce como índice.
ARREGLOS
ESTRUCTURA DE UN ARREGLO
UNIDIMENSIONAL
Normalmente el primer objeto del arreglo tiene el índice 0, aunque esto
varía de lenguaje en lenguaje.
 Declaración:
Como se sabe, hay 2 tipos de datos en Java: primitivos (como int y double) y
objetos. En muchos lenguajes de programación (aún en Orientados a Objetos
como C++) los arreglos son tipos primitivos, pero en Java son tratados como
objetos. Por consiguiente, se debe utilizar el operador new para crear un
ARREGLOS
arreglo:
UNIDIMENSIONALES – COMO SE
DECLARAN
int miArreglo[]; // define la referencia a un arreglo
miArreglo = new int[100]; // crea el arreglo y establece miArreglo
// como referencia a él
O el equivalente a hacerlo dentro de una misma sentencia
int miArreglo[] = new int[100];
El operador [] es la señal para el compilador que estamos
declarando un arreglo (objeto) y no una variable ordinaria.
Dado que un arreglo es un objeto, el nombre –miArreglo-, en el
ejemplo anterior- es una referencia a un arreglo y no el nombre del
arreglo como tal.
ARREGLOS
UNIDIMENSIONALES – HALLAR EL
TAMAÑO DEL ARREGLO
El arreglo es almacenado en una dirección de memoria x, y
miArreglo almacena solo esa dirección de memoria.
Los arreglos tienen el método length, el cual se utiliza para
encontrar el tamaño de un arreglo:
int tamaño = miArreglo.length; // arroja el tamaño del arreglo
Para acceder a los elementos de un arreglo se debe utilizar los
corchetes, muy similar a otros lenguajes de programación:
ARREGLOS
UNIDIMENSIONALES – COMO
ACCEDER A LOS ELEMENTOS DEL
ARREGLO
temp = miArreglo[4]; // guarda en temp el valor del cajón 4 del
arreglo
miArreglo[8] = 50; // almacena en el cajon 8 del arreglo el valor 50
Es preciso recordar que en Java, como en C y C++, el primer
elemento del arreglo es el 0. Luego entonces, los índices de un
arreglo de 10 elementos van del 0 al 9.
package arreglosunidimensionales;
public class ArreglosUnidimensionales {
public static void main(String[] args) {
int x[] = new int[5];
x[0] = 10;
x[1] = 30;
x[2] = 25;
ARREGLOS
x[3] = 2;
UNIDIMENSIONALES - EJEMPLO
x[4] = 12;
for (int i = 0; i < x.length; i++) {
System.out.println("x[" + i + "]:" + x[i]);
}
}
}
Se pueden implementar una serie de operaciones básicas sobre
los arreglos, a saber:
 - Insertar elementos
ARREGLOS
 - Búsqueda de elementos
UNIDIMENSIONALES –
OPERACIONES SOBRE ARREGLOS
 - Eliminar elementos
 - Mostrar los elementos
 - Ordenar los elementos
 - Modificar algún elemento
Un arreglo de dos dimensiones, también llamado tabla o matriz,
donde cada elemento se asocia con una pajera de índices, es otro
arreglo simple.
Conceptualizamos un arreglo bidimensional como una cuadrícula
rectangular de elementos divididos en filas y columnas, y utilizamos
la notación (fila,
ARREGLOS
BIDIMENSIONALES - MATRICES
columna) para identificar un elemento específico. La siguiente
figura muestra la visión conceptual y la notación específica de los
elementos:
El trabajo con los arreglos bidimensionales es muy parecido a los
arreglos lineales, la declaración de uno de ellos se da de la siguiente
manera:
ARREGLOS
BIDIMENSIONALES DECLARACIÓN
double [][] temperatures = new double [2][2]; // Dos filas y dos
columnas.
La asignación de datos, se hace de una forma similar a los arreglos
lineales:
temperatures [0][0] = 20.5;
temperatures [0][1] = 30.6;
temperatures [0][2] = 28.3;
ARREGLOS
BIDIMENSIOANLES – ASIGNACIÓN
DE DATOS
temperatures [1][0] = -38.7;
temperatures [1][1] = -18.3;
temperatures [1][2] = -16.2;
Las operaciones con las matrices son muy variadas, desde las
básicas como:
insertar y eliminar elementos hasta multiplicaciones de matrices,
entre otras.
package arreglosbidimensionales;
public class ArreglosBidimensionales {
public static void main(String[] args) {
int x[][];
x = new int[2][2];
x[0][0] = 34;
x[0][1] = 11;
x[1][0] = 25;
ARREGLOS
x[1][1] = 4;
BIDIMENSIONALES - EJEMPLO
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
System.out.println("x[" + i + "][" + j + "]" + x[i][j]);
}
}
}
}
COLECCIONES
Librería: Java.util
 Framework que nos permite utilizar diferentes estructuras de
datos para almacenar y recuperar objetos de cualquier clase
(java.util)
COLECCIONES
 INTERFAZ: CLASE ABSTRACTA QUE NO NOS PERMITE USARLA PARA
CREAR OBJETOS, PERO SI DEFINE LOS MÉTODOS QUE TENDRÁ TODAS
LAS POSIBLES IMPLEMENTACIONES DE LA INTERFAZ
 Sintaxis para instanciar una colección
SINTAXIS PARA
INSTANCIAR
UNA
COLECCIÓN
 Colección<clase> nombre = new Colección<clase>();

 Ejemplo
 List<String> lista = new ArrayList<String>();
SUBTIPOS DE
LA INTERFAZ
COLLECTION
 CONJUNTO: (Hereda de Collection): Los elementos no tienen un
orden y no se permiten duplicados, hereda de la clase collection
 Interfaz: Set <E>
 Implementaciones: HashSet<E>, LinkedSet<E>, TreeSet<E>
SUBTIPOS DE
LA INTERFAZ
COLLECTION
 LISTA: (Hereda de Collection): list es una colección de elemento
potencialmente repetidos indexados por enteros (se parece a un
array). Se puede usar en una factura. Se puede usar en las notas que
se sacan de un examen. Es una estructura secuencial, donde cada
elemento tiene un índice o posición
 Interfaz: List <E>
 Implementaciones: ArrayList<E>, LinkedList<E>, Stack<E>,
Vector<E>
SUBTIPOS DE
LA INTERFAZ
COLLECTION
 DICCIONARIO: (No hereda de Collection): Map es una colección de
elementos repetibles indexados por clave única arbitraria, el tema
semántico de los map es la clave no el valor, la clave no puede
repetirse, se puede guardar 10 veces el mismo valor siempre y
cuando la clave sea distinta. Cada elemento tiene asociado una
clave que se usara para poder recuperarlo.
 Interfaz: Map <K, V>
 Implementaciones: HashMpa< K, V >, TreeMap< K, V >, LinkedMap<
K, V >
COLECCIONES
GRAFICA DE JERARQUÍA DE
INTERFACES Y CLASES
INTERFAZ COLLECTION (CONJUNTOY LISTA)
MÉTODOS QUE SON HEREDADOS POR DESDE COLLECTION POR
LOS CONJUNTOSY LAS LITAS
COLECCIONES –
INTERFAZ
COLLECTION
boolean add(E e): Añade un nuevo elemento a la Colección.
boolean remove(E e): Elimina el elemento indicado.
boolean contains(E e): Mira si el elemento está en la colección
void clear(): Elimina todos los elementos de la colección.
Int size(): Devuelve el número de elementos en la colección.
boolean isEmpty(): Comprueba si la colección está vacía.
LOS SIGUIENTES MÉTODOS COMBINAN 2 COLECCIONES
COLECCIONES –
INTERFAZ
COLLECTION
boolean
en c
addAll(Collection<?> c): Elimina todo elemento que este
boolean
containsAll(Collection<?>
subconjunto nuestro
c):
Comprueba si c es
boolean retainAll(Collection<?> c): Elimina todos los elementos a
no ser que estén en c (Obtiene la intersección).
EJEMPLOS:
CONJUNTO: Estructura De Datos Donde Los Elementos No Tienen
Un Orden Ni Se Permiten Duplicados.
Set<String> conjunto = new HashSet<String>();
conjunto.add(“manzana”);
COLECCIONES –
CONJUNTO
(SET)
conjunto.add(“pera”);
conjunto.add(“banano”);
conjunto.add(“mango”);
for (String s : conjunto){
System.out.println(s);
}
LISTA: Estructura Secuencial, donde cada elemento tiene un índice
o posición
Metodos:
boolean add(int índice, E e): Inserta Elemento a la Posición
COLECCIONES –
LISTA (LIST)
E get(int índice): Devuelve elemento en la posición.
int indexOf(E e): Primera Posición en que se encuentra elemento.
int lastIndexOf(E e): Ultima Posición del elemento.
E remove(int índice): Elimina el elemento de la posición indicada.
E set(int índice, E e): Reemplaza elemento en la posición
package ejemploarraylist2;
import java.util.*;
public class EjemploArrayList2 {
public static void main(String[] args) {
List<String> lista = new ArrayList<>();
lista.add("LEYDER");
COLECCIONES –
LISTA (LIST)
IMPLEMENTACIÓN
ARRAYLIST
lista.add("GIL");
lista.add("LOPEZ");
//Añadir un elemento en una posición de la Lista.
//lista.add(1, "OK");
for (String c : lista) {
System.out.println(c);
}
}
}
public class EjemploArrayList {
public static void main(String[] args) {
List<String> cadenas; //Declaración
cadenas = new ArrayList<>(); //Crear Instancia
cadenas.add("Hola"); //Agregar Elementos
cadenas.add("como");
cadenas.add("Estas");
COLECCIONES –
LISTA (LIST) –
IMPLEMENTACIÓN
ARRAYLIST
for (int i = 0; i < cadenas.size(); i++) {//Recorrer arraylist con un for
System.out.println("--->" + cadenas.get(i));
}
cadenas.remove(1); //Eliminar Elementos
for (int i = 0; i < cadenas.size(); i++) {
System.out.println("===>" + cadenas.get(i));
}
}
}
Descargar

Descarga