Breaking

Post Top Ad

Your Ad Spot

sábado, 21 de diciembre de 2019

Java LinkedList

En este tutorial, aprenderemos sobre la clase LinkedList en detalle con la ayuda de muchos ejemplos.
anuncios a través de carbonoMongoDB Atlas es el servicio de base de datos en la nube más confiable disponible. ¡Probar ahora!ANUNCIOS A TRAVÉS DE CARBONO
La LinkedListclase del marco de Java Collections proporciona la funcionalidad de la estructura de datos de la lista vinculada.

Interfaces implementadas por LinkedList

  • Interfaz de lista Java
  • Interfaz de cola de Java
  • Interfaz Java Deque
Interfaces implementadas por la lista vinculada

Implementación de LinkedList en Java

La LinkedListclase Java proporciona una implementación de lista doblemente vinculada.
Nodo en una lista vinculada
Cada elemento en una lista vinculada se conoce como un nodo . Consta de 3 campos:
  • Anterior : almacena una dirección del elemento anterior en la lista. Es nullpara el primer elemento.
  • Siguiente : almacena una dirección del siguiente elemento en la lista. Es nullpara el último elemento.
  • Datos : almacena los datos reales.
Los elementos en las listas vinculadas no se almacenan en secuencia. En cambio, están dispersos y conectados a través de enlaces (Anterior y Siguiente).
Trabajo de LinkedList en Java
Aquí tenemos 3 elementos en una lista vinculada.
  • Perro : es el primer elemento que se mantiene nulo como dirección anterior y la dirección de Gato como dirección siguiente
  • Gato : es el segundo elemento que contiene una dirección de Perro como dirección anterior y una dirección de Vaca como dirección siguiente
  • Vaca : es el último elemento que contiene la dirección de Cat como la dirección anterior y nula como el siguiente elemento

Crear una lista enlazada

Así es como podemos crear listas vinculadas en Java:
  1. LinkedList<Type> linkedList = new LinkedList<>();
Aquí, Tipo indica el tipo de una lista vinculada. Por ejemplo,
  1. // create Integer type linked list
  2. LinkedList<Integer> linkedList = new LinkedList<>();
  3. // create String type linked list
  4. LinkedList<String> linkedList = new LinkedList<>();

Crear una LinkedList usando interfaces

Pongamos un ejemplo.
  1. List<String> animals1 = new LinkedList<>();
Aquí hemos declarado una lista vinculada animals1, utilizando la Listinterfaz. La lista vinculada solo puede acceder a los métodos de la Listinterfaz.
Tomemos un ejemplo más.
  1. Queue<String> animals2 = new LinkedList<>();
  2. Deque<String> animals3 = new LinkedList<>();
Aquí, animals2solo se puede acceder a los métodos de la Queueinterfaz.
Sin embargo, animals3solo puede acceder a los métodos de las interfaces DequeQueueEs porque Dequees una subinterfaz de Queue.

Métodos de LinkedList

LinkedList proporciona varios métodos que nos permiten realizar diferentes operaciones en listas vinculadas.

Agregar elementos a LinkedList

1. Agregar elementos: canta el método add ()
Para agregar un elemento (nodo) al final de la lista vinculada, utilizamos el add()método Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args){
  4. LinkedList<String> animals = new LinkedList<>();
  5. // Add elements to LinkedList
  6. animals.add("Dog");
  7. animals.add("Cat");
  8. animals.add("Horse");
  9. System.out.println("LinkedList: " + animals);
  10. }
  11. }
Salida
LinkedList: [Perro, Gato, Caballo]

2. Agregar elementos: usando un número de índice
También podemos agregar elementos a la lista vinculada mediante índices. Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args){
  4. LinkedList<String> animals = new LinkedList<>();
  5. // Add elements using indexes
  6. animals.add(0,"Dog");
  7. animals.add(1,"Cat");
  8. animals.add(2,"Horse");
  9. System.out.println("LinkedList: " + animals);
  10. }
  11. }
Salida
LinkedList: [Perro, Gato, Caballo]

3. Agregar elementos: una lista vinculada a otra
Para agregar todos los elementos de una lista vinculada a otra lista vinculada, utilizamos el addAll()método. Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args){
  4. LinkedList<String> mammals = new LinkedList<>();
  5. mammals.add("Dog");
  6. mammals.add("Cat");
  7. mammals.add("Horse");
  8. System.out.println("Mammals: " + mammals);
  9. LinkedList<String> animals = new LinkedList<>();
  10. animals.add("Crocodile");
  11. // Add all elements of mammals in animals
  12. animals.addAll(mammals);
  13. System.out.println("Animals: " + animals);
  14. }
  15. }
