Learn about how to build and use arrays in C#. 

Arrays

In addition to `Sort()`, `IndexOf()`, and `Find()`, there are several other built-in methods for arrays. You can find them (and you probably guessed it) in the [Microsoft documentation](https://docs.microsoft.com/en-us/dotnet/api/system.array). 

Let's put your documentation sleuthing to use and hunt down some built-in methods to write some code! 



Documentation Hunt

Arrays are useful for storing values, but they're not very useful if they simply stay there &mdash; we also need a way to access them. 

Arrays order items so that they’re in a specific sequence, which makes it helpful for accessing each item. Each value has a specific position in the array, which is known as its _index_. You can think of an index like an address - it’s what we use to locate an item in an array. In C#, arrays start their index at 0 and then add one for each value. 

![accessing by index](https://content.codecademy.com/courses/learn-c-sharp/arrays/C%23SyntaxDiagram_1_black.svg)

To access a value from a list, we write out the name of the array, followed by brackets `[]` and within the brackets, the index number of that value that we want: 

```csharp
int[] plantHeights = {3, 4, 6};

// plantTwoHeight will be 4
int plantTwoHeight = plantHeights[1];
```
We can now use that value and do something with it, like save it to a variable. 


Accessing Array Items

Once we create an array, the size of that array is fixed. However, it's possible to change the values it contains. 

For example, we can initialize an array that has a length of three without specifying what those values are, then later go back and edit the array to include a new value. This is useful if we know how many things we're expecting, but we don't know their specific values yet:

```csharp
// plantHeights will be equal to [0, 0, 0]
int[] plantHeights = new int[3]; 

// plantHeights will now be [0, 0, 8]
plantHeights[2] = 8; 
```

When we create the array with a known length but no known values, the array stores a _default type value_ ([0 for int, null for string](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table)). We then edit the array and swap out one of the default values with a new, specific value. In this case, we're saying that at index 2 we want to swap the default value `0` for `8`. 

We can also edit the values of pre-existing arrays. Again, we can't add to the length of an existing array, but we can swap out values:
```csharp
int[] plantHeights = { 3, 4, 6 };

// plantHeights will be [3, 5, 6]
plantHeights[1] = 5; 
```

In this case, we already have an array with a defined set of values, `{ 3, 4, 6 }`. But what if a plant grows? We'll need to go back in and change its value. So if it's the second plant, we access its value using bracket notation, then change its value to `5`. 


Editing Arrays

Congratulations, we covered a lot in this lesson! We learned about:

- Data structures and how we can use them to better organize our data
- How to build, access, and edit values in arrays
- How to use Array class built-in methods, including `Sort()`, `IndexOf()`, and `Find()`

If you get stuck or would like to learn more, check out the official Microsoft site:
* For general conceptual information, read [the programming guide on Arrays](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/index)
* For specific information on methods like `Find()`, read [the Array class documentation](https://docs.microsoft.com/en-us/dotnet/api/system.array)

Review

In C#, arrays are a collection of values that all share the same data type. You could have an array of type `string` that contains a list of your favorite songs, or an array of type `int` that stores a collection of user ids. 

Similar to defining a variable for one piece of data, when we define a variable to hold an array we also have to specify the type:

```csharp
// These arrays store ints, strings, and doubles, respectively
int[] x; 
string[] s; 
double[] d; 
```

To declare a variable that holds an array, we first write the type of data that will be stored in an array, then add the square brackets `[]` to signify that it is holding an array (rather than a single value), followed by the name of the array. 

Like a variable, we can define and initialize an array at the same time, by specifying the values we want to store in it:

```csharp
int[] plantHeights = { 3, 4, 6 };
```
To declare and initialize an array at the same time, after the array declaration we use the equal sign to denote we're storing a value to the array, then write out the numbers we're putting in the array, separated by commas `,` and enclosed in curly braces `{}`. 

You may also see arrays defined and initialized using a `new` keyword:
```csharp
int[] plantHeights = new int[] { 3, 4, 6 };
```

The `new` keyword signifies that we are instantiating a new array from the array class. We'll cover classes and instantiation in another lesson, but for now you can just think of it as another way to create an array. 

In fact, if you decide to define an array and then initialize it later (rather in one line like above) you **must** use the `new` keyword:

```csharp
// Initial declaration
int[] plantHeights;

// This works
plantHeights = new int[] { 3, 4, 6 };   

// This will cause an error
// plantHeights = { 3, 4, 6 }; 
```


Building Arrays

You want to write a program that keeps track of the heights of different plants in your garden. You could do this as a series of variables, but those would become difficult to work with really fast. 

```csharp
// height in inches
int plantOne = 4;
int plantTwo = 3;
int plantThree = 6;
```
Luckily, C# provides us with a built-in solution to easily keep track of lots of different pieces of information. _Data structures_ are formats designed to store larger amounts of information in an organized fashion. 

An _array_ is one very basic data structure. Programmers use arrays as a container to store multiple pieces of information that relate to each other in some way. Like a list of the presidents of the United States, types of cheeses in alphabetical order, and the finishing positions of runners in a race.

What makes arrays special is that they order our data in a specific, linear sequence. Since our values are kept in order, it allows us to easily find the information we’re looking for; otherwise, we’d have a huge jumbled mess of data! Which means, rather than having to create multiple variables and retrieve information using a variable name, we can use a single array name and retrieve it using its location in that array. 

You're already familiar with strings - strings are arrays of characters. Just like we can use syntax to access parts of string, we can do so with arrays. 

In this lesson, we'll cover:
- How to build arrays in C#
- How to find the length of an array
- How to access array values
- How to edit arrays
- How to read documentation and use built-in methods


Introduction to Arrays

In C#, there are several built-in methods we can use with arrays. The full list can be found in the [Microsoft documentation of the Array class, under methods](https://docs.microsoft.com/en-us/dotnet/api/system.array). 

#### SORT

The built-in method `Array.Sort()` ([documentation](https://docs.microsoft.com/en-us/dotnet/api/system.array.sort)), as its name suggests, sorts an array. This method is a quick way to further organize array data into a logical sequence:

```csharp
int[] plantHeights = { 3, 6, 4, 1 };

// plantHeights will be { 1, 3, 4, 6 }
Array.Sort(plantHeights); 
```

`Sort()` takes an array as a parameter and edits the array so its values are sorted. If it is an array of integer values, it will sort them into ascending values (lowest to highest). If it's an array of string values, they would be sorted alphabetically.  


#### INDEX OF

The `Array` method `Array.IndexOf()`([documentation](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof)) takes a value and returns its index. `IndexOf()` works best when you have a specific value and need to know where it's located in the array (or if it even exists!). 

```csharp
int[] plantHeights = { 3, 6, 4, 1, 6, 8 };

 // returns 1
Array.IndexOf(plantHeights, 6);
```
`IndexOf()` typically takes two parameters: the first is the array and the second is the value whose index we're locating. `IndexOf()` also has several overloads that allow you to search for a specific range of the array. 
If the value appears more than once in an array, it returns only the first occurrence within the specified range. If it cannot find the value, it returns the lower bound of the array, minus 1 (since most arrays start at 0, it's usually -1). 


#### FIND

The `Array` method `Array.Find()`([documentation](https://docs.microsoft.com/en-us/dotnet/api/system.array.find)) searches a one-dimensional array for a specific value or set of values that match a certain condition and returns the first occurrence in the array. 

```csharp
int[] plantHeights = { 3, 6, 4, 1, 6, 8 };

// Find the first occurence of a plant height that is greater than 5 inches
int firstHeight = Array.Find(plantHeights, height => height > 5);
```

`Find()` takes two parameters: the first is the array and the second is a _predicate_ that defines what we're looking for. A predicate is a method that takes one input and outputs a boolean. Unlike `IndexOf()`, `Find()` returns the actual values that match the condition, instead of their index. 

It's customary to use a lambda function for the predicate to determine if the value meets the necessary criteria. If you need a refresher on lambda functions, check out our C# methods lesson. 

For more information on using built-in methods, check out our lessons on [C#: Methods](https://www.codecademy.com/learn/learn-c-sharp/modules/csharp-methods).

Built-In Methods

We often want to know how many items an array contains. We can do this with the `.Length` property. 

```csharp
int[] plantHeights = { 3, 4, 6 };

// arrayLength will be 3
int arrayLength = plantHeights.Length 
```

Using the `.Length` property will return the number of items in an array and zero if the array is empty. 
