Java tutorials arraylist

20.06.2019
0
43
Java Tutorial: ArrayList - 2018

On Java - ArrayList - 2018

Duke 512Bookmark and Share


bogotobogo.com site search:

ArrayList

Three implementation of the List interface are provided in the java.util package: ArrayList, LinkedList, and Vector.
In this chapter we'll deal with ArrayList which is one of the most commonly used of all the classes in the Collections.

ArrayList vs. Array

Some of the advantages of ArrayList over arrays are:

It can grow dynamically. It provides more powerful insertion and search mechanisms that arrays.
ArrayList array
ArrayList myList =
new ArrayList();
or
List myList =
new ArrayList();
String [] myList =
new String[3]; 
String s1 = 
new String("Donald Knuth");
String s2 = 
new String("Edsger Dijkstra");
String s3 = 
new String("Alan Turing");
String s1 = 
new String("Donald Knuth");
String s2 = 
new String("Edsger Dijkstra");
String s3 = 
new String("Alan Turing");
myList.add(s1); 
myList.add(s2); 
myList.add(s3); 
myList[0] = s1;
myList[1] = s2;
myList[2] = s2;
int szList = myList.size();
int szList = myList.length;
Object o = myList.get(2);
String o = myList[2];
myList.remove(2);
myList[2] = null;
boolean isIn = myList.contain(s3);
boolean isIn = false;
for (String item : myList) {
  if(s3.equals(item)) {
    isIn = true;
    break;
  }
}

Let's look at the table in detail.

A plain old array has to know its size at the time it's created.
	new String[3]
	
But for ArrayList, we just make an object of type ArrayList. It can grow dynamically.
	new ArrayList()
	
To put an object in a regular array, we must assign it to a specific location.
	myList[2] = s3;
	
With ArrayList, we can specify an index using the add(int, Object) method, or we can just add(Object) and the ArrayList will keep growing.
	myList.add(s3);
	
Arrays use array syntax that's not used anywhere else in Java.
But ArrayList are plain old Java objects, so they have no special syntax.
	myList[2]
	
ArrayLists are parameterized
	ArrayList
	
The in angle bracket is a "type parameter" as opposed to ArrayList which means, "a list of Animals".

Samples of Array & ArrayList

Here is an array example: how to create and to pass into a method:

import java.util.*;

public class test {
	public static void main(String[] args) {
		System.out.println("Binary search");
		(new test()).go();
	}
	
	public void go() {
		int[] array = new int[]{0,1,2,3,4,5,6,7,8,9};
		int x = BinarySearch(array, 4);
	        if(x == -1)	
	    	    System.out.println(x+" is not in the array!");
	        else
	    	    System.out.println(x+" is at " + x);				
	}
	
	public int BinarySearch(int[] a, int n) {
		int upper = a.length - 1;
		int lower = 0;
		int mid = 0;
		
		while(lower <= upper) {
			mid = (upper + lower)/2;
			if(n < a[mid])
				upper = mid - 1;
			else if(n > a[mid])
				lower = mid + 1;
			else 
				return mid;
		}
		return -1;
	}
}

Output:

Binary search
4 is at 4

The following code is a slightly modified version using ArrayList instead of the simple integer array. I made some changes to the code: two classes instead of just one.

// test.java

package com.bogo;

import java.util.ArrayList;

public class test {
	public static void main(String[] args) {
		System.out.println("Binary search");
		(new test()).go();
	}
	
	public void go() {
		ArrayList array = new ArrayList();
		for(int i = 0; i < 10; i++) {
			array.add(i);
		}
		Algorithms al = new Algorithms();
		int x = al.BinarySearchArrayList(array, 4);
	        if(x == -1)	
	    	    System.out.println(x+" is not in the array!");
	        else
	    	    System.out.println(x+" is at " + x);		
		
	}
}

// Algorithms.java

package com.bogo;

import java.util.ArrayList;

public class Algorithms {
	