Salida
Mamíferos: [Perro, Gato, Caballo]
Animales: [cocodrilo, perro, gato, caballo]

4. Agregar elementos: usando el método listIterator ()
También podemos usar el listsIterator()método para agregar elementos a la lista vinculada. Para usarlo, debemos importar el java.util.ListIteratorpaquete. Por ejemplo,
  1. import java.util.ArrayList;
  2. import java.util.ListIterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. ArrayList<String> animals= new ArrayList<>();
  6. // Creating an object of ListIterator
  7. ListIterator<String> listIterate = animals.listIterator();
  8. listIterate.add("Dog");
  9. listIterate.add("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. }
  12. }
Salida
LinkedList: [Perro, Gato]

Acceder a elementos de LinkedList

1. Elementos de acceso: usando el método get ()
Para acceder a un elemento de la lista vinculada, podemos usar el get()método Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in the linked list
  6. animals.add("Dog");
  7. animals.add("Horse");
  8. animals.add("Cat");
  9. System.out.println("LinkedList: " + animals);
  10. // Get the element from the linked list
  11. String str = animals.get(1);
  12. System.out.print("Element at index 1: " + str);
  13. }
  14. }
Salida
LinkedList: [Perro, Caballo, Gato]
Elemento en el índice 1: Caballo

2. Elementos de acceso: utilizando el método iterator ()
Para iterar sobre los elementos de una lista vinculada, podemos usar el iterator()método. Debemos importar el java.util.Iteratorpaquete para usar este método. Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Iterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. LinkedList<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. // Creating an object of Iterator
  11. Iterator<String> iterate = animals.iterator();
  12. System.out.print("LinkedList: ");
  13. while(iterate.hasNext()) {
  14. System.out.print(iterate.next());
  15. System.out.print(", ");
  16. }
  17. }
  18. }
Salida
LinkedList: perro, gato, caballo,
Nota:
  • hasNext()- devuelve truesi hay un elemento siguiente
  • next() - devuelve el siguiente elemento
Para obtener más información Iterator, visite Java Iterator Interface.

3. Elementos de acceso: utilizando el método listIterator ()
También podemos usar el listIterator()método para iterar sobre los elementos de una lista vinculada. Para usar este método, debemos importar el java.util.ListIteratorpaquete.
El listsIterator()método es más preferido en las listas vinculadas. Es porque los objetos de listIterator()pueden iterar hacia atrás también. Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.ListIterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. LinkedList<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. // Create an object of ListIterator
  11. ListIterator<String> listIterate = animals.listIterator();
  12. System.out.print("LinkedList: ");
  13. while(listIterate.hasNext()) {
  14. System.out.print(listIterate.next());
  15. System.out.print(", ");
  16. }
  17. // Iterate backward
  18. System.out.print("\nReverse LinkedList: ");
  19. while(listIterate.hasPrevious()) {
  20. System.out.print(listIterate.previous());
  21. System.out.print(", ");
  22. }
  23. }
  24. }
Salida
LinkedList: perro, caballo, gato,
Reverse LinkedList: Gato, Caballo, Perro,
Nota:
  • hasNext()- devuelve truesi hay un elemento siguiente
  • next() - devuelve el siguiente elemento
  • hasPrevious()- devuelve truesi existen elementos anteriores
  • previous() - devuelve el elemento anterior
Para obtener más información ListIterator, visite la interfaz Java ListIterator.

1. Elemento de búsqueda: utilizando el método contiene ()
Para verificar si una lista vinculada contiene un elemento en particular o no, utilizamos el contains()método. Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in the linked list
  6. animals.add("Dog");
  7. animals.add("Horse");
  8. animals.add("Cat");
  9. System.out.println("LinkedList: " + animals);
  10. // Checks if Dog is in the linked list
  11. if(animals.contains("Dog")) {
  12. System.out.println("Dog is in LinkedList.");
  13. }
  14. }
  15. }
Salida
LinkedList: [Perro, Caballo, Gato]
El perro está en LinkedList.

