REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA

EDUCACIÓN UNIVERSITARIA
INSTITUTO UNIVERSITARIO POLITECNICO
“SANTIAGO MARIÑO”

Estructuras de datos en Java

¿Cómo crearlas?

Nombre: Enmanuel Morles

C.I: 27.691.096
03/12/2022
Sección: "AB"
 ¿Qué es la estructuras de datos en Java?

La estructura de datos en Java es el sistema mediante el cual

se organizan los datos en la memoria de la aplicación que se
está programando. Existen muchas formas de organizar los
datos en la memoria.

Por ejemplo, un array es una colección de elementos de

memoria en el que los datos se almacenan de forma secuencial.

Sin embargo, es necesario explicar la importancia y significado

de los algoritmos en este rubro de la estructura de datos.
 ¿Qué son los algoritmos en Java?

Los algoritmos en Java son instrucciones precisas sobre cómo realizar una
tarea específica. En el contexto de la programación, los algoritmos se
definen normalmente mediante el código fuente.

La eficiencia de una sistema o aplicación determinada, normalmente, se

mide o se asocia con los algoritmos. En este contexto, la eficiencia de un
programa es una parte integral de la usabilidad de un programa.

En un sentido más amplio, los algoritmos en Java permiten recuperar y

mostrar información rápidamente. Se trata de una parte fundamental
dentro de la estructura de datos en Java.

Y la cual se rige por una tipología de datos particular.

 ¿Cuáles son los tipos de datos en Java?

Un tipo de dato es un atributo de datos que dice cómo el

programador pretende usar los datos.
• Primitivo: bloque de construcción básico (booleano, entero,
flotante, char, etc.)
• Compuesto: cualquier tipo de datos (estructura, matriz,
cadena, etc.) compuesto por tipos primitivos o compuestos.
El conjunto de los tipos de datos son lo que conforma la
estructura de datos en Java.
Es decir: los primitivos se avocan a lo esencialmente puro e
específico. Mientras los compuestos es un conjunto más complejo
de simbología y reglas.
 Tipos de estructuras de datos en Java

Como ya hemos visto, una estructura de datos en Java es una colección de “valores”,
de tipos de datos que se almacenan y organizan de tal forma que permiten un acceso y
una modificación eficientes. En algunos casos, una estructura de datos puede
convertirse en la implementación subyacente de un tipo de datos en particular.
Por ejemplo, los tipos de datos compuestos son estructuras de datos que se
componen de tipos de datos primitivos y otros tipos compuestos. La estructura de
datos en Java se puede utilizar como implementación concreta para ese tipo de
datos.
Cuando pensamos en estructuras de datos, generalmente hay cuatro formas:
• Lineal: matrices, listas.
• Árbol: binario, montones, partición de espacio, etc.
• Hash: tabla hash distribuida, árbol hash, etc.
• Gráficos: decisión, dirigido, acíclico, etc.
 Realizando estructuras de datos
(Paso a paso)
Caso #1-Arrays
Un array es un tipo de estructura que tiene una conformación lineal y puede almacenar
una cantidad de datos que sean del mismo tipo. Los datos que puede almacenar son
tipos primitivos como por ejemplo int, bool, etc. Pero también se puede almacenar tipos
de objetos, aunque en este caso se almacena es la referencia al objeto y no el objeto como
tal, sin embargo es algo muy útil de saber.

Acceso
Al ser de tipo lineal, el acceso a su contenido debe hacerse de forma secuencial, aunque
podemos apuntar directo a un índice del mismo y obtener su contenido, el recorrido en la
mayoría de los casos que podemos hacer sobre esta estructura responde a una secuencia
de sus índices.

Cuando tenemos un índice por elemento es un array o vector unidimensional, en cambio

cuando tenemos más de un índice por elemento estamos hablando de
arrays multidimensionales, es decir, dentro de un índice tenemos una estructura interna
con sus propios índices.
 Paso #1-Declarar un array
Declarar un array es muy sencillo, únicamente debemos definir el tipo de dato que va a almacenar e indicarle
las dimensiones con corchetes, luego debemos definir el nombre del mismo y con ello ya podemos empezar a
utilizarlo.

A pesar que hay varias formas de declarar un array, la preferida es la forma corta como vemos a continuación:

