Understanding Maps and Double Linked Lists in Java

Map & Diccionarios

Import Statements

import java.security.InvalidParameterException;
import java.util.*;

RedCarreteras Class

public class RedCarreteras { 
    private Map<String, Map<String, Integer>> red;

    //CONSTRUCTORES
    public RedCarreteras() {
        red = new HashMap<>();// Nuevo dicc a 0
    }

    //METODOS
    private void validarTramo(String una, String otra, int distancia) {
        if (una == null || otra == null || una.equals(otra) || distancia < 1)
            throw new InvalidParameterException();
    }

    public Set<String> ciudades() {
        return red.keySet();
    }

    public int nuevoTramo(String una, String otra, int distancia) {
        validarTramo(una, otra, distancia);
        Map<String, Integer> submapa;
        int resultado;
        if (red.containsKey(una)) {
            submapa = red.get(una);
            if (submapa.put(otra, distancia) == null)
                resultado = -1;
            else
                resultado = submapa.put(otra, distancia);
            red.put(una, submapa);
        } else {
            submapa = new HashMap<>();
            submapa.put(otra, distancia);
            red.put(una, submapa);
            resultado = -1;
        }
        if (red.containsKey(otra)) {
            submapa = red.get(otra);
            submapa.put(una, distancia);
            red.put(otra, submapa);
        } else {
            submapa = new HashMap<>();
            submapa.put(una, distancia);
            red.put(otra, submapa);
        }
        return resultado;
    }

    public int existeTramo(String una, String otra) {
        if (!red.containsKey(una) || !red.containsKey(otra))
            return -1;

        Integer aux = red.get(una).get(otra);

        return (aux == null ? -1 : aux);
    }

    public int borraTramo(String una, String otra) {
        int d = existeTramo(una, otra);

        if (d < 0)
            return d;

        red.get(una).remove(otra);
        red.get(otra).remove(una);

        return d;
    }

    public int compruebaCamino(List<String> camino) {
        ListIterator<String> iterator1 = camino.listIterator();
        ListIterator<String> iterator2 = camino.listIterator();
        String origen;
        String destino;
        Map<String, Integer> submapa;
        int total = 0;
        if (camino.size() == 0)
            return -1;
        else if (camino.size() == 1)
            return 0;
        else {
            iterator2.next();
            while (iterator2.hasNext()) {
                origen = iterator1.next();
                destino = iterator2.next();
                if (origen == null || destino == null)
                    return -1;
                if (existeTramo(origen, destino) == -1 && !origen.equals(destino))
                    return -1;
                else if (!origen.equals(destino)){
                    submapa = red.get(origen);
                    total += submapa.get(destino);
                }
            }
        }
        return total;
    }

    public String masProxima (String una) {
        Map<String, Integer> tramos = red.get(una);
        if (tramos == null)
            return null;
        String masCercana = null;
        int distancia = -1;
        Iterator<String> iter= tramos.keySet().iterator();
        while(iter.hasNext()) {
            String ciudad = iter.next();
            if (masCercana == null || (tramos.get(ciudad) < distancia)) {
                distancia = tramos.get(ciudad);
                masCercana = ciudad;
            }
        }
        return masCercana;
    }
}

DoubleLinkedList

Import Statements

import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;

EDHeaderDoubleLinkedList Class

/**
 * Implementación de la interface List<T> usando nodos doblemente enlazados de
 * forma circular y con nodo cabecera.
 *
 * La clase admite nulls como elementos
 */
public class EDHeaderDoubleLinkedList<T> implements List<T> {

    /**
     * Definición de nodo
     */
    private class Node {
        public T data;
        public Node next;
        public Node prev;

        public Node(T element) {
            data = element;
            next = null;
            prev = null;
        }
    }

    // Inicializa nodo cabecera. A él se enlazan el primero y el último
    private Node header;
    private int size;

    //CONTRUCTORES
    //Por defecto
    public EDHeaderDoubleLinkedList() {
        header = new Node(null);
        size = 0;
        header.next = header;
        header.prev = header;
    }

    //Copía todos los elementos de otra clase
    public EDHeaderDoubleLinkedList(Collection<T> c) {
        this();
        addAll(c);
    }

    //Comparador (tiene en cuenta que hay nulls)
    private boolean compareNull(T one, Object item) {
        if (one == null)
            return one == item;
        else
            return one.equals(item);
    }

    //METODOS
    public boolean isEmpty() {
        return header.next == header;
    }

    public void clear() {
        header.next = header.prev = header;
        size = 0;
    }

    private Node findNode(Object item) {
        Node actual = header.next;
        Node encontrado = null;
        while (actual != header) {
            if (compareNull(actual.data, item))
                encontrado = actual;
            actual = actual.next;
        }
        return encontrado;
    }

    //Devuelve el nodo de la lista que ocupa la posición index.
    private Node findIndex(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException();

        Node aux = header;
        if (index < size / 2)
            for (int i = 0; i <= index; i++)
                aux = aux.next;
        else
            for (int i = size; i > index; i--)
                aux = aux.prev;

        return aux;
    }

    public boolean add(T item) {
        insertBefore(header, item);
        return true;
    }

    public void add(int index, T element) {
        insertBefore(findIndex(index), element);
    }

    private Node insertBefore(Node n, T item) {
        Node nuevo = new Node(item);
        size ++;
        nuevo.prev = n.prev;
        nuevo.next = n;
        n.prev.next = nuevo;
        n.prev = nuevo;
        return nuevo;
    }

    private void removeNode(Node n) {
        n.prev.next = n.next;
        n.next.prev = n.prev;
        size --;
    }

    public boolean remove(Object item) {
        if (findNode(item) == null)
            return false;
        else {
            removeNode(findNode(item));
            return true;
        }
    }

    public T remove(int index) {
        if (index == size)
            throw new IndexOutOfBoundsException();

        Node n = findIndex(index);
        removeNode(n);
        return n.data;
    }

    public boolean contains(Object item) {
        return findNode(item) != null;
    }

    public T get(int index) {
        if (index == size)
            throw new IndexOutOfBoundsException();

        Node n = findIndex(index);
        return n.data;
    }

    public T set(int index, T element) {
        if (index == size)
            throw new IndexOutOfBoundsException();

        Node n = findIndex(index);
        T old = n.data;
        n.data = element;
        return old;
    }

    public int indexOf(Object item) {
        Node aux = header.next;
        int i = 0;

        while (aux != header) {
            if (compareNull(aux.data, item))
                return i;
            aux = aux.next;
            i++;
        }

        return -1;
    }

    public int lastIndexOf(Object item) {
        int i = size - 1;
        for (Node actual = header.prev; actual != header; actual = actual.prev) {
            if (compareNull(actual.data, item))
                return i;
            i --;
        }
        return i;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        boolean haCambiado = false;
        for (Node actual = header.next; actual != header; actual = actual.next) {
            if (!c.contains(actual.data)) {
                removeNode(actual);
                haCambiado = true;
            }
        }
        return haCambiado;
    }
}