2. Elemento de búsqueda: utilizando el método indexOf ()
  • indexOf() - devuelve el índice de la primera aparición de un elemento
  • lastIndexOf() - devuelve el índice de la última aparición de un elemento
Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in the linked list
  6. animals.add("Dog");
  7. animals.add("Horse");
  8. animals.add("Cat");
  9. animals.add("Dog");
  10. System.out.println("LinkedList: " + animals);
  11. // First Occurrence of Dog
  12. int index1 = animals.indexOf("Dog");
  13. System.out.println("First Occurrence of Dog: " + index1);
  14. // Last Occurrence of Dog
  15. int index2 = animals.lastIndexOf("Dog");
  16. System.out.println("Last Occurrence of Dog: " + index2);
  17. }
  18. }
Salida
LinkedList: [Perro, Caballo, Gato, Perro]
Primera aparición de perro: 0
Última aparición del perro: 3
Nota: Ambos indexOf()lastIndexOf()devuelve -1si no se encuentra el elemento especificado.

Cambiar elementos de LinkedList

1. Cambiar elemento: usando el método set ()
Para cambiar elementos de una lista vinculada, podemos usar el set()método Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in the linked list
  6. animals.add("Dog");
  7. animals.add("Horse");
  8. animals.add("Cat");
  9. animals.add("Dog");
  10. System.out.println("LinkedList: " + animals);
  11. // Change elements at index 3
  12. animals.set(3, "Zebra");
  13. System.out.println("New LinkedList: " + animals);
  14. }
  15. }
Salida
LinkedList: [Perro, Caballo, Gato, Perro]
Nueva LinkedList: [Perro, Caballo, Gato, Cebra]

2. Cambiar elemento: usando el método listIterator ()
También podemos cambiar los elementos en una lista vinculada usando el listIterator()método Por ejemplo,
  1. import java.util.ArrayList;
  2. import java.util.ListIterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. ArrayList<String> animals= new ArrayList<>();
  6. // Add elements
  7. animals.add("Dog");
  8. animals.add("Cat");
  9. animals.add("Horse");
  10. System.out.println("LinkedList: " + animals);
  11. // Creating an object of ListIterator
  12. ListIterator<String> listIterate = animals.listIterator();
  13. listIterate.next();
  14. // Change element returned by next()
  15. listIterate.set("Cow");
  16. System.out.println("New LinkedList: " + animals);
  17. }
  18. }
Salida
LinkedList: [Perro, Gato, Caballo]
Nueva LinkedList: [Vaca, Gato, Caballo]

Eliminar elementos de LinkedList

1. Eliminar elemento: utilizando el método remove ()
Para eliminar un elemento de la lista vinculada, podemos usar el remove()método Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in LinkedList
  6. animals.add("Dog");
  7. animals.add("Horse");
  8. animals.add("Cat");
  9. animals.add("Zebra");
  10. System.out.println("LinkedList: " + animals);
  11. // Remove elements from index 1
  12. String str = animals.remove(1);
  13. System.out.println("Removed Element: " + str);
  14. System.out.println("New LinkedList: " + animals);
  15. }
  16. }
Salida
LinkedList: [Perro, Caballo, Gato, Cebra]
Elemento eliminado: caballo
Nueva LinkedList: [Perro, Gato, Cebra]

2. Eliminar elemento: usando el método listIterator ()
También podemos eliminar elementos de una lista vinculada mediante el listsIterator()método Por ejemplo,
  1. import java.util.ArrayList;
  2. import java.util.ListIterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. ArrayList<String> animals= new ArrayList<>();
  6. // Add elements
  7. animals.add("Dog");
  8. animals.add("Cat");
  9. animals.add("Horse");
  10. System.out.println("LinkedList: " + animals);
  11. // Creating an object of ListIterator
  12. ListIterator<String> listIterate = animals.listIterator();
  13. listIterate.next();
  14. // Remove element returned by next()
  15. listIterate.remove();
  16. System.out.println("New LinkedList: " + animals);
  17. }
  18. }
Salida
LinkedList: [Perro, Gato, Caballo]
Nueva LinkedList: [Cat, Horse]

3. Eliminar elementos: usando el método clear ()
Para eliminar todos los elementos de una lista vinculada, utilizamos el clear()método Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<String> animals= new LinkedList<>();
  5. // Add elements in LinkedList
  6. animals.add("Dog");
  7. animals.add("Cat");
  8. animals.add("Horse");
  9. System.out.println("LinkedList: " + animals);
  10. // Remove all the elements
  11. animals.clear();
  12. System.out.println("New LinkedList: " + animals);
  13. }
  14. }