tipo[] nombreArrary = new tipo[longitud];

En el caso de un array multidimensional podemos hacer lo mismo pero agregando las nuevas capas o
dimensiones dentro de la misma declaración, por ejemplo:

Array de dos dimensiones:

tipo[][] nombreArrary = new tipo[longitud][longitud];

Array de tres dimensiones:

tipo[][][] nombreArrary = new tipo[longitud][longitud][longitud];

Lo único que debemos tener en cuenta es que luego de tres dimensiones las cosas se vuelven mucho más
complejas, pero ya esto lo va a dictar nuestras necesidades al momento del desarrollo del programa.
 Paso #2-Recorrer un array
Para recorrer un array debemos utilizar alguno de los ciclos iterativos que tenemos disponibles,
siendo el ciclo for uno de los preferidos, ya que podemos indicar el tamaño del array y recorrer
cada uno de sus elementos.

Debemos tener en cuenta que los índices de los arrays empiezan desde cero, por lo que en un array
de tres elementos sus índices serían [0], [1], [2], esto hay que tenerlo muy en cuenta ya que al no
ser una cuenta tradicional puede llevarnos a la confusión.

Un ejemplo genérico de como recorrer un array es algo como lo siguiente:

for (int i=0; i<LogitudArray; i++) {

System.out.println(nuestroArray[i]);
}

De la misma forma que en ese pequeño ejemplo hemos hecho impresión por pantalla del contenido
del índice correspondiente, también podemos hacer asignaciones secuenciales y otras operaciones
con el array. En el caso de un array multidimensional debemos hacer un ciclo por cada una de las
dimensiones que tenemos, es por ello que hablamos de que luego de más de tres dimensiones un
array se vuelve muy complejo.
 Ejemplificación
Se construye construir un pequeño código en el cual se definirá un array, luego, se hará un recorrido de sus elementos para q ue luego
se muestre el resultado por pantalla. De tal manera que al organizar de forma secuencia, el código luce de la siguiente forma;

public class Array {

public static void main(String[] argv) {
int[] EjArray = new int[10];
for (int i=0; i<10; i++) {
EjArray[i] = i+1;
System.out.println("El contenido del array en: [" + i +"] es: "+ EjArray[i]);
}
System.out.println("La longitud total del array es: " + EjArray.length);
}
}

En este programa lo primero que se realiza al definir nuestra clase y el método main, es definir un array del tipo int (entero) con
nombre EjArray al cual se le asigna una longitud de 10 elementos. Posteriormente con un ciclo for que va del 0 al 9, se asigna un valor a
cada uno de los índices del array, luego de esto, se imprime su valor y finalmente se emplea la propiedad length del array que permite
obtener su longitud total y se imprime por igual.
 Caso #2-Listas
La interfaz de Lista de Java es un subtipo de la interfaz de colección de Java.
Esta es la interfaz estándar que hereda la interfaz de colección de Java.

Las listas (List) aparecen en los interfaces de usuario para facilitar a los
operadores la manipulación de muchos elementos. Se crean utilizando métodos
similares a los de los botones Choice.

La interfaz de Lista de Java es un subtipo de la interfaz de colección de Java.

Esta es la interfaz estándar que hereda la interfaz de colección de Java.
 Paso #1-Crear y declarar una Lista

List es una interfaz y está implementada por clases como ArrayList, Stack, Vector y LinkedList.
Por lo tanto, puede declarar y crear instancias de la lista de cualquiera de las siguientes maneras:

List linkedlist = new LinkedList(); List arrayList = new ArrayList();List vec_list = new Vector();
List stck_list = new Stack();

como se muestra arriba, se puede crear una lista con cualquiera de las clases anteriores y luego
inicializar estas listas con valores., A partir de las instrucciones anteriores, puede ver que el orden
de los elementos cambiará dependiendo de la clase utilizada para crear una instancia de la lista.

por ejemplo, para una lista con clase stack, el orden es Last In, First Out (LIFO).
 Paso #2-Inicializar una lista
Usando el método asList
Se puuede crear una lista inmutable utilizando los valores de la matriz. La sintaxis general es:
List<data_type> listname = Arrays.asList(array_name);

Aquí, el data_type debe coincidir con el de la matriz.

