Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Learn how to create lists of data in Java.

Learn Java: Arrays

When we write `main()` methods for our programs, we use the parameter `String[] args`. Now that we know about array syntax, we can start to parse what this means.


A `String[]` is an array made up of `String`s. Examples of `String` arrays:

```java
String[] humans = {"Talesha", "Gareth", "Cassie", "Alex"};
String[] robots = {"R2D2", "Marvin", "Bender", "Ava"};
```

The `args` parameter is another example of a `String` array. In this case, the array `args` contains the arguments that we pass in from the terminal when we run the class file. (So far, `args` has been empty.)

So how can you pass arguments to `main()`? Let's say we have this class `HelloYou`:

```java
public class HelloYou {
  public static void main(String[] args) {
    System.out.println("Hello " + args[0]);  
  }
}
```

When we run the file `HelloYou` in the terminal with an argument of `"Laura"`:
```
java HelloYou Laura
```
We get the output:
```
Hello Laura
```

The `String[] args` would be interpreted as an array with one element, `"Laura"`.

When we use `args[0]` in the main method, we can access that element like we did in `HelloYou`.



String[] args

We have seen how to store single pieces of data in variables. What happens when we need to store a group of data? What if we have a list of students in a classroom? Or a ranking of the top 10 horses finishing a horse race?

If we were storing 5 lottery ticket numbers, for example, we could create a different variable for each value:

```java
int firstNumber = 4;
int secondNumber = 8;
int thirdNumber = 15;
int fourthNumber = 16;
int fifthNumber = 23;
```

That is a lot of ungainly repeated code. What if we had a hundred lottery numbers? It is more clean and convenient to use a Java [_array_](https://www.codecademy.com/resources/docs/java/arrays?page_ref=catalog) to store the data as a list.

An array holds a fixed number of values of one type. Arrays hold `double`s, `int`s, `boolean`s, or any other primitives. Arrays can also contain `String`s as well as object references!

Each index of an array corresponds with a different value. Here is a diagram of an array filled with integer values:

<img src="https://content.codecademy.com/courses/learn-java/revised-2019/array-introduction.png" alt="A diagram of an example int array" with="100%"/>

<br>Notice that the indexes start at 0! The element at index 0 is `4`, while the element at index 1 is `8`. This array has a length of 5, since it holds five elements, but the highest index of the array is 4.

Let's explore how to create and use arrays in Java, so that we can store all of our Java data types.

Introduction

What if we have an array storing all the usernames for our program, and we want to quickly see how many users we have? To get the length of an array, we can access the `length` field of the array object:

```java
String[] menuItems = new String[5];
System.out.println(menuItems.length);
```

This command would print `5`, since the `menuItems` array has `5` slots, even though they are all empty.

If we print out the length of the `prices` array:
```java
double[] prices = {13.1, 15.87, 14.22, 16.66};

System.out.println(prices.length);
```

We would see `4`, since there are four items in the `prices` array!


Length

When we printed out the array we created in the last exercise, we saw a memory address that did not help us understand what was contained in the array.

If we want to have a more descriptive printout of the array itself, we need a `toString()` method that is provided by the `Arrays` _package_ in Java. 

```java
import java.util.Arrays;
```

We put this at the top of the file, before we even define the class!

When we import a package in Java, we are making all of the methods of that package available in our code.

The `Arrays` package has many useful methods, including `Arrays.toString()`. When we pass an array into `Arrays.toString()`, we can see the contents of the array printed out:

```java
import java.util.Arrays;

public class Lottery(){
  
  public static void main(String[] args){
    int[] lotteryNumbers = {4, 8, 15, 16, 23, 42};
    String betterPrintout = Arrays.toString(lotteryNumbers);
    System.out.println(betterPrintout);
  }

}
```

This code will print:

```
[4, 8, 15, 16, 23, 42]
```

Importing Arrays

We can also create empty arrays and then fill the items one by one. Empty arrays have to be initialized with a fixed size:

```java
String[] menuItems = new String[5];
```

Once you declare this size, it cannot be changed! This array will always be of size `5`.

After declaring and initializing, we can set each index of the array to be a different item:

```java
menuItems[0] = "Veggie hot dog";
menuItems[1] = "Potato salad";
menuItems[2] = "Cornbread";
menuItems[3] = "Roasted broccoli";
menuItems[4] = "Coffee ice cream";
```

This group of commands has the same effect as assigning the entire array at once:

```java
String[] menuItems = {"Veggie hot dog", "Potato salad", "Cornbread", "Roasted broccoli", "Coffee ice cream"};
``` 

We can also change an item after it has been assigned! Let's say this restaurant is changing its broccoli dish to a cauliflower one:

```java
menuItems[3] = "Baked cauliflower";
```

Now, the array looks like:

```
["Veggie hot dog", "Potato salad", "Cornbread", "Baked cauliflower", "Coffee ice cream"]
```
**Keep Reading: AP Computer Science A Students**

When we use `new` to create an empty array, each element of the array is initialized with a specific value depending on what type the element is:

Data Type | Initialized Value
--- | ---
int | `0`
double | `0.0`
boolean | `false`
Reference | `null`

For example, consider the following arrays:

```java
String[] my_names = new String[5];
int[] my_ages = new int[5];
```
Because a String is a reference to an Object, `my_names` will contain five `null`s. `my_ages` will contain five `0`s to begin with.
    



Creating an Empty Array

Now that we have an array declared and initialized, we want to be able to get values out of it.

We use square brackets, `[` and `]`, to access data at a certain index:

```java
double[] prices = {13.1, 15.87, 14.22, 16.66};

System.out.println(prices[1]);
```

This command would print:

```
15.87
```

This happens because `15.87` is the item at the `1` index of the array. Remember, the index of an array starts at `0` and ends at an index of one less than the number of elements in the array.

If we try to access an element outside of its appropriate index range, we will receive an `ArrayIndexOutOfBoundsException` error. 

For example, if we were to run the command `System.out.println(prices[5])`, we'd get the following output:
```error
java.lang.ArrayIndexOutOfBoundsException: 5
```



Get Element By Index

We have now seen how to store a list of values in arrays. We can use this knowledge to make organized programs with more complex variables.

Throughout the lesson, we have learned about:

- Creating arrays explicitly, using `{` and `}`.
- Accessing an index of an array using `[` and `]`.
- Creating empty arrays of a certain size, and filling the indices one by one.
- Getting the length of an array using `length`.
- Using the argument array `args` that is passed into the `main()` method of a class.



Review

Imagine that we're using a program to keep track of the prices of different clothing items we want to buy. We would want a list of the prices and a list of the items they correspond to. To create an array, we provide a name and declare the type of data it holds: 

```java
double[] prices;
```
Just like with variables, we can declare and initialize in the same line.  This allows us to explicitly initialize the array to contain the data we want to store :

```java
double[] prices = {13.15, 15.87, 14.22, 16.66};
```

We can use arrays to hold `String`s and other objects as well as primitives:

```java
String[] clothingItems = {"Tank Top", "Beanie", "Funny Socks", "Corduroys"};
```