Salida
LinkedList: [Perro, Gato, Caballo]
Nueva LinkedList: []
Nota: También podemos usar el removeAll()método para eliminar todos los elementos. Sin embargo, el clear()método se considera más eficiente que el removeAll()método.

4. Eliminar elemento: utilizando el método removeIf ()
También podemos eliminar elementos de una lista vinculada si cumplen una determinada condición. Para esto, usamos el removeIf()método. Por ejemplo,
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. LinkedList<Integer> animals= new LinkedList<>();
  5. // Add elements in LinkedList
  6. animals.add(2);
  7. animals.add(3);
  8. animals.add(4);
  9. animals.add(5);
  10. System.out.println("LinkedList: " + animals);
  11. // Remove all elements less than 4
  12. animals.removeIf((Integer i)->i < 4);
  13. System.out.println("New LinkedList: " + animals);
  14. /** Here we have used the lambda expression
  15. * For now just remember
  16. * parameter inside removeIf() is a condition
  17. */
  18. }
  19. }
Salida
LinkedList: [2, 3, 4, 5]
Nueva LinkedList: [4, 5]
Nota: (Integer i)->i<4 es una expresión lambda. Para obtener información sobre la expresión lambda, visite Java Lambda Expression .

LinkedList como Deque y Queue

Dado que la LinkedListclase también implementa el Queuey la Dequeinterfaz, se puede aplicar métodos de estas interfaces también. Estos son algunos de los métodos más utilizados:

Método addFirst () y addLast ()

  • addFirst() - agrega el elemento especificado al comienzo de la lista vinculada
  • addLast() - agrega el elemento especificado al final de la lista vinculada
Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Deque;
  3. class Main {
  4. public static void main(String[] args){
  5. Deque<String> animals = new LinkedList<>();
  6. // Add element at starting of LinkedList
  7. animals.addFirst("Cow");
  8. animals.addFirst("Dog");
  9. animals.addFirst("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. // Add elements at the end of LinkedList
  12. animals.addLast("Zebra");
  13. System.out.println("New LinkedList: " + animals);
  14. }
  15. }
Salida
LinkedList: [Gato, Perro, Vaca]
Nueva LinkedList: [Cat, Dog, Cow, Zebra]

Método getFirst () y getLast ()

  • getFirst() - devuelve el primer elemento
  • getLast() - devuelve el último elemento
Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Deque;
  3. class Main {
  4. public static void main(String[] args) {
  5. Deque<String> animals= new LinkedList<>();
  6. // Add elements in the linked list
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. // Get the first element from the linked list
  12. String str1 = animals.getFirst();
  13. System.out.println("First Element: " + str1);
  14. // Get the last element from the linked list
  15. String str2 = animals.getLast();
  16. System.out.println("Last Element: " + str2);
  17. }
  18. }
Salida
LinkedList: [Perro, Caballo, Gato]
Primer elemento: perro
Último elemento: gato

Método removeFirst () y removeLast ()

  • removeFirst() - elimina el primer elemento
  • removeLast() - elimina el último elemento
Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Deque;
  3. class Main {
  4. public static void main(String[] args) {
  5. Deque<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. // Remove the first element from LinkedList
  12. String str1 = animals.removeFirst();
  13. System.out.println("Removed Element: " + str1);
  14. // Remove the last element from LinkedList
  15. String str2 = animals.removeLast();
  16. System.out.println("Removed Element: " + str2);
  17. System.out.println("New LinkedList: " + animals);
  18. }
  19. }
Salida
LinkedList: [Perro, Caballo, Gato]
Elemento eliminado: perro
Elemento eliminado: Gato
Nueva LinkedList: [Caballo]

Método peek ()

El peek()método devuelve el primer elemento (encabezado) de la lista vinculada. Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. class Main {
  4. public static void main(String[] args) {
  5. Queue<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. // Access the first element of LinkedList
  12. String str = animals.peek();
  13. System.out.println("Element Accessed: " + str);
  14. System.out.println("New LinkedList: " + animals);
  15. }
  16. }
Salida
LinkedList: [Perro, Caballo, Gato]
Elemento Accedido: Perro
Nueva LinkedList: [Perro, Caballo, Gato]

método poll ()

El poll()método devuelve y elimina el primer elemento de la lista vinculada. Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. class Main {
  4. public static void main(String[] args) {
  5. Queue<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. animals.add("Cat");
  10. System.out.println("LinkedList: " + animals);
  11. // Returns and removes the first element
  12. String str = animals.poll();
  13. System.out.println("Removed Element: " + str);
  14. System.out.println("New LinkedList: " + animals);
  15. }
  16. }
Salida
LinkedList: [Perro, Caballo, Gato]
Elemento eliminado: perro
Nueva LinkedList: [Horse, Cat]

Método de oferta ()

El offer()método agrega el elemento especificado al final de la lista vinculada. Por ejemplo,
  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. class Main {
  4. public static void main(String[] args) {
  5. Queue<String> animals= new LinkedList<>();
  6. // Add elements in LinkedList
  7. animals.add("Dog");
  8. animals.add("Horse");
  9. System.out.println("LinkedList: " + animals);
  10. // Adds element at the end of LinkedList
  11. animals.offer("Cat");
  12. System.out.println("New LinkedList: " + animals);
  13. }
  14. }
Salida
LinkedList: [Perro, Caballo]
Nueva LinkedList: [Perro, Caballo, Gato]

Iterando a través de LinkedList

1. Usando el bucle forEach
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating a linked list
  5. LinkedList<String> animals = new LinkedList<>();
  6. animals.add("Cow");
  7. animals.add("Cat");
  8. animals.add("Dog");
  9. System.out.println("LinkedList: " + animals);
  10. // Using forEach loop
  11. System.out.println("Accessing linked list elements:");
  12. for(String animal: animals) {
  13. System.out.print(animal);
  14. System.out.print(", ");
  15. }
  16. }
  17. }