	public int BinarySearch(int[] a, int n) {
		int upper = a.length - 1;
		int lower = 0;
		int mid = 0;
		
		while(lower <= upper) {
			mid = (upper + lower)/2;
			if(n < a[mid])
				upper = mid - 1;
			else if(n > a[mid])
				lower = mid + 1;
			else 
				return mid;
		}
		return -1;
	}
	
	public int BinarySearchArrayList(ArrayList a, int n) {
		int upper = a.size() - 1;
		int lower = 0;
		int mid = 0;
		
		while(lower <= upper) {
			mid = (upper + lower)/2;
			if(n get(mid))
				upper = mid - 1;
			else if(n > a.get(mid))
				lower = mid + 1;
			else 
				return mid;
		}
		return -1;
	}
}


Sorting ArrayList of Strings

We're going to do a simple sorting for the ArrayList of Strings. But we'll use a utility from java.util.Collections class not from the ArrayList's method, sort().

import java.util.*;
public class StringArrayList {
	public static void main(String[] args) {
		ArrayList Universities =
			new ArrayList();
		Universities.add("Carnegie Mellon");
		Universities.add("MIT");
		Universities.add("UC Berkeley");
		Universities.add("Stanford");
		Universities.add("Cornell");
		Universities.add("Illinois-Urbana-Champaign");
		System.out.println("--Unsorted--");
		for(String s: Universities) {
			System.out.println(s);
		}
		System.out.println("\n--Sorted--");
		Collections.sort(Universities);
		for(String s: Universities) {
			System.out.println(s);
		}
	}
}

Output from the run is:

--Unsorted--
Carnegie Mellon
MIT
UC Berkeley
Stanford
Cornell
Illinois-Urbana-Champaign

--Sorted--
Carnegie Mellon
Cornell
Illinois-Urbana-Champaign
MIT
Stanford
UC Berkeley

Sorting ArrayList of Objects

import java.util.*;
import java.io.*;

class University {
	// Three instance variables for the University attribute in the file.
	String name;
	String city;
	String state;
	// The variables are all set in the constructor
	// when the University is created
	University (String n, String c, String s) {
		name = n;
		city = c;
		state = s;
	}
	public String getName() {
		return name;
	}
	public String getCity() {
		return city;
	}
	public String getState() {
		return state;
	}
	// Override toString(), because when we do a
	// System.out.println(aUniversityObject), we want to
	// see the name of the University. When we do a 
	// System.out.println(aListOfUniversities), it calls
	// the toString() method of each element in the list.
	public String toString() {
		return name;
	}
}

public class UnivArrayList {
	// ArrayList of University object 
	// instead of String.
	ArrayList uList =
		new ArrayList();
	
	public static void main(String[] args) {
		new UnivArrayList().go();
	}
	