la instrucción anterior crea una lista inmutable. Si desea que la lista sea mutable, entonces se debe crear una
instancia de la lista usando new y luego asignarle los elementos de matriz usando el método asList.esto es
como se muestra a continuación:
List<data_type> listname = new ArrayList<> (Arrays.asList(array_name));
implementemos un programa en Java que muestre la creación e inicialización de la lista utilizando el método
asList.,
salida:
En el programa anterior, se crea una lista inmutable primero utilizando el método asList. Luego, se genera
una lista mutable creando una instancia de ArrayList y luego inicializando esta ArrayList con valores de la
matriz utilizando el método asList. Por tanto, hay que tener en cuenta que como la segunda lista es mutable,
también es posible agregar más valores a ella.
 Ejemplificación
private static boolean buscarNumero(int[] numeros, int numeroaBuscar) {
return Arrays.asList(numeros)
.contains(numeroaBuscar);
}

public static void main(String[] args) {

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

int numerosaBuscar = 4;

if (buscarNumero(numeros,numeroaBuscar))
System.out.println("El número " + numeroaBuscar + " está en la lista");
else
System.out.println("El número " + numeroaBuscar + " NO está en la lista");
}
 Caso #3-Pilas

Una pila es una estructura que nos permite apilar elementos y recopilarlos en
el orden inverso al cual los apilamos mediante operaciones de desapilar. Esto
es lo que se conoce como estructuras LIFO (Last In First Out). De esta manera
una pila suele tener 3 operaciones básicas:

• apilar, añade un elemento a la lista.

• desapilar, retira un elemento de la lista
• ¿está vacía?, comprueba si la lista está vacía.

En el lenguaje Java contamos con la clase Stack en la librería java.util. Es

importante saber que la pila hereda de la pila (aka Vector). Y que por lo tanto
podemos utilizar los elementos del Vector sobre la pila.
 Paso #1-Definir la pila

Lo primero será definir la pila, es decir, instanciar la

clase Stack.

Stack pila = new Stack();

Como vemos el tipo de elementos que insertaremos en la pila

serán String -cadenas-.
 Paso #2-Insertar elementos

Una vez instanciada vamos a ir creando los elementos e insertándolos en

la pila. El método que inserta elementos en la pila es .push(). Este método
recibirá como parámetro el elemento a insertar.

for (int x=1;x<=10;x++)

pila.push(Integer.toString(x));

Hemos creado un bucle que nos vaya creando los números y nos hemos
apoyado en la clase Integer y su método .toString() para convertir los
números en cadena.
 Paso #3-Vaciar la pila

Una vez que tenemos todos los elementos, procedemos al vaciado de la

pila. Tendremos que interactuar sobre la pila hasta que esta esté vacía,
cosa que nos dice el método .empty(). En cada una de las iteraciones
extraeremos un elemento de la pila mediante el método .pop()

while (!pila.empty())
System.out.println(pila.pop());

Pocas líneas de código que nos ayudan a crear una pila en Java.
 Ejemplificación
package tech.morles;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<Manga> pila = new Stack<Manga>();
Libro l0 = new Manga("Título 1", "Mangaka 1");
Libro l1 = new Manga("Título 2", "Mangaka 2");
Libro l2 = new Manga("Título 3", "Mangaka 3");
pila.push(l0); // adiciona un libro a la pila
pila.push(l1);
pila.push(l1);
System.out.println(pila.peek().getTitulo()); // el último elemento adicionado
while (!pila.isEmpty()) { // mostrar pila completa
System.out.println(pila.pop().getTitulo()); // extrae un elemento de la pila
}
}
}
 ¿Cómo es el diseño de arrays, listas y pilas en diferentes lenguajes de
programación?
Caso 1#-PHP
Array Lista Pila

Un array puede ser creado usando el <?php //Crea la pila

