Julia 数组
数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。
Julia 支持数组数据结构，它可以存储一个大小不是固定的，类型可以相同也可以不同的顺序集合。
Julia 数组是可变类型集合，用于列表、向量、表格和矩阵。
Julia 数组的索引键值可以使用整数表示，数组的大小不是固定的。
Julia 提供了很多函数帮助我们来操作数组，比如数组添加元素，合并数组等。
Julia 数组用方括号
[...]
指定，多个元素使用逗号
,
分隔。
创建一个一维数组(即一个向量)语法为:
[A, B, C, ...]
创建一维数组
下面实例创建了一个简单的一维数组：
julia
>
arr =
[
1
,
2
,
3
]
3
-element
Vector
{
Int64
}
:
上面的实例中我们创建了一个包含 3 个元素的一维数组，每个元素都是一个 64 位整数，这个一维数组绑定到变量
arr
中。
数组元素的类型也可以不一样：
julia
>
arr =
[
1
,
"RUNOOB"
,
2.5
, pi
]
4
-element
Vector
{
Any
}
:
"RUNOOB"
π =
3.1415926535897
...
上面的实例中我们创建了一个包含 4 个元素不同类型的一维数组，
pi
是常量
π
，每个元素都是一个 64 位整数，这个一维数组绑定到变量
arr
中。
当然也可以强制指定类型：
julia
>
arr =
Int64
[
1
,
2
,
3
]
3
-element
Vector
{
Int64
}
:
julia
>
arr2 =
String
[
"Taobao"
,
"RUNOOB"
,
"GOOGLE"
]
3
-element
Vector
{
String
}
:
"Taobao"
"RUNOOB"
"GOOGLE"
以上实例数组
arr
限制只能输入整数，
arr2
限制只能输入字符串。
我们也可以创建一个空数组：
julia
>
arr =
Int64
[
]
Int64
[
]
julia
>
arr2 =
String
[
]
String
[
]
创建的数组可以直接使用索引值来访问，第一个值的索引为 1（不是 0），第二个值索引为 2，以此类推，最后一个可以使用
end
表示：
julia
>
arr =
Int64
[
1
,
2
,
3
]
3
-element
Vector
{
Int64
}
:
julia
>
arr
[
2
]
julia
>
arr2 =
String
[
"Taobao"
,
"RUNOOB"
,
"GOOGLE"
]
3
-element
Vector
{
String
}
:
"Taobao"
"RUNOOB"
"GOOGLE"
julia
>
arr2
[
1
]
"Taobao"
julia
>
arr2
[
end
]
"GOOGLE"
指定数组类型及维度
我们还可以使用以下语法指定数组的类型和维度:
Array{type}(undef, dims...)
undef
表示数组未初始化。
dims...
可以是维度的单多元组，也可以是维度作为可变参数时的一组值。
dims...
数字表示元素个数，多个维度使用逗号
,
分隔。
julia
>
array =
Array
{
Int64
}
(
undef,
3
)
# 表示一维数组，数组有 3 个元素
3
-element
Vector
{
Int64
}
:
4834342704
4377305096
julia
>
array =
Array
{
Int64
}
(
undef,
3
,
3
,
3
)
# 表示 3 维数组，每个维度数组有 3 个元素
3
×
3
×
3
Array
{
Int64
,
3
}
:
[
:, :,
1
]
=
4562265712
0
0
1
0
0
0
0
0
[
:, :,
2
]
=
0
0
0
0
0
0
0
0
0
[
:, :,
3
]
=
0
0
0
0
0
0
0
0
0
以上实例中，数组的类型我们放在花括号中
{}
， undef 用于设置数组未初始化为任何已知值，这就是我们在输出中得到随机数的原因。
创建二维数组和矩阵
我们可以将数组元素中的逗号
,
省略掉或者使用两个冒号
;;
，这样就可以创建一个二维数组了，如下实例：
julia
>
[
1
2
3
4
]
1
×
4
Matrix
{
Int64
}
:
1
2
3
4
julia
>
[
1
;;
2
;;
3
;;
4
]
1
×
4
Matrix
{
Int64
}
:
1
2
3
4
注意：
第一行输出的
1×4 Matrix{Int64}:
，1x4 表示一行四列的矩阵。
虽然只有一行，也是二维数组，因为 Julia 只认可列向量，而不认可所谓的行向量。
要添加另一行，只需添加分号
;
，看以下实例：
julia
>
[
1
2
;
3
4
]
2
×
2
Matrix
{
Int64
}
:
1
2
3
4
也可以使用冒号
:
和空格
来实现，看以下实例：
julia
>
[
1
:
2
3
:
4
]
2
×
2
Matrix
{
Int64
}
:
1
3
2
4
注意：
第一行输出的
2×2 Matrix{Int64}:
，2×2 表示两行两列的矩阵。
我们也可以在方括号
[]
中嵌入多个长度相同的一维数组，并用空格分隔来创建二维数组：
julia
>
[
[
1
,
2
]
[
3
,
4
]
[
5
,
6
]
]
2
×
3
Matrix
{
Int64
}
:
1
3
5
2
4
6
2x3
表示两行三列的数组。
下面我们通过灵活运用分号
;
和空格
创建一个两行三列和三行两列的二维数组：
julia
>
[
[
1
;
2
]
[
3
;
4
]
[
5
;
6
]
]
2
×
3
Matrix
{
Int64
}
:
1
3
5
2
4
6
julia
>
[
[
1
2
]
;
[
3
4
]
;
[
5
6
]
]
3
×
2
Matrix
{
Int64
}
:
1
2
3
4
5
6
使用范围函数来创建数组
省略号 ...
可以使用省略号
...
来创建一个数组，实例如下：
julia
>
[
0
:
10
...
]
11
-element
Vector
{
Int64
}
:
collect() 函数
collect() 函数语法格式如下：
collect(start:step:stop)
start 为开始值，step 为步长，stop 为结束值。
该函数返回数组。
以下实例值为 1，步长为 2，结束值为 13：
julia
>
collect
(
1
:
2
:
13
)
7
-element
Vector
{
Int64
}
:
collect() 函数也可以指定类型，语法格式如下：
collect(element_type, start:step:stop)
以下实例创建一个浮点型数组：
julia
>
collect
(
Float64
,
1
:
2
:
5
)
3
-element
Vector
{
Float64
}
:
range() 函数
range() 函数可以生存一个区间范围并指定步长，可以方便 collect() 函数 调用。
range() 函数语法格式如下：
range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)
start 为开始值，step 为步长，stop 为结束值，length 为长度。
julia
>
range
(
1
,
length
=
100
)
1
:
100
julia
>
range
(
1
, stop=
100
)
1
:
100
julia
>
range
(
1
, step=
5
,
length
=
100
)
1
:
5
:
496
julia
>
range
(
1
, step=
5
, stop=
100
)
1
:
5
:
96
julia
>
range
(
1
,
10
,
length
=
101
)
1.0
:
0.09
:
10.0
julia
>
range
(
1
,
100
, step=
5
)
1
:
5
:
96
julia
>
range
(
stop=
10
,
length
=
5
)
6
:
10
julia
>
range
(
stop=
10
, step=
1
,
length
=
5
)
6
:
1
:
10
julia
>
range
(
start
=
1
, step=
1
, stop=
10
)
1
:
1
:
10
如果未指定长度 length，且
stop - start
不是 step 的整数倍，则将生成在 stop 之前结束的范围。
julia> range(1, 3.5, step=2)
1.0:2.0:3.0
使用 range() 和 collect() 创建数组：
julia
>
collect
(
range
(
1
,stop=
10
)
)
10
-element
Vector
{
Int64
}
:
julia
>
collect
(
range
(
1
,
length
=
15
, stop=
150
)
)
15
-element
Vector
{
Float64
}
:
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0
使用推导式和生成器创建数组
创建数组的另一种有用方法是使用推导。
数组推导式语法格式如下：
A = [ F(x,y,...) for x=rx, y=ry, ... ]
F(x,y,...) 取其给定列表中变量 x，y 等的每个值进行计算。值可以指定为任何可迭代对象，但通常是 1:n 或 2:(n-1) 之类的范围，或者像 [1.2, 3.4, 5.7] 这样的显式数组值。结果是一个 N 维密集数组，将变量范围 rx，ry 等的维数拼接起来得到其维数，并且每次 F(x,y,...) 计算返回一个标量。
julia
>
[
n^
2
for
n
in
1
:
10
]
10
-element
Vector
{
Int64
}
:
创建二维数组：
julia
>
[
n
*
m
for
n
in
1
:
10
, m
in
1
:
10
]
10
×
10
Matrix
{
Int64
}
:
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
Vector
{
Int64
}
:
以下表达式在不分配内存的情况下对一个序列进行求和：
julia
>
sum
(
1
/n^
2
for
n=
1
:
1000
)
1.6439345666815615
Julia 数组基本函数
similar(A, T, dims...)
一个与
A
具有相同类型（这里指的是密集，稀疏等）的未初始化数组，但具有指定的元素类型和维数。第二个和第三个参数都是可选的，如果省略则默认为元素类型和
A
的维数。
reinterpret(T, A)
与
A
具有相同二进制数据的数组，但元素类型为
T
rand(T, dims...)
一个随机
Array
，元素值是
[
0
,
1
)
半开区间中的均匀分布且服从一阶独立同分布
randn(T, dims...)
一个随机
Array
，元素为标准正态分布，服从独立同分布
Matrix{T}(I, m, n)
m
行
n
列的单位矩阵 （需要先执行
using LinearAlgebra
来才能使用
I
）
range(start, stop=stop, length=n)
从
start
到
stop
的带有
n
个线性间隔元素的范围
fill!(A, x)
用值
x
填充数组
A
fill(x, dims...)
一个被值
x
填充的
Array
zeros()
创建数组实例，元素初始值 都是 0:
julia
>
zeros
(
Int8
,
2
,
3
)
2
×
3
Matrix
{
Int8
}
:
0
0
0
0
0
0
julia
>
zeros
(
Int8
,
(
2
,
3
)
)
2
×
3
Matrix
{
Int8
}
:
0
0
0
0
0
0
julia
>
zeros
(
(
2
,
3
)
)
2
×
3
Matrix
{
Float64
}
:
0.0
0.0
0.0
0.0
0.0
0.0
