An array is an ordered list of items stored in a single variable

An array is a container that holds multiple values of the same type in one place. Instead of creating separate variables for each item — like name1, name2, name3 — you create one array called names and store all three inside it. Each item in the array occupies a numbered position, starting from 0, so you can retrieve or change any item by its position number.

Arrays are one of the most common ways programmers organize data. They appear in nearly every programming language — Python, JavaScript, Java, C++, and others — because they solve a basic problem: how to work with many related items without writing repetitive code.

Key Takeaways

  • An array stores multiple items of the same type in a single variable, with each item assigned a position number starting from 0.
  • You access items in an array by their position number, called an index, rather than by a unique variable name.
  • Arrays let you loop through many items with a single block of code instead of writing separate instructions for each item.
  • Different programming languages have slightly different syntax for creating and using arrays, but the core idea is the same across all of them.
  • Arrays work best when you know roughly how many items you need to store, or when all items are the same type.

How array positions work

Each item in an array has a position number called an index. The first item is always at index 0, the second at index 1, the third at index 2, and so on. This numbering system is consistent across almost all programming languages, even though it confuses beginners who expect the first item to be at position 1.

If you create an array of fruit names — ["apple", "banana", "orange"] — then apple is at index 0, banana is at index 1, and orange is at index 2. To retrieve the banana, you ask for the item at index 1. To change the apple to a pear, you replace the item at index 0.

This system matters because it lets you write a single instruction that works on every item. Instead of writing "print apple, print banana, print orange," you write "for each item in the array, print it." The loop runs once for each position, and you never have to name the items individually.

Why programmers use arrays instead of separate variables

Imagine you need to store the test scores for 30 students. You could create 30 separate variables: score1, score2, score3, and so on. But then calculating the average would require adding all 30 variables together by name — a line of code that is long, error-prone, and painful to maintain.

With an array, you create one variable called scores that holds all 30 numbers. Then you write a loop that says "add up every number in the scores array and divide by how many numbers there are." The same loop works whether you have 30 scores, 300 scores, or 3 scores. You never have to rewrite the logic.

Arrays also make it easier to work with data that changes. If you read a list of names from a file, you do not know in advance how many names there will be. An array can grow or shrink to fit the data, whereas separate variables would require you to decide the exact number before you start.

Creating and using arrays in practice

The syntax for creating an array varies by language, but the idea is the same. In Python, you write fruits = ["apple", "banana", "orange"]. In JavaScript, it looks nearly identical: const fruits = ["apple", "banana", "orange"];. In Java, you write String[] fruits = {"apple", "banana", "orange"};.

Once the array exists, you retrieve items by index. In most languages, fruits[0] gives you "apple", fruits[1] gives you "banana". You can also change an item: fruits[0] = "pear" replaces the apple with a pear. Many languages let you add new items to the end of an array, or remove items from the middle.

Looping through an array is where they become powerful. In Python, you write:

for fruit in fruits:   print(fruit)

This prints every item in the array, one per line. You do not need to know how many items are in the array or write the print statement multiple times. The loop handles it automatically.

Arrays versus other data structures

Arrays are not the only way to store multiple items. Lists are similar to arrays but often more flexible — they can change size more easily and sometimes hold different types of items. Dictionaries or hash maps store items by name rather than by position number, so you might ask for the item called "age" instead of the item at index 3. Sets store unique items with no particular order.

Arrays work best when you have many items of the same type and you want to access them by position. If you need to look up items by name, a dictionary is usually better. If you need the list to change size frequently, a list might be more convenient. But arrays remain the most common choice for straightforward, ordered collections of data.

Common mistakes when working with arrays

The most frequent error is forgetting that indexing starts at 0. A programmer creates an array with 5 items and tries to access array[5], expecting the last item, but that position does not exist — the last item is at array[4]. This causes an "index out of bounds" error.

Another common mistake is mixing data types. If you create an array meant to hold numbers, then try to put a text string in it, some languages will reject the code before it runs, while others will allow it but cause unexpected behavior later. Keeping arrays homogeneous — all numbers, or all text, or all objects of the same class — prevents confusion.

A third mistake is assuming an array is the right tool when it is not. If you need to look up a person's phone number by their name, storing both in separate arrays and trying to match them by index is fragile and error-prone. A dictionary that maps names to phone numbers is the clearer choice.

How arrays connect to larger programming concepts

Arrays are a building block for more complex ideas. A two-dimensional array is an array of arrays — imagine a spreadsheet where each row is an array, and the whole sheet is an array of rows. A list of objects is an array where each item is not just a number or string, but a complete object with its own properties and methods. Sorting and searching are algorithms that operate on arrays to rearrange items or find a specific one.

Understanding arrays well makes it easier to learn these more advanced topics, because they all rely on the same core idea: organizing related data in a structured way so that code can process it efficiently.

Frequently Asked Questions

Why does array indexing start at 0 instead of 1?

This convention comes from how computer memory works. The index actually represents an offset — how many positions to move from the start of the array. The first item is zero positions away from the start, the second item is one position away, and so on. Early programming languages kept this system, and it became the standard across nearly all languages.

Can an array hold different types of items, like numbers and text?

It depends on the language. Strongly typed languages like Java and C++ require all items in an array to be the same type. Loosely typed languages like Python and JavaScript allow mixed types, though mixing them often leads to bugs. It is usually better to keep arrays homogeneous unless you have a specific reason to mix types.

What happens if I try to access an index that does not exist?

Most languages throw an error called "index out of bounds" or "array index out of range" and stop the program. Some languages return a special value like null or undefined. Either way, the program does not silently give you wrong data — it alerts you that something went wrong.

Is an array the same as a list?

In everyday conversation, yes, but technically they differ. An array has a fixed size set when you create it, while a list can grow or shrink. In Python, the word "list" refers to a flexible, resizable array. In Java, "array" and "list" are distinct — arrays are fixed-size, and lists are flexible. The core idea is the same, but the implementation details vary.

Can I use an array to store other arrays inside it?

Yes. This creates a multi-dimensional array, most commonly a two-dimensional array that works like a table or grid. Each item in the outer array is itself an array. You access items using two indices: grid[2][3] means row 2, column 3. This is useful for storing matrices, game boards, or any data that naturally fits a grid shape.