Salida
LinkedList: [Vaca, Gato, Perro]
Acceso a elementos de lista vinculados:
Vaca, gato, perro,

2. Utilizando for loop
  1. import java.util.LinkedList;
  2. class Main {
  3. public static void main(String[] args) {
  4. // Creating a linked list
  5. LinkedList<String> animals = new LinkedList<>();
  6. animals.add("Cow");
  7. animals.add("Cat");
  8. animals.add("Dog");
  9. System.out.println("LinkedList: " + animals);
  10. // Using for loop
  11. System.out.println("Accessing linked list elements:");
  12. for(int i=0; i < animals.size(); i++) {
  13. System.out.print(animals.get(i));
  14. System.out.print(", ");
  15. }
  16. }
  17. }
Salida
LinkedList: [Vaca, Gato, Perro]
Acceso a elementos de lista vinculados:
Vaca, gato, perro,
En ambos ejemplos, hemos accedido a elementos individuales de una lista vinculada mediante bucles.

3. Usando el método iterator ()
Podemos usar el método iterator () para acceder a elementos de una lista vinculada. Para utilizar este método, debemos importar el java.util.Iteratorpaquete.
  1. import java.util.LinkedList;
  2. import java.util.Iterator;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating a linked list
  6. LinkedList<String> animals = new LinkedList<>();
  7. animals.add("Cow");
  8. animals.add("Cat");
  9. animals.add("Dog");
  10. System.out.println("LinkedList: " + animals);
  11. // Using the iterator() method
  12. System.out.println("LinkedList using the iterator() method:");
  13. Iterator<String> iterate = animals.iterator();
  14. while(iterate.hasNext()) {
  15. System.out.print(iterate.next());
  16. System.out.print(", ");
  17. }
  18. }
  19. }
Salida
LinkedList: [Vaca, Gato, Perro]
LinkedList usando el método iterator ():
Vaca, gato, perro,

LinkedList vs. ArrayList

Ambos LinkedListArrayListimplementa la Listinterfaz del Collectionsmarco. Sin embargo, existe alguna diferencia entre ellos.
Lista enlazadaLista de arreglo
almacena 3 valores ( dirección anterior , datos y siguiente dirección ) en una sola posiciónalmacena un solo valor en una sola posición
proporciona la implementación de la lista doblemente vinculada de Listproporciona una implementación de matriz redimensionable
cada vez que se agrega un elemento prevnextse cambia la direccióncada vez que se agrega un elemento, todos los elementos después de esa posición se desplazan
Para acceder a un elemento, necesitamos iterar desde el principio hasta el elementopuede acceder aleatoriamente a elementos usando índices.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas