数组的基本概念
如果说现在要求你定义100个整型变量，那么如果按照之前的做法，可能现在定义的的结构如下：
int i1, i2, i3, ... i100;

但是这个时候如果按照此类方式定义就会非常麻烦，因为这些变量彼此之间没有任何的关联，也就是说如果现在突然再有一个要求，要求你输出这100个变量的内容，意味着你要编写System.out.println()语句100次。
其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，而数组的定义语法有如下两类。

数组动态初始化：

声明并开辟数组：

数据类型 [] 数组名称 =  new 数据类型[长度];
数据类型 [] 数组名称 =  new 数据类型[长度];


分布进行数组空间开辟（实例化）

| Tables | Are |

| ------------- |:-------------?

| 声明数组： | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间： | 数组名称 =new` 数组类型[长度]; |



那么当数组开辟空间之后，就可以采用如下的方式的操作：

数组的访问通过索引完成，即：“数组名称[索引]”，但是需要注意的是，数组的索引从0开始，所以索引的范围就是0 ~ 数组长度-1，例如开辟了3个空间的数组，所以可以使用的索引是：0,1,2，如果此时访问的时候超过了数组的索引范围，会产生java.lang.ArrayIndexOutOfBoundsException 异常信息；
当我们数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值；
数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一个有限的数据集合，所以应该使用 for 循环。
在 Java 中提供有一种动态取得数组长度的方式：数组名称.length；

范例： 定义一个int型数组
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
		data[0] = 10; // 第一个元素
		data[1] = 20; // 第二个元素
		data[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过循环控制索引
		}
	}
}

数组本身除了声明并开辟空间之外还有另外一种开辟模式。
范例： 采用分步的模式开辟数组空间
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null; 
		data = new int[3]; /*开辟了一个长度为3的数组*/
		data[0] = 10; // 第一个元素
		data[1] = 20; // 第二个元素
		data[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过循环控制索引
		}
	}
}

但是千万要记住，数组属于引用数据类型，所以在数组使用之前一定要开辟控件（实例化），如果使用了没有开辟空间的数组，则一定会出现 NullPointerException 异常信息：
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null; 
		System.out.println(data[x]);
	}
}

这一原则和之前讲解的对象是完全相同的。
数组在开发之中一定会使用，但是像上面的操作很少。在以后的实际开发之中，会更多的使用数组概念，而直接使用，99%情况下都只是做一个 for 循环输出。
数组引用传递
既然数组属于引用数据类型，那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。
范例： 观察一道程序
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //开辟一个长度为3的数组
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
	}
}


那么既然说到了引用数据类型了，就一定可以发生引用传递，而现在的引用传递的本质也一定是：同一块堆内存空间可以被不同的栈内存所指向。
范例： 定义一个程序
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = null;
		data = new int[3]; //开辟一个长度为3的数组
		int temp[] = null; //声明对象
		data[0] = 10;
		data[1] = 20;
		data[2] = 30;
		temp = data;  //int temp[] = data;
		temp[0] = 99;
		for(int i = 0; i < temp.length; i++) {
			System.out.println(data[i]);
		}
	}
}


引用传递分析都是一个套路。同一块堆内存被不同的栈内存所指向。
数组静态初始化
在之前所进行的数组定义都有一个明显特点：数组先开辟内存空间，而后再使用索引进行内容的设置，实际上这种做法都叫做动态初始化，而如果希望数组在定义的时候可以同时出现设置内容，那么就可以采用静态初始化完成。
数组的静态初始化一共分为以下两种类型：




Tables
Are




简化格式：
数据类型 数组名称 = {值, 值,…}


完整格式：
数据类型 数组名称 = new 数据类型[] {值, 值,…}


范例： 采用静态初始化定义数组
public class ArrayDemo {
	public static void main(String args[]) {
		int data[] = {1, 2, 4, 545, 11, 32, 13131, 4444};
		for(int i = 0; i < data.length; i++) {
			System.out.println(data[i]);
		}
	}
}

在开发之中，对于静态数组的初始化强烈建议使用完整语法模式，这样可以轻松地使用匿名数组这一概念。
public class ArrayDemo {
	public static void main(String args[]) {
		System.out.println(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}.length);
	}
}

以后使用静态方式定义数组的时候一定要写上完整格式。
数组最大的缺陷：长度固定。
二维数组
在之前所使用的数组发现只需要一个索引就可以进行访问，那么这样的数组实际上非常像一个数据行的概念。




索引
0
1
2
3
4
5
6
7
8




内容
12
23
44
56
90
445
49
99
1010


现在痛过一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组，而二维数组本质上指的是行列集合，也如果要确定某一个数据需要行索引和列索引来进行定位。




索引
0
1
2
3
4
5
6
7
8




0
12
23
44
56
90
445
49
99
1010


1
2
3
41
56
9
45
49
99
10


如果要想确定一个数据则数据使用的结构是“数组名称[行索引][列索引]”，所以这样的结构就是一个表的结构。
那么对二维数组的定义有两种声明形式：

数组的动态初始化：数据类型 对象数组[][] = new 数据类型[行个数][列个数];
数组的静态初始化：数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};

数组的数组就是二维数组。
范例： 定义一个二维数组
public class ArrayDemo {
	public static void main(String args[]) {
		//此时的数组并不是一个等列数组
		int data[][] = new int[][] {
			{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
		//如果在进行输出的时候一定要使用双重循环，
		//外部的循环控制输出的行数，而内部的循环控制输出列数
		for(int i = 0; i < data.length; i++) {
			for(int j = 0; j < data[i].length; j++) {
				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
			}
			System.out.println();
		}
	}
}

由于输出麻烦，所以可以忽略了，在进行开发之中，出现二位数组的几率并不高。

typedef是类型定义的意思。typedef struct 是为了使用这个结构体方便。

具体区别在于: 

若struct node{ }这样来定义结构体的话。在定义 node 的结构体变量时，需要这样写:struct node n; 

若用typedef，可以这样写：typedef struct node{}NODE; 。在申请变量时就可以这样写：NODE n;其实就相当于 NODE 是node 的别名。区别就在于使用时，是否可以省去struct这个关键字。

首先：

在C中定义一个结构体类型时如果要用typedef:

typedef struct Student
{
   int no;
   char name[12];
}Stu,student;

于是在声明变量的时候就可：Stu stu1;或者：student stu2;(Stu 和student 同时为Student的别名) 

如果没有typedef即：

struct Student
{
   int no;
   char name[12];
}Stu;

就必须用struct Student stu1;或者struct Stu stu1;来声明 

另外这里也可以不写Student（于是也不能struct Student stu1;了）

typedef struct
{
   int no;
   char name[12];
}Stu;

其次：

在c++中如果用typedef的话，又会造成区别：

struct Student
{
   int no;
   char name[12];
}stu1;//stu1是一个变量

typedef struct Student2
{
   int no;
   char name[12];
}stu2;//stu2是一个结构体类型，即stu2是Student2的别名

使用时可以直接访问stu1.no 

但是stu2则必须先定义 stu2 s2; 

然后 s2.no=10;

pdf版本笔记的下载地址: MATLAB02_结构化编程和函数定义（访问密码：3834）
MATLAB02:结构化编程和函数定义
结构化编程
流程控制语句和逻辑运算符
流程控制语句示例
使用循环语句应尽量预先分配内存空间
编写脚本时应注意的问题
在脚本开头应添加语句清空工作区
在运算和赋值语句后应添加分号`;`抑制输出
使用省略号`...`拼接多行语句
函数
查看内置函数
以`函数名.m`文件形式定义函数
MATLAB内置的函数参数
MATLAB函数定义示例1
MATLAB函数定义示例2
以函数句柄形式定义函数

学习一门技术最好的方式就是阅读官方文档,可以查看MATLAB官方文档
结构化编程
流程控制语句和逻辑运算符
与大多数编程语言相同,MATLAB有以下流程控制语句:




流程控制语句
作用




if, elseif, else
若if语句为真,则执行子句


switch, case, otherwise
根据switch语句内容判断执行哪个子句


while
重复执行子句直到while中的条件为假


for
执行子句固定次数


try, catch
执行子句并捕获执行过程中的异常






break
跳出循环


continue
直接进入下一次循环


end
结束子句


pause
暂停程序


return
返回到调用函数处



上述所有循环和条件语句都要在末尾以end闭合.

MATLAB还有以下逻辑运算符:




运算符
意义




<
小于


<=
小于或等于


>
大于


>=
大于或等于


==
等于


~=
不等于


&&
且


||
或



&&和||运算符支持逻辑短路功能.

流程控制语句示例
下面演示各流程控制语句:


if语句:

if rem(a, 2) == 0
	disp('a is even');
else
	disp('a is odd');
end



switch语句:

switch input_num
case -1
	disp('negative 1');
case 0
	disp('zero');
case 1
	disp('positive 1');
otherwise
	disp('other value');
end



while语句:

n = 1;
while prod(1:n) < 1e100
	n = n + 1;
end



for语句:

for n=1:10
	a(n)=2^n;
end
disp(a)



break语句:
x = 2; k = 0; error = inf;
error_threshold = 1e-32;
while error > error_threshold
    if k > 100
    	break
    end
    x = x - sin(x)/cos(x);
    error = abs(x - pi);
    k = k + 1;
end



使用循环语句应尽量预先分配内存空间
若一个变量所需要的内存空间是一个可预测的定值,我们应尽量提前为其分配内存空间.
以下面两段程序为例,演示这一点:


程序一:
tic
for ii = 1:2000
    for jj = 1:2000
        A(ii,jj) = ii + jj;
    end
end
toc

程序输出Elapsed time is 4.616199 seconds.


程序二:
tic
A = zeros(2000, 2000);		% 预先为变量分配内存空间
for ii = 1:size(A,1)
    for jj = 1:size(A,2)
        A(ii,jj) = ii + jj;
    end
end
toc

程序输出Elapsed time is 2.786401 seconds.


可以看到,程序一比程序二所用的时间更长.这是因为: 对于程序一,没有预先为变量A分配内存,因此每当A的形状发生改变时,都需要重新为A分配内存地址,这花费了更多的时间.
编写脚本时应注意的问题
在脚本开头应添加语句清空工作区
在每个脚本的开头,应添加下述语句,清空工作区缓存以及之前程序运行的痕迹:
clear all	% 清空工作区内存中的变量
close all 	% 关闭之前程序绘制的图像
clc			% 清空之前程序在终端的输出

在运算和赋值语句后应添加分号;抑制输出
在所有运算和赋值语句都应该添加分号;抑制输出,若需要向终端输出一个变量,应对其调用disp方法.
使用省略号...拼接多行语句
在MATLAB中,省略号...可以将多行语句拼接为一行,灵活使用该语句可以提高代码可读性.
annPoints_sampled = annPoints(annPoints(:,1)>x1 & ...
    annPoints(:,1) < x2 & ...
    annPoints(:,2) > y1 & ...
    annPoints(:,2) < y2);

函数
与其他语言相似,MATLAB也可以定义函数.与脚本类似,函数可以被存入函数名.m文件中,也可以以函数句柄的形式定义在内存中.
查看内置函数
我们可以使用which命令查看内置函数源代码文件的位置,与edit命令结合可以查看内置函数的源代码.
运行下面语句可以打开MATLAB内置的mean函数的源文件:
edit(which('mean.m'))

可以在编辑器中看到mean函数的源代码如下:

以函数名.m文件形式定义函数
在MATLAB文件中定义函数的格式如下:
function [输出变量名] = 函数名(输入变量名) 
% 函数的文档

函数代码


function是一个关键字,声明该文件中保存的是一个函数.
输入变量和输出变量是非必须的,函数既可以没有输入变量,也可以没有输出变量.
函数名应与.m文件名相同,且不包含特殊字符(最好不要有中文).

MATLAB内置的函数参数
在MATLAB中,内置了一些函数参数如下:




函数参数
意义




imputname
输入变量名列表


mfilename
函数源代码文件名


nargin
输入变量数


nargout
输出变量个数


varargin
可变长输入参数列表


varargout
可变长输出参数列表


MATLAB不提供其他高级语言的指定默认参数值以及函数重载等语法,但灵活使用上述内置的函数参数,可以在一定程度上实现指定默认参数值以及方法重载:
function [volume]=pillar(Do,Di,height)
if nargin==2,
	height=1;
end
volume=abs(Do.^2-Di.^2).*height*pi/4;

MATLAB函数定义示例1
下面程序用来计算自由落体运动中位移量:

$x = 
x_0 + 
v_0 t +
\frac{1}{2} g t^2$
function x = freebody(x0,v0,t)
% calculation of free falling
% x0: initial displacement in m
% v0: initial velocity in m/sec
% t: the elapsed time in sec
% x: the depth of falling in m
x = x0 + v0.*t + 1/2*9.8*t.*t;

该函数演示了一个MATLAB编程技巧: 计算乘法时应尽量使用.*而非*,因为前者不仅对参数t为标量的情况可用,也对变量t为向量或矩阵的情况可用.
freebody(0, 0, 2)			% 得到 19.6000
freebody(0, 0, [0 1 2 3])	% 得到 [0 4.9000 19.6000 44.1000]
freebody(0, 0, [0 1; 2 3])	% 得到 [0 4.9000; 19.6000 44.1000]

MATLAB函数定义示例2
下面函数实现了从华氏温度到摄氏温度的转换,该函数可以识别输入的待转换样例的个数,当输入的待转换样例个数为0时,退出函数.
function F2C()
while 1
    F_degree = input('tempreature in Fahrenheit: ', 's');
    F_degree = str2num(F_degree);
    if isempty(F_degree)
        return
    end
    C_degree = (F_degree-32)*5/9;
    disp(['tempreature in Celsius: ' num2str(C_degree)])
end



(需要按Ctrl+C退出程序)
以函数句柄形式定义函数
我们也可以使用函数句柄的形式定义函数,这更接近数学上的函数定义,其语法如下:
函数句柄 = @(输入变量) 输出变量 

可以直接通过函数句柄调用该方法.
f = @(x) exp(-2*x);
x = 0:0.1:2;
plot(x, f(x));

pdf版本笔记的下载地址: MATLAB02_结构化编程和函数定义（访问密码：3834）

1.数组的定义

用于存储同一类型数据的集合，其实数组就是一个容器。

连续的存储单元

 

2.数组的好处

自动给数组中的元素从零开始编号。自动给下标，从零开始0-1-2-3-……

 

3.书写格式

      元素类型[]  数组名 =    new   元素类型[]{元素，元素，元素……};

3.1 格式1

   int [] arr = new int[5];   

需要手动赋值

arr[0]=1;

arr[1]=2;

arr[3]=3

arr[4]=4;

arr[5]=5;

3.2 格式2

int [] arr = new int[]{1,3,5,7｝    

                        

3.3 格式3

int[]arr = {1,3,5,7};     

 

4.数组的内存结构

 



 

 

5.数组的内存特点

 

（1）.因为使用了关键字new 会在堆内存中开辟相应的空间，分别赋予了两个数组不同的地址。当比较的时候，比较的是两个数组的地址，则为不同

 



（2）.本例虽未使用new 关键字，但是同样的比较的也是数组的地址；



 

 

（3）.此例输出为true



因为他们指的都是同一个对象abc的地址，所以是相同的