Julia 数组
数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。
Julia 支持数组数据结构，它可以存储一个大小不是固定的，类型可以相同也可以不同的顺序集合。
Julia 数组是可变类型集合，用于列表、向量、表格和矩阵。
Julia 数组的索引键值可以使用整数表示，数组的大小不是固定的。
Julia 提供了很多函数帮助我们来操作数组，比如数组添加元素，合并数组等。
Julia 数组用方括号 [...] 指定，多个元素使用逗号 , 分隔。
创建一个一维数组(即一个向量)语法为:
[A, B, C, ...]
创建一维数组
下面实例创建了一个简单的一维数组：
实例
3 -element Vector { Int64 } :
1
2
3
上面的实例中我们创建了一个包含 3 个元素的一维数组，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。
数组元素的类型也可以不一样：
实例
4 -element Vector { Any } :
1
"yssmx"
2.5
π = 3.1415926535897 ...
上面的实例中我们创建了一个包含 4 个元素不同类型的一维数组， pi 是常量 π ，每个元素都是一个 64 位整数，这个一维数组绑定到变量 arr 中。
当然也可以强制指定类型：
实例
3 -element Vector { Int64 } :
1
2
3
julia > arr2 = String [ "Taobao" , "yssmx" , "GOOGLE" ]
3 -element Vector { String } :
"Taobao"
"yssmx"
"GOOGLE"
以上实例数组 arr 限制只能输入整数， arr2 限制只能输入字符串。
我们也可以创建一个空数组：
实例
Int64 [ ]
julia > arr2 = String [ ]
String [ ]
创建的数组可以直接使用索引值来访问，第一个值的索引为 1（不是 0），第二个值索引为 2，以此类推，最后一个可以使用 end 表示：
实例
3 -element Vector { Int64 } :
1
2
3
julia > arr [ 2 ]
2
julia > arr2 = String [ "Taobao" , "yssmx" , "GOOGLE" ]
3 -element Vector { String } :
"Taobao"
"yssmx"
"GOOGLE"
julia > arr2 [ 1 ]
"Taobao"
julia > arr2 [ end ]
"GOOGLE"
指定数组类型及维度
我们还可以使用以下语法指定数组的类型和维度:
Array{type}(undef, dims...)
undef 表示数组未初始化。
dims... 可以是维度的单多元组，也可以是维度作为可变参数时的一组值。
dims... 数字表示元素个数，多个维度使用逗号 , 分隔。
实例
3 -element Vector { Int64 } :
4834342704
4377305096
julia > array = Array { Int64 } ( undef, 3 , 3 , 3 ) # 表示 3 维数组，每个维度数组有 3 个元素
3 × 3 × 3 Array { Int64 , 3 } :
[ :, :, 1 ] =
4562265712
1
[ :, :, 2 ] =
[ :, :, 3 ] =
以上实例中，数组的类型我们放在花括号中 {} ， undef 用于设置数组未初始化为任何已知值，这就是我们在输出中得到随机数的原因。
创建二维数组和矩阵
我们可以将数组元素中的逗号 , 省略掉或者使用两个冒号 ;; ，这样就可以创建一个二维数组了，如下实例：
实例
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 只认可列向量，而不认可所谓的行向量。
要添加另一行，只需添加分号 ; ，看以下实例：
实例
2 × 2 Matrix { Int64 } :
1 2
3 4
也可以使用冒号 : 和空格 来实现，看以下实例：
实例
2 × 2 Matrix { Int64 } :
1 3
2 4
注意： 第一行输出的 2×2 Matrix{Int64}: ，2×2 表示两行两列的矩阵。
我们也可以在方括号 [] 中嵌入多个长度相同的一维数组，并用空格分隔来创建二维数组：
实例
2 × 3 Matrix { Int64 } :
1 3 5
2 4 6
2x3 表示两行三列的数组。
下面我们通过灵活运用分号 ; 和空格 创建一个两行三列和三行两列的二维数组：
实例
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
使用范围函数来创建数组
省略号 ...
可以使用省略号 ... 来创建一个数组，实例如下：
实例
11 -element Vector { Int64 } :
1
2
3
4
5
6
7
8
9
10
collect() 函数
collect() 函数语法格式如下：
collect(start:step:stop)
start 为开始值，step 为步长，stop 为结束值。
该函数返回数组。
以下实例值为 1，步长为 2，结束值为 13：
实例
7 -element Vector { Int64 } :
1
3
5
7
9
11
13
collect() 函数也可以指定类型，语法格式如下：
collect(element_type, start:step:stop)
以下实例创建一个浮点型数组：
实例
3 -element Vector { Float64 } :
1.0
3.0
5.0
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 为长度。
实例
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() 创建数组：
实例
10 -element Vector { Int64 } :
1
2
3
4
5
6
7
8
9
10
julia > collect ( range ( 1 , length = 15 , stop=150 ) )
15 -element Vector { Float64 } :
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
使用推导式和生成器创建数组
创建数组的另一种有用方法是使用推导。
数组推导式语法格式如下：
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,...) 计算返回一个标量。
实例
10 -element Vector { Int64 } :
1
4
9
16
25
36
49
64
81
100
创建二维数组：
实例
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
也可以在没有方括号的情况下编写（数组）推导，从而产生称为生成器的对象。
以下实例创建一个数组：
实例
5 -element Vector { Int64 } :
1
4
9
16
25
以下表达式在不分配内存的情况下对一个序列进行求和：
实例
1.6439345666815615
Julia 数组基本函数
| 函数 | 描述 |
|---|---|
eltype(A)
|
A
中元素的类型
|
length(A)
|
A
中元素的数量
|
ndims(A)
|
A
的维数
|
size(A)
|
一个包含
A
各个维度上元素数量的元组
|
size(A,n)
|
A
第
n
维中的元素数量
|
axes(A)
|
一个包含
A
有效索引的元组
|
axes(A,n)
|
第
n
维有效索引的范围
|
eachindex(A)
|
一个访问
A
中每一个位置的高效迭代器
|
stride(A,k)
|
在第
k
维上的间隔（stride）（相邻元素间的线性索引距离）
|
strides(A)
|
包含每一维上的间隔（stride）的元组 |
Julia构造和初始化
Julia 提供了许多用于构造和初始化数组的函数。在下列函数中，参数 dims ... 可以是一个元组 tuple 来表示维数，也可以是一个可变长度的整数值作为维数。大部分函数的第一个参数都表示数组的元素类型 T 。如果类型 T 被省略，那么将默认为 Float64。
| 函数 | 描述 |
|---|---|
Array{T}(undef, dims...)
|
一个没有初始化的密集
Array
|
zeros(T, dims...)
|
一个全零
Array
|
ones(T, dims...)
|
一个元素均为 1 的
Array
|
trues(dims...)
|
一个每个元素都为
true
的
BitArray
|
falses(dims...)
|
一个每个元素都为
false
的
BitArray
|
reshape(A, dims...)
|
一个包含跟
A
相同数据但维数不同的数组
|
copy(A)
|
拷贝
A
|
deepcopy(A)
|
深拷贝，即拷贝
A
，并递归地拷贝其元素
|
similar(A, T, dims...)
|
一个与
A
具有相同类型（这里指的是密集，稀疏等）的未初始化数组，但具有指定的元素类型和维数。第二个和第三个参数都是可选的，如果省略则默认为元素类型和
A
的维数。
|
reinterpret(T, A)
|
与
A
具有相同二进制数据的数组，但元素类型为
T
|
rand(T, dims...)
|
一个随机
Array
，元素值是
半开区间中的均匀分布且服从一阶独立同分布
[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:
实例
2 × 3 Matrix { Int8 } :
julia > zeros ( Int8 , ( 2 , 3 ) )
2 × 3 Matrix { Int8 } :
julia > zeros ( ( 2 , 3 ) )
2 × 3 Matrix { Float64 } :
0.0 0.0 0.0
0.0 0.0 0.0
