Home Â» Julia Â» How to Create a List in Julia?

# How to Create a List in Julia?

In Julia, a list is an ordered collection of elements. To create a list in Julia, you can use the `[]` syntax. Below are some examples:

## Create a List in Julia Examples

```julia> x = [1, 2, 3, 4]
4-element Array{Int64,1}:
1
2
3
4```

In this example, the `x` variable is initialized to a list containing the numbers `1`, `2`, `3`, and `4`. You can access the elements of the list using indexing:

```julia> x[1]
1

julia> x[2]
2

julia> x[3]
3

julia> x[4]
4```

You can also add elements to a list using the `push!` function:

```julia> push!(x, 5)
5-element Array{Int64,1}:
1
2
3
4
5

julia> push!(x, 6)
6-element Array{Int64,1}:
1
2
3
4
5
6```

In this example, the `push!` function is used to add the elements `5` and `6` to the end of the `x` list. The `push!` function modifies the list in place, so the original `x` list is updated with the new elements.

## Create List using Comprehensions in Julia

You can also create lists using comprehensions, which provide a more concise syntax for creating lists from other collections. For example:

```julia> x = [i^2 for i in 1:10]
10-element Array{Int64,1}:
1
4
9
16
25
36
49
64
81
100```

In this example, the `x` variable is initialized to a list of squares of the numbers from 1 to 10. The list comprehension is used to generate the elements of the list, where the `i^2` expression is applied to each element `i` in the range `1:10`. This generates a list of 10 elements, each of which is the square of the corresponding number in the range.

## Create List using collect Function

You can also create lists using the `collect` function, which converts an iterator into a list. For example:

```julia> x = collect(1:10)
10-element Array{Int64,1}:
1
2
3
4
5
6
7
8
9
10```

In this example, the `collect` function is used to create a list from the iterator `1:10`, which generates the numbers from 1 to 10. This produces a list with 10 elements, each of which is a number from the iterator.

you can add elements to an empty list using the `push!` function. For example:

```julia> x = []
0-element Array{Any,1}

julia> push!(x, 1)
1-element Array{Any,1}:
1

julia> push!(x, 2)
2-element Array{Any,1}:
1
2

julia> push!(x, 3)
3-element Array{Any,1}:
1
2
3```

In this example, the `x` variable is initialized to an empty list using the `[]` syntax. Then, the `push!` function is used to add the elements `1`, `2`, and `3` to the list. The `push!` function modifies the list in place, so the original `x` list is updated with the new elements.

You can also create empty lists using the `Array` constructor and specify the type of elements that the list will contain. For example:

```julia> x = Array{Int64}(undef, 0)
0-element Array{Int64,1}

julia> push!(x, 1)
1-element Array{Int64,1}:
1

julia> push!(x, 2)
2-element Array{Int64,1}:
1
2

julia> push!(x, 3)
3-element Array{Int64,1}:
1
2
3```

In this example, the `x` variable is initialized to an empty list using the `Array` constructor with the `undef` keyword argument. This creates an empty list with the element type `Int64`. Then, the `push!` function is used to add the elements `1`, `2`, and `3` to the list. The `push!` function modifies the list in place, so the original `x` list is updated with the new elements.