constructor del lenguaje array(). Éste toma $ Enma = new Enma();
un cierto número de parejas clave => valor
$ conn = $redis->connect('127.0.1.1', 6378);
como argumentos.
i f ($conn) { $stack = new SplStack();
echo "Conexion exitosa: estas conectado a Enma...</br>";
array( $ command = true;
//Añade elementos
}
clave => valor,
el se {
clave2 => valor2, echo "No se pudo conectar con el servidor de Enma :(";
$stack->push('1');
clave3 => valor3, }
i f ($command) { $stack->push('2');
...
//Creamos un arreglo $stack->push('3');
) $ redis->lpush("lista-sv", "Enma");
$ redis->lpush("lista-sv", "LAN");
La coma después del elemento del array es
opcional y se puede omitir. Esto $ redis->lpush("lista-bd", "WAN"); //Muestra el número de elementos de la pila (3)
normalmente se hace para arrays de una //Asignamos el arreglo a una variable
sola línea, esto es, es preferible array(1, 2) $ listbd = $enma->lrange("lista-bd", 0, 3);
que array(1, 2, ). Por otra parte, para arrays echo $stack->count();
multilínea, la coma final se usa //Ciclo que muestra cada valor del arreglo
comnúnmente, ya que permite la adición foreach ($listbd as $nombre) {
sencilla de nuevos elementos al fin echo "<br>" . $nombre;
//Situa el puntero al final de la cola
}
}

$stack->rewind();
 Caso 2#-JS

Array Lista Pila

//Declaración del array Para crear una lista vacía se puede hacer de las La clase Stack representa a una pila, esta clase tendrá la
siguientes dos formas: propiedad items que representará el conjunto de elementos a
almacenar (en este caso se utiliza un arreglo de elementos,
//Forma 1: corchetes pero puede ser cualquier otro, como por ejemplo un objeto o un
conjunto. Lo importante es encapsular el comportamiento). Al
var nuevoArray = [5,13,19,2,87]; var lista=[]; comenzar, el conjunto de elementos no tendrá ningún
elemento.

//Bucle que recorre todo el array //Forma 2: new Array(); class Stack {
var lista=new Array(); constructor() {
this.items = [];
for(var i=0; i<nuevoArray.length; i++) { }
Sea cual sea la forma que se utilice para crear una lista
document.write(nuevoArray[i]; //Inserción de elementos
(arreglo) es irrelevante.
push(element) {
} this.items.push(element);
//El resultado será: 51319287 }
//Método de elim inación de elementos
pop() {
return this.items.pop();
}
//Método de visualización de elementos
peek() {
return this.items[this.items.length - 1];
}
}
 Caso 3#-C++

Array Lista Pila

//Declaración e inicio de un vector con valores referentes a //Línea de inicialización/creación de la lista //Colocación de librerias y sintaxis inicial
la edad de varias personas
#include <list> #include <iostream>
#include "iostream"
list <string> staff; using namespace std;
using namespace std;

int m ain()
//Añadidura de nodos y determinación del tamaño de la lista //Definición del nodo de partida
{
staff.push_back("Angel"); struct nodo{
int edades[] = {1,3,10,9,15,43,12,47,39,19,4,90};
staff.push_back("Elvis");
//Declaración del límite que alcanzará el vector (tamaño)
staff.push_back("Mari"); //Determinación de la clase de variable
int limite = (sizeof(edades)/sizeof(edades[0]));
staff.push_back("Enma"); int nro;
//Se establece un ciclo for que comienza en 0 y se detiene
en el límite establecido staff.push_back("Sol"); struct nodo *sgte;

for (int i = 0; i < limite; i++) };

{ cout << staff.size() << endl; // 5

//Por último, se accede a los elementos del arreglo typedef nodo * ptrPila;
haciendo un recorrido por cada uno, tomando a "i" como la //Creando nodo tipo puntero( tipo de dato )
variable que cambia con cada ciclo //Remoción de un nodo de la lista

cout<<edades[i]<<endl; staff.pop_back();
cout << staff.size() << endl; //
}

}
 Caso 4#-C#
Array Lista Pila

//Primeramente, se declara el tipo de variable, //Iniciación, asignando valores y definiendo el nombre de la lista Para crear una pila, se emplea la clase Stack. Una pila permitirá introducir un nuevo
elemento en la cima ("apilar", en inglés "push") y quitar el elemento que hay en la cima
posteriormente un valor indefinido de elementos ("desapilar", en inglés "pop").
L ist<string> listadeNombres = new List<string>()
int[] valores; //valores sin inicializar //Inicialización de un menú básico en función de una pila genérica, con ningún valor de
//Inserción de elementos, en este caso, nombres retorno

{ using System;
//Posteriormente, se insertan elementos en el using System.Collections;
arreglo con el operador new seguido del tipo de new N ombre () { N ame = "Gina"},
dato y su valor public class EjemploPila
new N ombre () { N ame = "Yai"},
valores = new int[500]; //500 elementos {
new N ombre () { N ame = "El pepe"},
//Adicionalmente, se puede recorrer los elementos public static void Main()

del array accediendo a ellos mediante un bucle };

{
"for"
//Se añade un bucle de recorrido por los elementos almacenados en el string palabra;
for (int i = 0; i < valores.Length; i++) { listado recien creado, para posteriormente imprimir en pantalla el
resultado según cada ciclo //Creación de una pila nueva, compuesta por 3 elementos en su interior que se "apilan"
Console.WriteLine(valores[i]); con push
for(int i = 0; i < listadeNombres.Count; i++)
Stack Pila = new Stack();
}
} Pila.Push("Buenas,");

Console.WriteLine("Los nombres" listadeNombres[i].Name + " Pila.Push("soy");

son los siguientes");
Pila.Push("Enma");
}
//Recorrido genérico o cíclico según los valores de la pila

Console.ReadKey(); for (byte i=0; i<3; i++)

} {

} //Reposicionamiento de cada elemento luego del ciclo al desapilar y cambiar el orden

