Julia - 数组
数组是一组有序的元素，通常用方括号指定具有逗号分隔的项目。 我们可以创建数组 −
满或空
保存不同类型的值
仅限于特定类型的值
在 Julia 中，数组实际上是可变类型集合，用于列表、向量、表和矩阵。 这就是为什么 Julia 中的数组值可以使用某些预定义的关键字进行修改。 借助 push! 命令，您可以在数组中添加新元素。 同样，借助 splice! 函数，您可以在数组中的指定索引处添加元素。
创建简单的一维数组
以下示例展示了如何创建简单的一维数组 −
julia> arr = [1,2,3]
3-element Array{Int64,1}:
1
2
3
上面的示例显示我们创建了一个包含 3 个元素的一维数组，每个元素都是 64 位整数。 该一维数组绑定到变量 arr。
未初始化的数组
我们还可以使用以下语法指定数组的类型和维度 −
Array{type}(dims)
以下是未初始化数组的示例 −
julia> array = Array{Int64}(undef, 3)
3-element Array{Int64,1}:
0
0
0
julia> array = Array{Int64}(undef, 3, 3, 3)
3×3×3 Array{Int64,3}:
[:, :, 1] =
8 372354944 328904752
3 331059280 162819664
32 339708912 1
[:, :, 2] =
331213072 3 331355760
1 328841776 331355984
-1 328841680 2
[:, :, 3] =
1 0 339709232
164231472 328841872 347296224
328841968 339709152 16842753
这里我们将类型放在大括号中，将尺寸放在括号中。 我们使用 undef 这意味着特定数组尚未初始化为任何已知值，这就是我们在输出中获得随机数的原因。
任意数组
Julia 使我们可以自由地创建包含不同类型元素的数组。 让我们看下面的示例，我们将在其中创建奇数混合数组 - 数字、字符串、函数、常量 −
julia> [1, "TutorialsPoint.com", 5.5, tan, pi]
5-element Array{Any,1}:
1
"TutorialsPoint.com"
5.5
tan (generic function with 12 methods)
π = 3.1415926535897...
空数组
就像创建特定类型的数组一样，我们也可以在 Julia 中创建空数组。 下面给出示例 −
julia> A = Int64[] Int64[] julia> A = String[] String[]
创建二维数组和矩阵
省略元素之间的逗号，您将在 Julia 中获得二维数组。 下面是单行多列数组的示例 −
julia> [1 2 3 4 5 6 7 8 9 10]
1×10 Array{Int64,2}:
1 2 3 4 5 6 7 8 9 10
这里，1×10是该数组的第一行。
要添加另一行，只需添加分号(;)。 让我们检查下面的例子 −
julia> [1 2 3 4 5 ; 6 7 8 9 10]
2×5 Array{Int64,2}:
1 2 3 4 5
6 7 8 9 10
这里，它变成了2×5数组。
使用范围对象创建数组
我们可以通过以下方式使用范围对象创建数组 −
Collect() 函数
使用范围对象创建数组的第一个有用函数是collect()。 借助冒号(:)和collect()函数，我们可以使用范围对象创建一个数组，如下所示 −
julia> collect(1:5)
5-element Array{Int64,1}:
1
2
3
4
5
我们还可以使用浮点范围对象创建数组 −
julia> collect(1.5:5.5)
5-element Array{Float64,1}:
1.5
2.5
3.5
4.5
5.5
让我们看看范围对象的三部分版本，借助它您可以指定 1 以外的步长。
下面给出了相同的语法 −start:step:stop.
下面是构建一个数组的示例，其中元素从 0 到 50，步长为 5 −
julia> collect(0:5:50)
11-element Array{Int64,1}:
0
5
10
15
20
25
30
35
40
45
50
省略号(…)或 splat 运算符
除了使用collect()函数之外，我们还可以在最后一个元素后面使用splat运算符或省略号(…)。 下面是一个例子 −
julia> [0:10...]
11-element Array{Int64,1}:
0
1
2
3
4
5
6
7
8
9
10
range() 函数
Range() 是另一个有用的函数，用于创建包含范围对象的数组。 它通过采用特定的步长值从开始值到结束值。
例如，让我们看一个从 1 到 150 只需 15 步的例子 −
julia> range(1, length=15, stop=150) 1.0:10.642857142857142:150.0 Or you can use range to take 10 steps from 1, stopping at or before 150: julia> range(1, stop=150, step=10) 1:10:141
我们可以使用range()和collect()来构建一个数组，如下所示 −
julia> collect(range(1, length=15, stop=150))
15-element Array{Float64,1}:
1.0
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
75.5
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0
使用推导式和生成器创建数组
创建数组的另一种有用方法是使用推导式。 通过这种方式，我们可以创建数组，其中每个元素都可以使用少量计算来生成。 例如，我们可以创建一个包含 10 个元素的数组，如下所示 −
julia> [n^2 for n in 1:10]
10-element Array{Int64,1}:
1
4
9
16
25
36
49
64
81
100
我们也可以轻松创建一个二维数组，如下所示 −
julia> [n*m for n in 1:10, m in 1:10]
10×10 Array{Int64,2}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
与推导式类似，我们可以使用生成器表达式来创建数组 −
julia> collect(n^2 for n in 1:5)
5-element Array{Int64,1}:
1
4
9
16
25
生成器表达式不会构建数组来首先保存值，而是在需要时生成值。 因此它们比推导式更有用。
填充数组
以下是您可以使用特定内容创建和填充数组的函数 −
zeros (m, n)
此函数将创建具有 m 行和 n 列的零矩阵。 下面给出示例 −
julia> zeros(4,5)
4×5 Array{Float64,2}:
0.0 0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
我们还可以指定零的类型，如下所示 −
julia> zeros(Int64,4,5)
4×5 Array{Int64,2}:
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0
ones (m, n)
此函数将创建 m 行和 n 列的矩阵。 下面给出示例 −
julia> ones(4,5)
4×5 Array{Float64,2}:
1.0 1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0 1.0
rand (m, n)
顾名思义，该函数将创建包含 m 行和 n 列的随机数矩阵。 下面给出示例 −
julia> rand(4,5)
4×5 Array{Float64,2}:
0.514061 0.888862 0.197132 0.721092 0.899983
0.503034 0.81519 0.061025 0.279143 0.204272
0.687983 0.883176 0.653474 0.659005 0.970319
0.20116 0.349378 0.470409 0.000273225 0.83694
randn(m, n)
顾名思义，该函数将创建 m*n 的正态分布随机数矩阵，平均值=0，标准差(SD)=1。
julia> randn(4,5)
4×5 Array{Float64,2}:
-0.190909 -1.18673 2.17422 0.811674 1.32414
0.837096 -0.0326669 -2.03179 0.100863 0.409234
-1.24511 -0.917098 -0.995239 0.820814 1.60817
-1.00931 -0.804208 0.343079 0.0771786 0.361685
fill()
该函数用于用特定值填充数组。 更具体地说，它将创建一个重复重复值的数组。
julia> fill(100,5)
5-element Array{Int64,1}:
100
100
100
100
100
julia> fill("tutorialspoint.com",3,3)
3×3 Array{String,2}:
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"
"tutorialspoint.com" "tutorialspoint.com" "tutorialspoint.com"
fill!()
它与 fill() 函数类似，但感叹号 (!) 表示或警告现有数组的内容将被更改。 下面给出示例:
julia> ABC = ones(5)
5-element Array{Float64,1}:
1.0
1.0
1.0
1.0
1.0
julia> fill!(ABC,100)
5-element Array{Float64,1}:
100.0
100.0
100.0
100.0
100.0
julia> ABC
5-element Array{Float64,1}:
100.0
100.0
100.0
100.0
100.0
数组构造函数
我们之前研究过的函数Array()可以构建特定类型的数组，如下所示 −
julia> Array{Int64}(undef, 5)
5-element Array{Int64,1}:
294967297
8589934593
8589934594
8589934594
0
从输出中我们可以看到该数组尚未初始化。 那些看起来奇怪的数字是记忆中的旧内容。
数组的数组
以下示例演示了创建数组的数组 −
julia> ABC = Array[[3,4],[5,6]]
2-element Array{Array,1}:
[3, 4]
[5, 6]
也可以借助 Array 构造函数来创建，如下所示 −
julia> Array[1:5,6:10]
2-element Array{Array,1}:
[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
复制数组
假设您有一个数组，并且想要创建另一个具有相似维度的数组，那么您可以使用 similar() 函数，如下所示 −
julia> A = collect(1:5);
Here we have hide the values with the help of semicolon(;)
julia> B = similar(A)
5-element Array{Int64,1}:
164998448
234899984
383606096
164557488
396984416
这里复制了数组 A 的维度，但没有复制值。
矩阵运算
众所周知，二维 (2D) 数组可以用作矩阵，因此所有可用于数组的函数也可以用作矩阵。 条件是尺寸和内容允许。 如果要输入矩阵，请使用空格组成行并使用分号 (;) 分隔行，如下所示 −
julia> [2 3 ; 4 5]
2×2 Array{Int64,2}:
2 3
4 5
以下是通过将两个数组彼此相邻放置来创建数组的数组（如我们之前所做的）的示例 −
julia> Array[[3,4],[5,6]]
2-element Array{Array,1}:
[3, 4]
[5, 6]
下面我们可以看到当我们省略逗号并将列彼此相邻放置时会发生什么 −
julia> [[3,4] [5,6]]
2×2 Array{Int64,2}:
3 5
4 6
访问数组的内容
在 Julia 中，要访问数组的内容/特定元素，您需要在方括号中写下数组的名称和元素编号。
下面是一维数组的示例 −
julia> arr = [5,10,15,20,25,30,35,40,45,50]
10-element Array{Int64,1}:
5
10
15
20
25
30
35
40
45
50
julia> arr[4]
20
在某些编程语言中，数组的最后一个元素称为 -1。 然而，在 Julia 中，它被称为 end。 您可以按如下方式找到数组的最后一个元素 −
julia> arr[end] 50
倒数第二个元素如下 −
julia> arr[end-1] 45
要一次访问多个元素，我们还可以提供一堆索引号，如下所示 −
julia> arr[[2,5,6]]
3-element Array{Int64,1}:
10
25
30
我们甚至可以通过提供 true 和 false 来访问数组元素 −
julia> arr[[true, false, true, true,true, false, false, true, true, false]]
6-element Array{Int64,1}:
5
15
20
25
40
45
现在让我们了解二维元素。
julia> arr2 = [10 11 12; 13 14 15; 16 17 18]
3×3 Array{Int64,2}:
10 11 12
13 14 15
16 17 18
julia> arr2[1]
10
下面的命令将给出 13，而不是我们预期的 11。
julia> arr2[2] 13
要访问 row1、column2 元素，我们需要使用以下命令 −
julia> arr2[1,2] 11
同样，对于row1和column3元素，我们必须使用以下命令 −
julia> arr2[1,3] 12
我们还可以使用getindex()函数从二维数组中获取元素 −
julia> getindex(arr2,1,2) 11 julia> getindex(arr2,2,3) 15
添加元素
我们可以分别使用 push!()、pushfirst!() 和 splice!() 函数将元素添加到 Julia 数组的末尾、前面和给定索引处。< /p>
最后
我们可以使用push!()函数在数组末尾添加一个元素。 例如，
julia> push!(arr,55)
11-element Array{Int64,1}:
5
10
15
20
25
30
35
40
45
50
55
记住我们在数组arr中有10个元素。现在push!()函数在该数组的末尾添加了元素55。
感叹号(!)表示该函数将更改数组。
在前面
我们可以使用pushfirst!()函数在数组的前面添加一个元素。 例如，
julia> pushfirst!(arr,0)
12-element Array{Int64,1}:
0
5
10
15
20
25
30
35
40
45
50
55
在给定索引处
我们可以使用 splice!() 函数将元素添加到给定索引处的数组中。 例如，
julia> splice!(arr,2:5,2:6)
4-element Array{Int64,1}:
5
10
15
20
julia> arr
13-element Array{Int64,1}:
0
2
3
4
5
6
25
30
35
40
45
50
55
删除元素
我们可以分别使用 pop!()、popfirst!() 和 splice!() 函数从 Julia 的数组中删除最后一个位置、第一个位置和给定索引处的元素。
删除最后一个元素
我们可以使用pop!()函数来删除数组的最后一个元素。 例如，
julia> pop!(arr)
55
julia> arr
12-element Array{Int64,1}:
0
2
3
4
5
6
25
30
35
40
45
50
删除第一个元素
我们可以使用popfirst!()函数来删除数组的第一个元素。 例如，
julia> popfirst!(arr)
0
julia> arr
11-element Array{Int64,1}:
2
3
4
5
6
25
30
35
40
45
50
删除给定位置的元素
我们可以使用splice!()函数从数组的给定位置删除元素。 例如，
julia> splice!(arr,5)
6
julia> arr
10-element Array{Int64,1}:
2
3
4
5
25
30
35
40
45
50
