El estudiante definira qué es un arr

Documente
Realice el código fuente
y ejecute su programa
Donde se encuentra el arreglo está
 studiante definira qué es un arrayObjetos y para que puede servir
cumente
alice el código fuente
ecute su programa
nde se encuentra el arreglo estático
public class Nodo {
    Nodo nodoDer;
    int dato;
    public Nodo(int dato) {
        this.dato = dato;
        this.nodoDer = null;
    }
}
import javax.swing.JOptionPane;

public class ListaS {
    private Nodo primero;
    private Nodo ultimo;
    private int tamano;
    public ListaS() {
        this.primero = null;
        this.ultimo = null;
        this.tamano = 0;
    }
//Metodo utilizado para denotar que la lista
se encuentra vacia.
    public boolean siVacio() {
        return (this.primero == null);
    }

//Metodo para agregar al final de la lista.

    public ListaS addLast(int dato) {
        if(siVacio()) {

            Nodo nuevo = new Nodo(dato);

            primero = nuevo;
            ultimo = nuevo;
            nuevo.nodoDer = nuevo;
        }
        else {

            Nodo nuevo = new Nodo(dato);

            nuevo.nodoDer = null;
            ultimo.nodoDer = nuevo;
            ultimo = nuevo;
        }
        this.tamano++;
        return this;
    }
//Metodo para borrar al final de la lista.

    public Nodo deleteLast() {
        Nodo eliminar = null;
        if(siVacio()) {

            JOptionPane.showMessageDialog(null, "La lista se encuentra vacia");

            return null;
        }
        if(primero == ultimo) {
            primero = null;
            ultimo = null;
        }
        else {
            Nodo actual = primero;
            while(actual.nodoDer !=
ultimo) {

                actual = actual.nodoDer;

            }
            eliminar = actual.nodoDer;
            actual.nodoDer = null;
            ultimo = actual;
        }
        this.tamano--;
        return eliminar;
    }

//Metodo que imprime el tamaño de la lista.

    public void tamano() {

        JOptionPane.showMessageDialog(null, "El tamaño es:\n " + this.tamano);

    }
//Metodo que imprime la lista y los valores
ingresados.
    public void imprimir() {
        if(tamano != 0) {
            Nodo temp = primero;
            String str = "";
            for(int i
= 0; i < this.tamano; i++) {
                str = str +
temp.dato + "\n";
                temp = temp.nodoDer;
            }

            JOptionPane.showMessageDialog(null, str);

        }
    }
}
public class MyClass {
    public static void main(String args[]) {
        System.out.println("Comenzamos");
      listaSimple n1=new listaSimple();
      n1.insertarPrimero(2);
      n1.insertarPrimero(1);
      n1.insertarFinal(3);
      n1.insertarFinal(4);
     
      System.out.println("Listamos desde main");
      n1.listar();
      System.out.println("Borramos un Elemento");
      n1.borrar(2);
      n1.borrar(5);
      System.out.println("volvemos a listar");
      n1.listar();
     
     
    }

}
class Nodo{
    private int elemento;
    private Nodo siguiente;

public Nodo (int elem, Nodo sig){

    elemento = elem;

    siguiente = sig;
}
public int getElemento(){
    return elemento;
}
public Nodo getSig(){

    return siguiente;
}
public void setElemento(int elem){
    elemento = elem;
}
public void setSig(Nodo sig){
    siguiente = sig;
}
   
}

class listaSimple{

    private Nodo primero;