palabra = (string) Pila.Pop();

Console.WriteLine( palabra );

}
 Caso 5#-VB.net
Array Lista Pila
//Primeramente, se establecen los parámetros del formato a trabajar según el tipo de Private Sub Form1_Load(sender As Object, e As EventArgs) //Primero, se declara una pila nueva de forma genérica
array y los datos que se manejerán dentro de éste
Handles MyBase.Load siguiendo el patrón sintáctico
P r i vate Sub Form1_Load(sender As Object, e As EventArgs) Handles Mybase.Load
//Declaración de una nueva lista Dim PilaAsNewStack
//Declaración de las dimensiones y el tipo de dato que se ha de manejar en el array
Dim personas As New List(of persona) ()
PrivateSub Button1_Click(ByVal sender AsSystem.Object,
' D i m grupo(4) As Integer
//Añadidura de "objetos" a la lista correspondiendo a una serie de ByVal e AsSystem.EventArgs) Handles BtnGenerar.Click
//Comando usado para redimensionar el array para realizar limpieza de los valores datos
almacenados //En este caso, valor hace referencia a un conjunto de
Dim per1 As New persona() caracteres que van en secuencia (AsString)
' Re Dim gr upo(3 )
pe r1.Nombre = "Mario"
//Items almacenados en el array denominado "grupo" Dim valor AsString = TextBox1.Text
pe r1.Numero = 04146371018
D i m grupo = {0,1,2,3,4} //Creación de iteraciones numéricas que corresponde a las
pe r1.Soltero = False dimensiones designada de la pila
//Asignación de valor a uno de los elementos del array

' g r upo(3) = 12
Dim per2 As New persona() F or i AsInteger = 0 T o valor.Length - 1

//Recorrido en formato de bucle aplicado para el array presente, que mostrará cada valor pe r2.Nombre = "Jonathan" //Se emplean operadores condicionales para representar el
almacenado
pe r2.Numero = 04246181503
comportamiento de cambio según el valor que resulte de las
a:
instrucciones y lo que esté almacenado
pe r2.Soltero = True
f o r i As integer = 0 to 5 - 1 IfIsNumeric (valor (i)) T hen
pe rsonas.Add(per1)
M sg Box("El valor del item" & i & "vale: " gr upo (i)) Pila.Push(valor(i))
pe rsonas.Add(per2)
Ne x t
Else
//Recorrido realizado entre cada elemento (objeto) como un bucle
//Comando de redimensionamiento que se emplea esencialmente para reajustar los definido hasta el último de los objetos
valores del array P ila2.Push(valor(i))
Re D i m Preserve grupo(5) Fo r Each item As persona In personas
EndIf
Go To a MsgBox("la persona: "+item.Nombre+"con el numero:"+
item.Numero.ToString() +"dice que su estado de soltero es: " + N ext
E nd Sub item.Soltero.ToString())
EndSub
E nd Class Ne xt
Su b
MUCHAS GRACIAS!