一维数组：
 
 
 
二维数组：
 
写代码的时候需要使用python创建二维数组：
 
num_list = [ [0]*5 ]*2
 print(num_list)
 输出：[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
 
看输出觉得这种方法是对的，结果程序出现了错误，经过分析，这种创建二维数组的方式存在问题
 
num_list[0][0] = 1
 print(num_list)
 输出：[[1, 0, 0, 0, 0], [1, 0, 0, 0, 0]]  
 
当改变num_list[0][0]的时候，num_list[1][0]也改变了
 
上面创建方式等价于
 
temp_list = [0]*5
 num_list = [temp_list,temp_list]
 因此 num_list[0][0] = 1  相当于 temp_list[0] = 1,所以num_list[1][0]也跟着变了
 
 
 
正确的创建二维数组可以使用以下两种方法：
 
num_list = [ [0] * 5 for i in range(2)]
 测试：
 
print(num_list)
 num_list[0][0] = 1
 print(num_list)
  
 输出：
 [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
 [[1, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
  
 
或者使用numpy库
 
import numpy
 num_list = numpy.zeros((2,5))
 测试：
 
print(num_list)
 print(type(num_list))
 num_list[0][0] = 1
 print(num_list)
  
 输出：
 [[ 0.  0.  0.  0.  0.]
  [ 0.  0.  0.  0.  0.]]
 <class 'numpy.ndarray'>
 [[ 1.  0.  0.  0.  0.]
  [ 0.  0.  0.  0.  0.]]
  

一维数组实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。本文将重点介绍一维数组的创建、初始化和使用。
 
创建一维数组
 
为了在程序中使用一个数组，必须声明一个引用该数组的变量，并指明整个变量可以引用的数组类型。声明一维数组的语法格式为：
 
数据类型数组名[];    //声明数组
 
或者
 
数据类型[]数组名;    //声明数组
 

 以上两种格式都可以声明一个数组，其中的数据类型既可以是基本数据类型，也可以是引用数据类型。数组名可以是任意合法的变量名。声明数组就是要告诉计算机该数组中数据的类型是什么。例如：
 
 
 
int[] score; //存储学生的成绩，类型为整型
double[] price; //存储商品的价格，类型为浮点型
String[] name; //存储商品名称，类型为字符串型

 在声明数组时不需要规定数组的长度，例如：
 
 
 
int score[10]; //这是错误的

 注意：在声明数组变量时千万不要漏写[]。
 
分配空间
 
声明了数组，只是得到了一个存放数组的变量，并没有为数组元素分配内存空间，不能使用。因此要为数组分配内存空间，这样数组的每一个元素才有一个空间进行存储。

 简单地说，分配空间就是要告诉计算机在内存中为它分配几个连续的位置来存储数据。在 Java 中可以使用 new 关键字来给数组分配空间。分配空间的语法格式如下：
 
数组名=new 数据类型[数组长度];    //分配空间
 

 其中，数组长度就是数组中能存放的元素个数，显然应该为大于 0 的整数，例如：
 
 
 
score=new int[10];
price=new double[30];
name=new String[20];

 这里的 score 是已经声明过的 int[] 类型的变量，当然也可以在声明数组时就给它分配空间，语法格式如下：
 
数据类型[]数组名=new 数据类型[数组长度];
 
例 1
 
例如，声明并分配一个长度为 5 的 int 类型数组 arr，代码如下：
 
 
 
int arr=new int[5];

 执行后 arr 数组在内存中的格式如图 1 所示。
  
 

 图1 一维数组的内存格式
 

 在图 1 中 arr 为数组名称，方括号“[]”中的值为数组的下标。数组通过下标来区分数组中不同的元素，并且下标是从 0 开始的。因此这里包含 5 个元素的 arr 数组最大下标为 4。

 注意：一旦声明了数组的大小，就不能再修改。这里的数组长度也是必需的，不能少。

 尽管数组可以存储一组基本数据类型的元素，但是数组整体属于引用数据类型。当声明一个数组变量时，其实是创建了一个类型为“数据类型[]”（如 int[]、double[], String[]）的数组对象，它具有表 1 所示的方法和属性。
  
 

  表1 数组的方法和属性
 
方法
名称
返回值
clone()
Object
equals(Object obj)
boolean
getClass()
Class<?>
hashCode()
int
notify()
void
notify All()
void
toString()
String
wait()
void
wait(long timeout)
void
wait(long timeout,int nanos)
void
属性
length
int
 
 
初始化一维数组
 
数组可以进行初始化操作，在初始化数组的同时，可以指定数组的大小，也可以分别初始化数组中的每一个元素。在 Java 语言中，初始化数组有以下 3 种方式。
 
使用 new 指定数组大小后进行初始化
 
使用 new 关键字创建数组，在创建时指定数组的大小。语法如下：
 
type[] array=new int[size];
 

 创建数组之后，元素的值并不确定，需要为每一个数组的元素进行赋值，其下标从 0 开始。
 
例 2
 
创建包含 5 个元素的 int 类型的数组，然后分别将元素的值设置为 1、2、3、5 和 8。代码如下：
 
 
 
int[] number=new int[5];
number[0]=1;
number[1]=2;
number[2]=3;
number[3]=5;
number[4]=8;

 注意：使用 new 创建数组之后，它还只是一个引用，直接将值赋给引用，初始化过程才算结束。
 
使用 new 指定数组元素的值
 
使用上述方式初始化数组时，只有在为元素赋值时才确定值。可以不使用上述方式，而是在初始化时就已经确定值。语法如下：
 
type[] array=new type[]{值 1,值 2,值 3,值 4,• • •,值 n};
 
例 3
 
更改例 2 中的代码，使用 new 直接指定数组元素的值。代码如下：
 
 
 
int[] number=new int[]{1, 2, 3, 5, 8};
上述代码的效果等价于例 2 的效果。
 
直接指定数组元素的值
 
在上述两种方式的语法中，type 可以省略，如果已经声明数组变量，那么直接使用这两种方式进行初始化。如果不想使用上述两种方式，那么可以不使用 new 直接指定数组元素的值。语法如下：
 
type[] array={值 1,值 2,值 3,值 值 n};
 
例 4
 
在前面例子的基础上更改代码，直接使用上述语法实现 number 数组的初始化。代码如下：
 
 
 
int[] number={1,2,3,5,8};

 使用这种方式时，数组的声明和初始化操作要同步，即不能省略数组变量的类型。如下的代码就是错误的：
 
 
 
int[] number;
number={1,2,3,5,8};
获取单个元素
 
获取单个元素是指获取数组中的一个元素，如第一个元素或最后一个元素。获取单个元素的方法非常简单，指定元素所在数组的下标即可。语法如下：
 
array[index];
 

 其中，array 表示数组变量，index 表示下标，下标为 0 表示获取第一个元素，下标为 array.length-1 表示获取最后一个元素。当指定的下标值超出数组的总长度时，会拋出 ArraylndexOutOfBoundsException 异常。
 
例 5
 
获取 number 数组中的第一个元素和最后一个元素，并将元素的值输出。代码如下：
 
 
 
int[] number={1,2,3,5,8};
System.out.println("获取第一个元素："+number[0]);
System.out.println("获取最后一个元素："+number[number.length-1]);

 执行上述代码，输出结果如下所示：
 
获取第一个元素：1
获取最后一个元素：8
 
例 6
 
编写一个 Java 程序，使用数组存放录入的 5 件商品价格，然后使用下标访问第 3 个元素的值。
 
 
 
import java.util.Scanner;
public class Test06
{
public static void main(String[] args)
{
int[] prices=new int[5]; //声明数组并分配空间
Scanner input=new Scanner(System.in); //接收用户从控制台输入的数据
for(int i=0;i<prices.length;i++)
{
System.out.println("请输入第"+(i+1)+"件商品的价格：");
prices[i]=input.nextInt(); //接收用户从控制台输入的数据
}
System.out.println("第 3 件商品的价格为："+prices[2]);
}
}

 上述代码的“int[] prices=new int[5]”语句创建了需要 5 个元素空间的 prices 数组，然后结合 for 循环向数组中的每个元素赋值。

 数组的索引从 0 开始，而 for 循环中的变量 i 也从 0 开始，因此 score 数组中的元素可以使用 scored 来表示，大大简化了代码。最后使用 prices[2] 获取 prices 数组的第 3 个元素，最终运行效果如下所示。
 
请输入第1件商品的价格：
5
请输入第2件商品的价格：
4
请输入第3件商品的价格：
6
请输入第4件商品的价格：
4
请输入第5件商品的价格：
8
第 3 件商品的价格为：6
 
获取全部元素
 
当数组中的元素数量不多时，要获取数组中的全部元素，可以使用下标逐个获取元素。但是，如果数组中的元素过多，再使用单个下标则显得烦琐，此时使用一种简单的方法可以获取全部元素——使用循环语句。

 下面利用 for 循环语句遍历 number 数组中的全部元素，并将元素的值输出。代码如下：
 
 
 
int[] number={1,2,3,5,8};
for (int i=0;i<number.length;i++)
{
System.out.println("第"+(i+1)+"个元素的值是："+number[i]);
}

 除了使用 for 语句，还可以使用 foreach 遍历数组中的元素，并将元素的值输出。代码如下:
 
 
 
for(int val:number)
{
System.out.print("元素的值依次是："+val+"\t");
}

用new创建多维数组时，最后需要用delete，但是我在delete时遇到了麻烦，实在不能再浪费时间了，先mark一下，至少创建多维数组这段是对的
 
 
以int型数组为例，我们知道
 
一维数组  int a[4] ={1,2,3,4};
 
二维数组  int b[3][4] = {1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4}
 
三维数组  int c[2][3][4] = {1,2};
 

 
 
那么用new方式如何创建呢
 
一维数组有
 
 
int *p1 = new int[4];
 
二维数组有
 
 
int (*p2)[4] = new int[3][4];
 

 
 
三维数组
 
int (*p3)[3][4] = new int[2][3][4];//两维三行四列
 

 
 
同样的四位数组
 
int (*p4)[2][3][4] = new int[1][2][3][4];//不知道怎么叫了
 

 
 
忘了从哪里看到的说： 从二维数组开始，定义并不是写成  int *p2[4]、int * p3[3][4]、...这是因为int * p2[4]表示定义一个数组p2，该数组是int *型，数组内的每个元素都是指向int型的指针。
 

	//step 1定义多维数组

	//int *q1 = new int[4];  //创建一维数组，暂时不用
	//int (*q2)[4] = new int[0][4];//创建二位数组，暂时不用
	int (*p)[3][4] =  new int[2][3][4];//创建三维数组，本文研究的重点，我为了少打字，这个变量我定义成了p,并不是p3
	//int (*p4)[3][4][5] = new int [0][3][4][5];//创建四维数组

	//留个标记，用于
	//存放这些数组的指针，用于验证是否delete时会用到
	int *backup[24];
	int imark = 0;

	//循环将三维数组每个元素均赋值为1
	printf("------初始化得到的二维数组----\n");
	for(int i = 0;i< 2;i++)
	{

		for(int j = 0;j<3;j++)
		{
			for(int k = 0;k<4;k++)
			{
				printf("%d --->",(*(*(p+i)+j)+k));//初始化之前均为0
				printf("%d ",*(*(*(p+i)+j)+k));//这里打印了new出来的三维数组，本层循环最后将每个值赋值成了1


				backup[imark++] = (*(*(p+i)+j)+k);
				*(*(*(p+i)+j)+k) = 1;//这里将每个元素赋值成了1，为的是方便后面delete时对比查看

			}
			printf("\n");
		}

	}

	printf("---------------------\n");//

	//step 2 准备检验

	//前辈说书中讲的，数组的大小在之前的四个字节内存储着，究竟是啥呢，在这里可以打印查看printf("front 4 byte is %d, -->%d\n",&p[0][0][0]-1,(int)*(&p[0][0][0]-1));printf("p[0][0][0] address is %d\n",&p[0][0][0]);printf("p[1][2][3] address is %d\n",&p[1][2][3]);printf("\n");//这里尝试了好多种delete的方式都没有成功？？？╮(╯▽╰)╭
	//第一种尝试，直接删除p数组，这个似乎从原理上很容易否定
	/*
	delete []p;//这种方式发现只删除了new出来的前两个元素

	*/

	//第二种尝试，借用一下保存的指针，用指针一个一个去free
	/*
	for(int i =0;i<24;i++)
	{
	delete backup[i];//用backup中记忆的位置一个一个删除，发现行不通，&backup[i]也行不通
	//delete []backup;//这种也是行不通的，我注解上了，可以试试
	}

	*/

	//第三种尝试，嵌套进入生成的数组，一层一层的去free，然而依然失败，不知道是重复删除了，还是怎么了，感觉是重复删除了
	for(int i = 0;i<2;i++)
	{
		for(int j = 0;j<3;j++)
		{
			delete [] p[i][j];
		}
	delete []p[i];
	}


	//第四种尝试，一个一个删，但依然没有成功,我从大到小，先小到大均试了一次，依然失败，下面写的是从大到小
	/*
	delete p[1][2][3];//不要搞混乱，2*3*4维数组最大值就是这个
	delete p[1][2][3];//不列写了，因为占篇幅，可以肯定的是没成功
	//...
	delete p[0][0][0];
	*/


	//这里面检查是否已经delete了
	for (int i = 0; i < 24; i++) {
		if ((i != 0) && (i % 4 == 0))
		{
			printf("\n");
		}
		printf("[%d]%d--->%d ", i, backup[i], (int) *backup[i]);
	}
	printf("\n");
	return 0;


 

 
 
我目前gdb方式还不会看，另外delete还学得不够深入，再钻进去周末别的也就看不成了，所以得先记下。
 

 
 
另外粘一个别人new三维数组的方法
 

int*** a= new int**[5];
for (int i = 0; i < 5; ++i)
{
     a[i] = new int*[6];
     for (int j = 0; j < 6; ++j)
    {
            a[i][j] = new int[7];
     }
}
for (int i = 0; i < 5; ++i)
{
     for (int j = 0; j < 6; ++j)
     {
           delete[] a[i][j];
     }
     delete[] a[i];
}
delete[] a;

 

 
 
就先到这里吧
 
 

 
 

1.解析一维数组的创建和初始化 
 2.一维数组的使用 
 3.一维数组的存储 
 4.一维数组的指针访问 
 5.解析二维数组的创建和初始化 
 6.二维数组的使用 
 7.二维数组的存储 
 8.二维数组的指针访问 
 
1.解析一维数组的创建和初始化
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

//初始化数组
void init(int p[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; ++i)
    {
        p[i] = i;
        printf("%d ", p[i]);
    }
    printf("\n");
}

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void main()
{
    int p[10];//创建一维数组
    int sz = sizeof(p) / sizeof(p[0]);//数组长度
    init(p, sz);//初始化数组
}
 
void main()
{
    int p[10] = {0，1，3，4，5，6，7，8，9};//创建并初始化
    int i = 0;
    for (; i < 10;++i)
    {
        printf("%d ", p[i]);
    }
    printf("\n");
}
 
 
2.一维数组的使用 
 数组名[下标]，如p[0],p[i+1]
 
3.一维数组的存储 
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void main()
{
    int p[10];
    printf("%d\n", sizeof(p));
}
 
输出结果为40，一个整形4字节，10个整形40字节。
 
4.一维数组的指针访问 
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void main()
{
    int p[10] = { 0, 1, 2, 3, 4 };
    int j = 0;
    for (int i = 0; i < 10; ++i)
    {
        printf("%d ", *p);//输出指针所指元素
        *p += 1;//地址+1
    }
}
 
5.解析二维数组的创建和初始化 
 分行初始化 int pp[2][3]={{1,2,3},{4,5,6}}; 
 不分行初始化 int pp[2][3]={1,2,3,4,5,6}; 
 部分初始化 int pp[2][3]={{1,2},{3}}; 
 省略初始化 int pp[][3]={1,2,3,4,5,6};
 
6.二维数组的使用 
 数组名[下标][下标]
 
7.二维数组的存储
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void main()
{
    int pp[3][3];
    printf("%d", sizeof(pp));
}
 
结果为36字节，3*3*int=36字节 
 数组长度sizeof（pp）/sizeof（pp[0][0]）=9
 
8.二维数组的指针访问 
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void main()
{
    int pp[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; 
    int i = 0, j = 0;
    for (i = 0; i < 2; ++i)
    {
        for (j = 0; j < 3; j++)
        {
            printf("%d ", **pp);
            **pp += 1;
        }
        printf("\n");
    }
}
 
输出结果为 
 1 2 3 
 4 5 6