    private int numElem;
public listaSimple(){
    primero = null;
    numElem = 0;
}

public void insertarPrimero (int elemento){

    Nodo nuevo = new Nodo (elemento, primero);

    primero = nuevo;

    numElem++;
}

public void insertarFinal (int elemento){

    Nodo nuevo = new Nodo(elemento, null);
    if (primero == null){
    primero = nuevo;
    }
    else {

        Nodo actual = primero;

        while (actual.getSig()!= null){

            actual = actual.getSig();
           

        }
        actual.setSig(nuevo);
        numElem++;
    }
System.out.println("Final");

}
public void borrar (int elem){
    if (primero == null)
        System.out.println("lista vacía");

    else
        if (primero.getElemento()== elem){
        primero = primero.getSig();
        numElem--;
        }
        else {
            Nodo actual = primero;
            while (actual.getSig()!=null && actual.getSig().getElemento() != elem)
                actual = actual.getSig();
                if (actual.getSig()== null )
                    System.out.println ("elemento "+elem+" no esta en la lista");
                else{
                    actual.setSig(actual.getSig().getSig());
                    numElem--;
                }
        }
}
public void listar(){
   
    Nodo actual = primero;
    while (actual.getSig()!= null){
        System.out.println(actual.getElemento());
        actual = actual.getSig();
   
    }
    System.out.println(actual.getElemento());
}
}
public class Nodo{

private Object dato;

private Nodo nodo;

public Nodo(){
dato = null;
Nodo nodo = null;
}
public Nodo(Object dato){
this();
this.dato = dato;
}
public void setDato(Object dato){
this.dato = dato;
}

public Object getDato(){

return dato;

public void setNodo(Nodo nodo){

this.nodo = nodo;

public Nodo getNodo(){

return nodo;

}
}

public class Lista{

private Nodo cabecera;

private int tamaño;

public Lista(){
tamaño = 0;
cabecera = new Nodo();
}

public int getTamaño(){

 return tamaño;

public boolean addDato(Object dato){

Nodo nodoUltimo = getUltimoNodo();

if(dato != null && nodoUltimo != null){

nodoUltimo.setNodo(new Nodo(dato));
tamaño ++;
return true;
}else{
return false;
}
}

private Nodo getUltimoNodo(){

Nodo nodoUltimo = null;

if(cabecera != null){
nodoUltimo = cabecera;
while(nodoUltimo.getNodo() != null){
nodoUltimo = nodoUltimo.getNodo();
}
}
return nodoUltimo;

public Object getDato(int pos){

Nodo nodoUltimo = null;

int contador = 0;

Object dato = null;

if(cabecera != null){
nodoUltimo = cabecera;
do{

nodoUltimo = nodoUltimo.getNodo();
 if(contador == pos){

dato = nodoUltimo.getDato();
break;

}else{

contador++;
}
}while(nodoUltimo.getNodo() != null);
}
return dato;
}
}

public class Main{

public static void main(String []args){
Lista lista = new Lista();

//Adjuntando datos
lista.addDato("Hola");
lista.addDato("mundo");
lista.addDato("aqui");
lista.addDato("estoy");

System.out.println("-------Imprimiendo datos-------");

for(int i = 0;i < lista.getTamaño();i ++){

System.out.println(lista.getDato(i));
}
}
}
class NodoLista {
Object dato;
NodoLista proximoNodo;

NodoLista( Object objeto )

{
this( objeto, null );
}

NodoLista( Object objeto, NodoLista nodo )

{
dato = objeto;
proximoNodo = nodo;
}

// devuelve el Objeto en este nodo

Object obtenerObjeto()
{
return dato;

// devuelve el proximo nodo

NodoLista obtenerProximo()

{
return proximoNodo;
}

} // fin de clase NodoLista

//clase Lista
public class Lista {
private NodoLista primerNodo;

private NodoLista ultimoNodo;

private String nombre;
// nombre es una cadena tal como "lista" usada en impresion

// construye una Lista vacía con un nombre

public Lista( String cadena )
{
nombre = cadena;
 primerNodo = ultimoNodo = null;
}

public Lista()
{
this( "lista" );
}

// Inserta un Object delante de la Lista. Si la Lista esta vacía,

// primerNodo y ultimoNodo se refieren al mismo objeto.
// De otra manera, primerNodo se refiere al nuevo nodo.
public synchronized void insertarDelante( Object elementoAInsertar )

if ( estaVacio() )
primerNodo = ultimoNodo = new NodoLista( elementoAInsertar );

else
primerNodo = new NodoLista( elementoAInsertar, primerNodo );
}
public synchronized void insertarDetras( Object elementoAInsertar )
{
if ( estaVacio() )

primerNodo = ultimoNodo = new NodoLista( elementoAInsertar );

else
ultimoNodo = ultimoNodo.proximoNodo =

new NodoLista( elementoAInsertar );

}

// remueve el primer nodo de la Lista

public synchronized Object removerDeDelante()

throws ExcepcionListaVacia
{
Object elementoARemover = null;

// lanza una excepción si la Lista esta vacía

if ( estaVacio() )
throw new ExcepcionListaVacia( nombre );

// recupera el dato a ser removido

elementoARemover = primerNodo.dato;

// reinicializa las referencias al primerNodo and ultimoNodo

if ( primerNodo == ultimoNodo )
primerNodo = ultimoNodo = null;

else
primerNodo = primerNodo.proximoNodo;

// devuelve el dato del nodo removido

return elementoARemover;
}

// Remueve el último nodo de la Lista

public synchronized Object removerDeDetras()
throws ExcepcionListaVacia
{
Object elementoARemover = null;

// lanza una excepción si la Lista esta vacía

if ( estaVacio() )
throw new ExcepcionListaVacia( nombre );

// recupera el dato del que esta siendo removido

elementoARemover = ultimoNodo.dato;

// reinicializa las referencias del primerNodo and ultimoNodo

if ( primerNodo == ultimoNodo )
primerNodo = ultimoNodo = null;

else {

// localiza el nuevo último nodo

NodoLista actual = primerNodo;
 // bucle mientras el nodo actual no se refiere
// a ultimoNodo
while ( actual.proximoNodo != ultimoNodo )
actual = actual.proximoNodo;

// actual es el nuevo ultimoNodo

ultimoNodo = actual;
actual.proximoNodo = null;
}

// devuelve el dato del nodo removido

return elementoARemover;
}

// retorna true si la Lista esta vacía

public synchronized boolean estaVacio()
{
return primerNodo == null;
}

// salida de los contenidos de Lista

public synchronized void print()
{
if ( estaVacio() ) {
System.out.println( "Vacio " + nombre );
return;
}

System.out.print( "La lista " + nombre + " es: " );

NodoLista actual = primerNodo;

// mientras no es el final de la lista, se muestra

// el dato del nodo actual
while ( actual != null ) {
System.out.print( actual.dato.toString() + " " );
actual = actual.proximoNodo;
}

System.out.println( "\n" );
}

} // fin de la clase Lista

// Definición de la clase ExcepcionListaVacia
public class ExcepcionListaVacia extends RuntimeException {

// inicializa an ExcepcionListaVacia
public ExcepcionListaVacia( String nombre )
{
super( "La lista " + nombre + " esta vacía" );
}

} // fin de la clase ExcepcionListaVacia

class PruebaListaSimplementeEnlazada {

public static void main(String[] args)

{
Lista miLista=new Lista();
String s1=new String("UCCI");
miLista.insertarDelante(s1);
miLista.print();
Double d1=new Double(23.78);
miLista.insertarDelante(d1);
miLista.print();
Character c1=new Character('a');
miLista.insertarDetras(c1);
miLista.print();

Object elementoRemovido=miLista.removerDeDelante();
System.out.println("Removido: "+elementoRemovido);
miLista.print();

elementoRemovido=miLista.removerDeDetras();
System.out.println("Removido: "+elementoRemovido);
miLista.print();

}
}
 esta vacía,

entoAInsertar )

toAInsertar );

primerNodo );

ntoAInsertar )

toAInsertar );
ultimoNodo

ultimoNodo