	public void go(){
		getUniversities();
		System.out.println(uList);
		Collections.sort(uList);
		System.out.println(uList);
	}
	void getUniversities(){
		try {
			File file = new File("UnivList.txt");
			BufferedReader r = 
				new BufferedReader(new FileReader(file));
			String line = null;
			while ( !((line = r.readLine()).isEmpty()) ){
				addUniversity(line);
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	void addUniversity(String lineToParse) {
		String[] s = lineToParse.split("/");
		// Create a new University object using the three strings. 
		// Then add the University to the list.
		University nextUniv = new University(s[0],s[1],s[2]);
		uList.add(nextUniv);
	}
}

Input file, UnivList.txt is:

Carnegie Mellon University /Pittsburgh/ PA
Massachusetts Institute of Technology /Cambridge/MA
University of California-Berkeley /Berkeley/ CA
Cornell University /Ithaca,/NY
University of Illinois-Urbana-Champaign /Urbana/ IL
University of Washington /Seattle/WA
Princeton University /Princeton/NJ

The University list file holds three attributes instead of just one. And we want all of them in our list, so we need to make a University class with instance variables for all three University attributes.

But the code won't compile. Instead we'll get the following message:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Bound mismatch: The generic method sort(List) of type Collections is not 
	applicable for the arguments (ArrayList). 
	The inferred type University is not a valid substitute for 
	the bounded parameter >

	at UnivArrayList.go(UnivArrayList.java:47)
	at UnivArrayList.main(UnivArrayList.java:41)

And we may get additional information as well though it's telling the same thing:

Bound mismatch: 
	The generic method sort(List) of type Collections is not
	applicable for the arguments (ArrayList). 
	The inferred type University is not a valid substitute 
	for the bounded parameter >

We know for sure that the Collections class has a sort() method and we used it in the previous section. We sorted successfully the ArrayList of Strings but not with this ArrayList of University Objects!

The error message says there is a mismatch between sort(List) and (ArrayList). And it gives us some keyword that can be a clue to our problem. The keyword is Comparable as in "parameter >"

Comparable Interface

Actually, String implements Comparable, and that's the reason why we could sort a list of Strings using Collections.sort() method. But our University object did nothing related to the Comparable interface, and probably that's why we failed in sorting.

The Comparable Interface is used by the Collections.sort() method to sort List and it is also used by java.util.Arrays.sort() method to sort array of objects.

So, how we implement Comparable?
To implement Comparable, a class must implement a method, compareTo().

We are fortunate because the Comparable interface is really simple, with only one method to implement:

public interface Comparable {
	int CompareTo(T o);
We invoke it as the following:
int n = thisObj.compareTo(anotherObj);

It returns:

n: positive
thisObj > anotherObj n: zero
thisObj = anotherObj n: negative
thisObj

It looks like the will be called on one University object, passing that University a compareTo() method reference to a different University.

The sort() method is using compareTo() to find out the way how it should sort things. Because we have to implement compareTo() for our classes, we can set our own criteria to sort instances of our classes.

In other words, our big job now is to decide what makes one University greater than another; and then implement the compareTo() method to reflect that.

The modified version for the University class:

import java.util.*;
import java.io.*;

class University implements ComparableUniversity>{
	String name;
	String city;
	String state;
	University (String n, String c, String s) {
		name = n;
		city = c;
		state = s;
	}
	public String getName() {
			return name;
	}
	public String getCity() {
			return city;
	}
	public String getState() {
			return state;
	}
	public String toString() {
		return name + " " + city + " " + state + "\n";
	}
	public int compareTo(University u) {
		return name.compareTo(u.getName());
	}
}

public class UnivArrayList {
	// ArrayList of University object 
	// instead of String.
	ArrayList uList =
		new ArrayList();
	
	public static void main(String[] args) {
		new UnivArrayList().go();
	}
	
	public void go(){
		getUniversities();
		System.out.println(uList);
		Collections.sort(uList);
		System.out.println(uList);
	}
	void getUniversities(){
		try {
			File file = new File("UnivList.txt");
			BufferedReader r = 
				new BufferedReader(new FileReader(file));
			String line = null;
			while ( !((line = r.readLine()).isEmpty()) ){
				addUniversity(line);
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	void addUniversity(String lineToParse) {
		String[] s = lineToParse.split("/");
		// Create a new University object using the three strings. 
		// Then add the University to the list.
		University nextUniv = new University(s[0],s[1],s[2]);
		uList.add(nextUniv); 
	}
}

The new output we got:

[Carnegie Mellon University  Pittsburgh  PA
, Massachusetts Institute of Technology  Cambridge MA
, Stanford University  Stanford  CA
, University of California-Berkeley  Berkeley  CA
, Cornell University  Ithaca NY
, University of Illinois-Urbana-Champaign  Urbana  IL
, University of Washington  Seattle WA
, Princeton University  Princeton NJ
, University of Texas-Austin  Austin  TX
, Georgia Institute of Technology  Atlanta GA
]
[Carnegie Mellon University  Pittsburgh  PA
, Cornell University  Ithaca NY
, Georgia Institute of Technology  Atlanta GA
, Massachusetts Institute of Technology  Cambridge MA
, Princeton University  Princeton NJ
, Stanford University  Stanford  CA
, University of California-Berkeley  Berkeley  CA
, University of Illinois-Urbana-Champaign  Urbana  IL
, University of Texas-Austin  Austin  TX
, University of Washington  Seattle WA
]

It worked!
It prints the list, then calls sort which puts the University in alphabetical order by name.

Let's summarize what we've been through.
We were able to pass the ArrayList to the sort() only after the University class implemented Comparable since that's the way sort().

Let's look at the declaration of sort() method in detail. In the api for java.util.Collections:

public static T extends Comparable> void sort(ListT

T extends Comparable
This says "Whatever T is must be of type Comparable."
Comparable is an interface, so this reads,"T must be implements the Comparable interface.
It doesn't matter whether the Comparable is a class or interface... we still say extends because in generics, extends means extends or implements.
It just mean that the type parameter for Comparable must be of type T or one of T's supertypes. List
We can pass in only a List (or subtype of list, like ArrayList) that uses a parameterized type that extends Comparable

Comparator

There's new problem: If we want two different list of the University list, one by the name and one by the state!

However, when we make a collection element comparable by having it implement Comparable, we get only one chance to implement the compareTo() method. So what we can do about it?

Let's look at the Collections class API again!
There's a second sort() method. It takes a Comparator.

sort(List list, Comparatorc)

This method is an overloaded version of sort() that takes both a list and something called a Comparator. The Comparator interface gives us:

The capability to sort a given collection any number of different ways. We can use it to sort instances of any class-even classes we can't modify-unlike the Comparable interface, which forces us to change the class whose instances we want to sort. The interface is very easy to implement, having only one method, compare().
public interface Comparator {
	int compare(T o1, T o2);
}

Which one?
sort(List o) or sort(List o, Comparator c)?

Invoking the one-argument sort(List o)
This means the list element's compareTo() method determines the order. So the elements in the list MUST implement the Comparable interface.
Invoking the sort(List o, Comparator c)
This means the list element's compareTo() method will NOT be called, and the Comparator's compare() method will be used instead. That means the elements in the list do NOT need to implement the Comparable interface.

Here is a new code uses Comparator.

import java.util.*;
import java.io.*;

class University implements Comparable{
	String name;
	String city;
	String state;
	University (String n, String c, String s) {
		name = n;
		city = c;
		state = s;
	}
	public String getName() {
			return name;
	}
	public String getCity() {
			return city;
	}
	public String getState() {
			return state;
	}
	public String toString() {
		return name + " " + city + " " + state + "\n";
	}
	public int compareTo(University u) {
		return name.compareTo(u.getName());
	}
}

public class UnivArrayList2 {
	ArrayList uList =
		new ArrayList();
	
	public static void main(String[] args) {
		new UnivArrayList2().go();
	}
	
	// Create a new inner class that implements Comparator
	// (note that its type parameter matches the type we're
	// going to compare - in this case University objects)
	class StateCompare implements Comparator {
		// We're letting the String variables(for state) 
		// do that actual comparison, since Strings already
		// know how to alphabetize themselves.
		public int compare(University one, University two) {
			return one.getState().compareTo(two.getState());
		}
	}
	
	public void go(){
		getUniversities();
		System.out.println(uList);
		Collections.sort(uList);
		// Invoke sort(), passing it the list and 
		// a reference to the new custom Comparator object.
		StateCompare stateCompare =
			new StateCompare();
		Collections.sort(uList, stateCompare);
		System.out.println(uList);
	}
	void getUniversities(){
		try {
			File file = new File("UnivList.txt");
			BufferedReader r = 
				new BufferedReader(new FileReader(file));
			String line = null;
			while ( !((line = r.readLine()).isEmpty()) ){
				addUniversity(line);
			}
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	void addUniversity(String lineToParse) {
		String[] s = lineToParse.split("/");
		// Create a new University object using the three strings. 
		// Then add the University to the list.
		University nextUniv = new University(s[0],s[1],s[2]);
		uList.add(nextUniv); 
	}
}

What we did in the code:

Created an inner class that implements Comparator (and thus compare() method that does the work previously done by compareTo()). Made an instance of the Comparator inner class. Called the overloaded sort() method, giving it both the University list and the instance of the Comparator inner class.

The output is sorted by the name of the state:

[Carnegie Mellon University  Pittsburgh  PA
, Massachusetts Institute of Technology  Cambridge MA
, Stanford University  Stanford  CA
, University of California-Berkeley  Berkeley  CA
, Cornell University  Ithaca NY
, University of Illinois-Urbana-Champaign  Urbana  IL
, University of Washington  Seattle WA
, Princeton University  Princeton NJ
, University of Texas-Austin  Austin  TX
, Georgia Institute of Technology  Atlanta GA
]
[Stanford University  Stanford  CA
, University of California-Berkeley  Berkeley  CA
, University of Illinois-Urbana-Champaign  Urbana  IL
, Carnegie Mellon University  Pittsburgh  PA
, University of Texas-Austin  Austin  TX
, Georgia Institute of Technology  Atlanta GA
, Massachusetts Institute of Technology  Cambridge MA
, Princeton University  Princeton NJ
, Cornell University  Ithaca NY
, University of Washington  Seattle WA
]

Comparable vs. Comparator


java.lang.Comparable java.util.Comparator
int objOne.compareTo(objTwo)
int compare(objOne, objTwo) 
We must modify the class whose instances we want to sort. We build a class separate from the class whose instances we want to sort. Only one sort sequence can be created. Many sort sequence can be created. Implemented frequently in the API by: String, Wrapper classes, Date, Calendar... Meant to be implemented to sort instances of third-party classes.
java tutorials arraylist
ArrayList (Java Platform SE 7 )
Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. (This class is roughly equivalent to Vector, except that it is unsynchronized.)

The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.

Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.

An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.

Note that this implementation is not synchronized. If multiple threads access an ArrayList instance concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more elements, or explicitly resizes the backing array; merely setting the value of an element is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the list. If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method. This is best done at creation time, to prevent accidental unsynchronized access to the list:

   List list = Collections.synchronizedList(new ArrayList(...));

The iterators returned by this class's iterator and listIterator methods are fail-fast: if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs.

This class is a member of the Java Collections Framework.



How to use Java ArrayList: Tutorial with Example

What is ArrayList in Java?

ArrayList is a data structure that can be stretched to accommodate additional elements within itself and shrink back to a smaller size when elements are removed. It is a very important data structure useful in handling the dynamic behavior of elements.

Wondering how ArrayList java could be useful, see the below conversation -

How to use Java Arraylist

See the following picture of a man stretching an elastic rubber band.

The actual length of the rubber band is much smaller, but when stretched it can extend a lot more than its actual length and can be used to hold/bind much larger objects with it.

Now, consider the next picture, that of a simple rope, it cannot stretch and will have a fixed length.

How to use Java Arraylist

It can grow as, and when required to accommodate the elements it needs to store and when elements are removed, it can shrink back to a smaller size.

So as our friend has an issue with the array he is using cannot be expanded or made to shrink, we will be using ArrayList.

Arrays are like the rope shown in the above picture; they will have a fixed length, cannot be expanded nor reduced from the original length.

So our stretchable rubber-band is much like the Array List whereas the rope can be considered as the array.

Technically speaking, java Array List is like a dynamic array or a variable-length array.

Let us see and understand the following code snippet that will help you work around with Array List.

ArrayList a = new ArrayList();

ArrayList Methods

  • ArrayList add: This is used to add elements to the Array List. If an ArrayList already contains elements, the new element gets added after the last element unless the index is specified.

    Syntax:

    add(Object o); 
  • ArrayList remove: The specified element is removed from the list and the size is reduced accordingly. Alternately, you can also specify the index of the element to be removed.

    Syntax:

    remove(Object o);
  • Java array size:  This will give you the number of elements in the Array List. Just like arrays, here too the first element starts with index 0.

    Syntax:

    int size();
  • ArrayList contains:  This method will return true if the list contains the specified element.

    Syntax:

    boolean contains(Object o);

Java ArrayList Example

import java.util.ArrayList;
class Test_ArrayList {
 public static void main(String[] args) {
  //Creating a generic ArrayList
  ArrayList arlTest = new ArrayList();
  //Size of arrayList
  System.out.println("Size of ArrayList at creation: " + arlTest.size());
  //Lets add some elements to it
  arlTest.add("D");
  arlTest.add("U");
  arlTest.add("K");
  arlTest.add("E");

  //Recheck the size after adding elements
  System.out.println("Size of ArrayList after adding elements: " + arlTest.size());

  //Display all contents of ArrayList
  System.out.println("List of all elements: " + arlTest);

  //Remove some elements from the list
  arlTest.remove("D");
  System.out.println("See contents after removing one element: " + arlTest);

  //Remove element by index
  arlTest.remove(2);
  System.out.println("See contents after removing element by index: " + arlTest);

  //Check size after removing elements
  System.out.println("Size of arrayList after removing elements: " + arlTest.size());
  System.out.println("List of all elements after removing elements: " + arlTest);

  //Check if the list contains "K"
  System.out.println(arlTest.contains("K"));

 }
}

Output:

Size of ArrayList at creation: 0
Size of ArrayList after adding elements: 4
List of all elements: [D, U, K, E]
See contents after removing one element: [U, K, E]
See contents after removing element by index: [U, K]
Size of arrayList after removing elements: 2
List of all elements after removing elements: [U, K]
true

Note: For simplicity, the elements shown in above code are single character elements. We can add Strings, integers, etc. too.

How to use Java Arraylist

 

Did you like the video? Like or tell your friends!
Tags:
Comments
Add a comment
Related videos:
20.06.2019
Jump to navigation Jump to search Lindsay LohanLohan in January 2019BornLindsay Dee LohanJuly 2, 1986New York City, U.S.OccupationActressbusinesswomanproducersingerfashion
20.06.2019
Jump to navigation Jump to search Tori SpellingSpelling at Ultimate Women's Expo in 2018BornVictoria Davey SpellingMay 16, 1973Los Angeles
20.06.2019
Celebs with rosacea even model turned actress Cameron Diaz has rosacea with flare ups and super sensitive skin“Whenever I
20.06.2019
Splash PoolShallow, warm instructional pool25 meters x 25 yardsAverage temperature of 84 to 86 degrees FDepth ranges from 2.5
20.06.2019
I am writing an app that allows users to modify and change some of their site settings. I am just
19.06.2019
1187sharesThis DIY Rustic Christmas Sign, complete with a cozy glow of Christmas lights and a verse from “O Holy Night
19.06.2019
Married1038116 Who is he dating right now? RelationshipsSylvester Stallone was previously married to Brigitte Nielsen (1985 - 1987) and Sasha Czack
19.06.2019
Producer | ActorBorn - February 18, 1954 in Englewood, New Jersey, USA Check out what your favourite celebrity John Travolta is up
19.06.2019
Jump to navigation Jump to search "Crazy Beautiful Life" redirects here. For Kesha's autobiography, see My Crazy Beautiful Life
19.06.2019
The hottest thing in music right now is a 72-year-old Pentecostal preacher from the South Side of Chicago
19.06.2019
Mariachi bands are rooted in Mexican culture. Traditional mariachi bands consisted of two or more members playing stringed instruments, wearing
18.06.2019
Jump to navigation Jump to search Lance BassBass in Beverly Hills, California on March 16, 2014BornJames Lance Bass[1]May
18.06.2019
Donald Trump once referred to Mac Miller as “the new Eminem,” cited the success of one of Miller’s songs
18.06.2019
Кристина Мария Агилера (англ. Christina Maria Aguilera; родилась 18 декабря 1980, Нью-Йорк) — американская певица, автор песен, танцовщица, актриса, продюсер
18.06.2019
Who Is Liam Neeson?Born in Northern Ireland in 1952, Liam Neeson began pursuing an acting career in the mid
18.06.2019
15.06.2019
Enter your search keywordAdvancedEnter your search keywordAdvancedJump to navigation Jump to search Janet Jackson's Rhythm Nation 1814Studio album by
15.06.2019
Caitlin GerardCaitlin Gerard Nude Photos And Video Leaked“American Crime” and “The Last Ship” star Caitlin Gerard appears to have
select background