重点：
 
定义数组
初始化数组
遍历数组
Arrays类
 

 难点：
 
遍历数组
二维数组及使用
 
 

 1.1一维数组
 

 1.1.1定义数组
 

 在Java中，定义数组的语法有两种。
 

 语法：
 
 
 
数据类型[] 数组名=new 数据类型[数组长度]；
数组类型 数组名[]=new 数组类型[数组长度]；
 
 

 数组元素分配的初始值：
 
数组元素类型 
默认初始值
byte、short、int、long 
0
float、double  
0.0
char 
'\u0000'
boolean
false
引用数据类型
null
 

 
 
 

 1.1.2数组元素的表示与赋值
 

 由于定义数组时,内存分配的是连续空间,所以数组元素在数组里顺序排列编号,该编号即元素下标,它标明了元素在数组
 中的位置。
 

 语法：
 
 
 数组名[下标值]
 

 1.1.3数组的初始化
 

 所谓数组初始化，就是在
 定义数组的同时一并完成赋值操作。
 

 语法：
 
 
 
数据类型 [] 数组名={值1,值2,值3，……,值n};
数组类型 [] 数组名=new 数据类型[]{值1,值2,值3,……,值n}
 
 

 1.1.4遍历数组
 

 在编写程序时，数组和循环往往结合在一起使用，可以大大地简化代码，提高程序效率。通常，使用for循环遍历数组。
 
 

 2.1二维数组
 

 Java中定义和操作多维数组的语法与一维数组类似。在实际应用中，三维及以上的数组很少使用，主要使用二维数组。
 

 语法：
 
 
 
数组类型 [][] 数组名;
数组类型 数组 [][];
 
 

 需要强调的是，虽然从语法上看，Java支持多维数组，但从内存分配原理的角度讲，Java中只有一维数组，没有多维
 数组。或者说，表面上是多维数组，实质上都是一维数组。
 

 2.2二维数组及其使用
 

 1.初始化二维数组
 

 二维数组也可以进行初始化操作，与一维数组类似，同样采用如下两种方式，要注意大括号的结构及书写顺序。
 

 例:
 
 
 
int[][] score=new int[][]{{90,32,43,43,23},{42,32,44},{67}};
int score[][]={{90,32,43,43,23},{42,32,44},{67}};
 
 

 2.二维数组的遍历
 

 例:
 
 
 

  public static void main(String[] args){
 
 
 

     int [][] array=new int[][]{{90,32,43,43,23},{42,32,44},{67}};
 
 
 

     int total;
 
 
 

     for(int i=0;i<array.length;i++){
 
 
 

         String str=(i+1)+"班";
 
 
 

         total=0;
 
 
 

         for(int j=0;j<array[i].length;j++){
 
 
 

          total+=array[i][j];
 
 
 

         }
 
 
 

         System.out.println(str+"总成绩:"+total);
 
 
 

     }
 
 
 

  }
 
 
 

 3.1Arrays类及其常用方法
 

 JDK中提供了一个专门用于操作数组的工具类，
 即Arrays类，位于java.util包中。该类提供了一系列方法来操作数
 组，如
 排列、复制、比较、填充等
 ，用户直接调用这些方法即可，不需要自己编写实现，降低了开发难度。
 

 Arrays类常用方法：
 
返回类型  
方法 
说明
boolean 
equals(array1,array2)
比较两个数组是否相等
void  
shrt(array)
对数组array的元素进行升序排列
String
toString()
将一个数组array转换成一个字符串
void 
fill(array,val)
把数组array的所有元素都赋值为val
与array数组类型一致
copyOf(array,length)
把数组array复制成一个长度为length的新数组
int
binarySearch(array,val)
查询元素值val在数组array中的下标
 
 

 总结：
 
数组是可以再内存中连续存储多个元素的结构。数组中的所有元素必须属于相同的数据类型。
数组中的元素通过数组下标进行访问，数组下标从0开始。
二维数组实际上是一个一维数组，它的每个元素又是一个一维数组。
使用Array类提供的方法可以方便地对数组中的元素进行排序、查询等操作。
JDK1.5之后提供了增强for循环，可以用来实现对数组和集合中数据的访问。

javascript 数组以及对象的深拷贝（复制数组或复制对象）的方法
 
前言
 
在js中，数组和对象的复制如果使用=号来进行复制，那只是浅拷贝。如下图演示：
 
 如上，arr的修改，会影响arr2的值，这显然在绝大多数情况下，并不是我们所需要的结果。
 因此，数组以及对象的深拷贝就是javascript的一个基本功了。
 
 
 
评论中有很多人说我误导大家。说这些都是浅拷贝。我不做过深的阐述，本文中涉及到的都是比较浅显的内容。诸位请根据自己的需要以及情况自行判断和理解。
 
 
数组的深拷贝
 
条条大道通罗马，实现数组的深拷贝，是有好几种方法的。举例如下：
 
for 循环实现数组的深拷贝
 
for循环是非常好用的。如果不知道高级方法，通过for循环能够完成我们大多数的需求。
 
var arr = [1,2,3,4,5]
var arr2 = copyArr(arr)
function copyArr(arr) {
	let res = []
	for (let i = 0; i < arr.length; i++) {
	 res.push(arr[i])
	}
	return res
}
 
如上，通过对数组的for循环，即可实现对数组的深拷贝了。
 
slice 方法实现数组的深拷贝
 
这个代码实现非常简单。原理也比较好理解，他是将原数组中抽离部分出来形成一个新数组。我们只要设置为抽离全部，即可完成数组的深拷贝。代码如下：
 
var arr = [1,2,3,4,5]
var arr2 = arr.slice(0)
arr[2] = 5
console.log(arr)
console.log(arr2)
 
运行结果如下：
 
 更多 slice 内容请访问 w3school JavaScript slice 方法
 
 
concat 方法实现数组的深拷贝
 
这个代码也非常简单，原理更加粗暴。它是用于连接多个数组组成一个新的数组的方法。那么，我们只要连接它自己，即可完成数组的深拷贝。代码如下：
 
var arr = [1,2,3,4,5]
var arr2 = arr.concat()
arr[2] = 5
console.log(arr)
console.log(arr2)
 
运行结果如下：
 
 更多 concat 内容请访问 w3school JavaScript concat 方法
 
 
2017年10月31日补充：ES6扩展运算符实现数组的深拷贝
 
OK，以上之前讲的方法全部过时了，用下面的方法实现数组的深拷贝是最简单的。
 
var arr = [1,2,3,4,5]
var [ ...arr2 ] = arr
arr[2] = 5
console.log(arr)
console.log(arr2)
 
运行结果如下：
 
 
对象的深拷贝
 
对象的深拷贝相比数组也没有困难许多，列举两个方法。
 
万能的for循环实现对象的深拷贝
 
在很多时候，for循环能够解决大问题。
 
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var obj2 = copyObj(obj)
function copyObj(obj) {
  let res = {}
  for (var key in obj) {
    res[key] = obj[key]
  }
  return res
}
 
转换成json再转换成对象实现对象的深拷贝
 
上面的代码实在是比较长，所以，用一个更暴力的方法吧！代码如下：
 
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var obj2 = JSON.parse(JSON.stringify(obj))
 
这个原理没什么好解释的，实在是够简单粗暴的啦！
 
2017年10月31日补充： 扩展运算符实现对象的深拷贝
 
var obj = {
  name: 'FungLeo',
  sex: 'man',
  old: '18'
}
var { ...obj2 } = obj
obj.old = '22'
console.log(obj)
console.log(obj2)
 
运行结果如下：
 
 
小结
 
数组和对象的深拷贝是js中最常见的应用。理解各种方法是必须的。希望对大家有所帮助。
 本文中并没有对异常进行处理，主要在讲原理。更多的数组以及对象的操作方法，可以参考lodash的源码，查看它的源码可以让你的js基础变得非常牢固。我也在学习中。
 
 
 
2017年10月31日补充，使用es6提供的扩展运算符的方法实现深拷贝，简单，高效。并且，对象的深拷贝不会像使用 JSON 方法深拷贝一样，丢失函数等信息，只能用来深拷贝 JSON 数据格式的对象。推荐大家使用。
 
 
补充一个数组去重的方法
 
function dedupe(array) {
  return [...new Set(array)]
}
var arr = [1,2,2,3,3,4,4,5,5]
console.log(dedupe(arr))
 
运行结果如下：
 
 
2021年03月29日 补充
 
这里说的深拷贝，都是指一维的数组和对象的深拷贝。鉴于评论中多人指出，这些是浅拷贝，我本来不想回应，但是提出这个观点的人很多，因此我在这边回应一下。
 
浅拷贝的概念不重复了，上文中已经说明。文章中的多种方法，均不是浅拷贝，只是是否支持多维数据而已。而在绝大多数场景下，文中的方法是适用的。
 
想要简便的支持多维数据的深拷贝，可以直接适用 JSON 方式。或适用 lodash 工具实现。
 
版权申明：本文由FungLeo原创，允许转载，但转载必须附注首发链接。谢谢。

1 数组
 
1.1 概念
 
数组Array，标志是[ ] ,用于储存多个相同类型数据的集合
 想要获取数组中的元素值，可以通过脚标（下标）来获取
 数组下标是从0开始的,下标的最大值是数组的长度减1
 
 
1.2 创建数组
 
数组的创建方式一般分为动态初始化和静态初始化
 
动态初始化
 int[] a = new int[5];
静态初始化
 int[] b = new int[]{1,2,3,4,5};
 int[] c = {1,2,3,4,5};
 
1.3 创建数组过程分析
 
程序创建数组 int[] a = new int[5]; 时发生了什么?
 
在内存中开辟连续的空间,用来存放数据,长度是5
给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
数组完成初始化会分配一个唯一的地址值
把唯一的地址值交给引用类型的变量a去保存
 
 
 
数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据
 
 
1.4 数组的长度
 
数组的长度用 length属性来表示,数组一旦创建，长度不可改变
 数组的长度允许为0
 
1.5 练习：向数组中存入数据hello
 

 创建包: cn.tedu.array
 创建类: TestCreateArray.java
 
package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的创建*/
public class TestCreateArray {
	public static void main(String[] args) {
		//1.创建数组
		//1.1静态创建--创建的时候已经知道了每一个元素的值
		char[] c1 = {'h','e','l','l','o'};
		char[] c2 = new char[] {'h','e','l','l','o'};
		
		//1.2动态创建--知道了数组的长度，后面再具体赋值
		char[] c3 = new char[5];//在内存中开辟一块连续的内存空间，用来存放5个字符
		//1.2.2给c3数组动态的赋值
		/**我们通过数组的下标来操作数组中的每一个元素，注意数组下标从0开始*/
		c3[0] = 'h';//给数组中的第1个元素赋值
		c3[1] = 'e';//给数组中的第2个元素赋值
		c3[2] = 'l';//给数组中的第3个元素赋值
		c3[3] = 'l';//给数组中的第4个元素赋值
		c3[4] = 'o';//给数组中的第5个元素赋值
		
		//2.打印查看刚刚创建好的数组
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		
		//3.创建String类型的数组，存放数据"a","b","c"
		String[] s1 = {"a","b","c"};
		String[] s2 = new String[] {"a","b","c"};
		String[] s3 = new String[3];
		s3[0] = "a";//给s3数组的第1个元素赋值为"a"
		s3[1] = "b";//给s3数组的第2个元素赋值为"b"
		s3[2] = "c";//给s3数组的第3个元素赋值为"c"
		
		/**char类型的数组底层中做了处理，可以直接打印数组中的具体元素
		 * 除了char类型以外的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays
		 * 具体方式：Arrays.toString(数组名);
		 * 注意Arrays使用时需要导包*/
		//4.打印创建好的数组
		System.out.println(s1);//打印出来的是数组的地址值
		System.out.println(Arrays.toString(s2));
		
		//5.查看数组的长度--数组中存放的元素的个数
		/**数组一旦创建，长度不可改变，如果想要增加/删除数组中的元素
		 * 只能先创建一个新长度的数组，再将原来的数据复制过去*/
		System.out.println(c1.length);
		System.out.println(s1.length);
		
	}
	
}
 
1.6 数组的遍历
 
遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
 我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标
 
开始:开始下标0 结束:结束下标length-1 如何变化:++
 for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
 循环体;
 }`
 
1.7 练习-1：输出每个月的天数
 
创建类: TestArrayExec.java
 
package cn.tedu.array;
/**本类用于练习数组的遍历
 * 需求:输出一年中每个月份的天数
 * */
public class TestArrayExec {
	public static void main(String[] args) {
		m ();//本方法用于输出每个月的天数,快速修复快捷键Ctrl+1
	}
	//打印需求:例如 1月有31天
	public static void m () {
		//1.创建数组用来存12个月的天数
		int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};
		
		//2.输出每个月的天数打印到控制台
		//数组的遍历--通过循环的方式--操作的是数组的下标
		//循环开始:a[0]--数组中的第一个元素
		//循环结束:a[a.length-1]--数组中的最后一个元素
		//如何变化:++
		//for(int i = 0 ; i <=a.length-1 ; i++) {
		for(int i = 0 ; i <a.length ; i++) {
			//a[i]--根据下标i来获取数组a中对应位置上元素的值
			System.out.println((i+1)+"月有:"+a[i]+"天");
		}
	}
}
 
1.8 练习-2：遍历数组，存入1到10
 
//需求:遍历数组,存入1-10
	public static void m2() {
		//1.创建数组--动态创建
		int[] a = new int[10];
		
		//2.遍历数组,依次给每个位置赋值
		//循环开始:a[0]--数组中的第一个元素
		//循环结束:a[a.length-1]--数组中的最后一个元素
		//如何变化:++
		for(int i = 0 ; i <= a.length-1 ; i++) {
			//a[i]--根据下标i来获取数组a中对应位置上元素的值
			a[i] = i+1;
		}//for循环结束
		//3.在存入10个数据之后,打印a数组
		System.out.println(a);//[I@15db9742
		//除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays
		//Arrays.toString(要打印的数组的名字)来查看数组中的具体内容
		System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		
	}
 
1.9 练习-3：创建随机数组
 
需求:创建数组,数组中的内容是100以内的随机数
 
public static void m3() {
	//1.创建数组--动态
	int[] a = new int[10];
	//2.遍历数组,给数组中的每个元素赋值
	for(int i = 0 ; i <a.length ; i++) {
		//100是自定义的数据,表示生成的随机整数的范围是[0,100)
		a[i] = new Random().nextInt(100);
		//a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
	}
	//3.使用数组的工具类查看数组中的元素
	System.out.println(Arrays.toString(a));
}
 
2 数组工具类Arrays
 
2.1 Arrays.toString(数组)
 
把数组里的数据,用逗号连接成一个字符串[值1,值2]
 
2.2 Arrays.sort(数组)
 
对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
对引用类型数组,使用的是优化后的合并排序算法
 
2.3 练习：练习Arrays.sort(数组)
 
创建类: TestArraysSort.java
 
package cn.tedu.array;

import java.util.Arrays;

/**本类用于测试数组的工具类Arrays*/
public class TestArraysSort {
	public static void main(String[] args) {
		//1.创建无序数组
		int[] a = {21,96,75,23,25};
		
		//底层使用的排序算法是进行优化后的快速排序算法
		Arrays.sort(a);//对无序数组进行直接排序
		System.out.println(Arrays.toString(a));
	}
}
 
2.4 Arrays.copyOf(数组，新的长度)
 
把数组赋值成一个指定长度的新数组
 新数组的长度 大于 原数组, 相当于复制,并增加位置
 新数组的长度 小于 原数组, 相当于截取一部分数据
 
2.5 练习：练习Arrays. copyOf(数组，新的长度)
 
创建类: TestArraysCopyOf.java
 
package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的缩容与扩容*/
public class TestArraysCopyOf {
	public static void main(String[] args) {
		//1.创建数组
		int[] from = {1,2,3,4,5};//数组一旦创建，长度不可改变
		
		//2.1 数组的普通复制
		/**copyOf()用于完成数组的复制，两个参数：
		 * 参数1：要复制哪个数组
		 * 参数2：新数组的长度*/
		int[] to = Arrays.copyOf(from, 5);
		System.out.println(Arrays.toString(to));
		
		//2.2数组的扩容
		/**扩容：给数组扩大容量，新数组的长度>原数组的长度
		 * 扩容思路：先创建对应长度的新数组，每个位置上都是默认值0
		 * 然后从原数组中将元素复制到新数组，没有被覆盖的元素还是默认值0*/
		int[] to2 = Arrays.copyOf(from, 10);
		System.out.println(Arrays.toString(to2));
		
		//2.3数组的缩容
		/**缩容：缩小数组的容量，新数组的长度<原数组的长度
		 * 缩容思路：先创建对应长度的新数组，每个位置上都是默认值0
		 * 然后从原数组中复制指定个数的元素到新数组中，类似于截取*/
		int[] to3 = Arrays.copyOf(from, 3);
		System.out.println(Arrays.toString(to3));
		
		//2.4指定首尾截取原数组中的元素
		/**copyOfRange()用于完成数组的截取，3个参数：
		 * 参数1：要截取哪个数组【原数组】
		 * 参数2：从原数组的哪个下标开始
		 * 参数3：到原数组的哪个下标结束
		 * 注意：截取的元素包含开始下标处的元素，不包含结束下标处的元素*/
		int[] to4 = Arrays.copyOfRange(from, 2, 4);
		System.out.println(Arrays.toString(to4));
	}
}
 
3 拓展之二维数组
 
3.1 概念
 
存放数组的数组，也就是说数组里存的还是数组的数据形式
 
 
3.2 创建二维数组
 
int[][] a = {{3,5},{7,9},{1,2}};
 –创建外部数组,长度是3
 –给每个外部数组的位置创建内部数组,每个内部数组的长度是2
 –给每个内部数组进行数据初始化
 –二维数组生成唯一的地址值
 –把地址值交给引用类型变量a来保存
 
3.3 遍历二维数组
 
for (int i = 0; i < a.length; i++) {//遍历外部数组
 for (int j = 0; j < a[i].length; j++) {//遍历内部数组
 System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
 }
 }
 
3.4 打印二维数组中的数据
 
package cn.tedu.array;

import java.util.Arrays;

/**本类用于打印二维数组中的数据*/
public class TestArrays2 {
	public static void main(String[] args) {
		//1.创建二维数组
		//    3      5    
		//a[0][0] a[0][1]
		//    7       9
		//[1][0] a[1][1] 
		//    1       2      3
		//a[2][0] a[2][1] a[2][2]
		int[][] a = {{3,5},{7,9},{1,2,3}};
		
		//2.遍历二维数组
		for (int i = 0; i < a.length; i++) {
//			System.out.println(Arrays.toString(a[i]));
			for (int j = 0; j < a[i].length; j++) {
				//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
				System.out.print(a[i][j]);
			}
			System.out.println();
		}
	}
}

 
文章目录
 
一、一维数组的创建和初始化
1.数组的创建
2.数组的初始化
3.一维数组的使用
4.一维数组在内存中的存储
  
二、二维数组的创建和初始化
1.二维数组的创建
2.二维数组的创建
3.二维数组的创建
4.二维数组在内存中的存储
  
二、数组越界
1. 数组名是什么?
 

 
 
一、一维数组的创建和初始化
 
1.数组的创建
 
数组是一组相同类型元素的集合。
 数组的创建方式：
 
type_t   arr_name[const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小
 
数组创建的实例:
 
//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];
//数组时候可以正常创建？
//代码3
char arr3[10];
float arr4[1];
double arr5[20];
 
注：数组创建，[]中要给一个常量才可以，不能使用变量。
 
2.数组的初始化
 
数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
 看代码：
 
int arr1[10] = { 1,2,3 };
int arr2[] = { 1,2,3,4 }; 
int arr3[5] = { 1，2，3，4，5 }；
char arr4[3] = { 'a',98, 'c' }; 
char arr5[] = { 'a','b','c' }; 
char arr6[] = "abcdef";
 
数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。
 但是对于下面的代码要区分，内存中如何分配。
 
char arr1[] = "abc";
char arr2[3] = {'a','b','c'};
 
3.一维数组的使用
 
对于数组的使用我们之前介绍了一个操作符：[]，下标引用操作符。它其实就数组访问的操作符。我们来看代码：
 
#include <stdio.h>
int main(){    
	int arr[10] = {0};
	//数组的不完全初始化   
	//计算数组的元素个数    
	int sz = sizeof(arr)/sizeof(arr[0]);  
	//对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：    
	int i = 0;
	for(i=0; i<10; ++i)    {
		printf("%d ", arr[i]);   
	}    return 0;
}
 
总结:
 
数组是使用下标来访问的，下标是从0开始。
 2.数组的大小可以通过计算得到。
 
4.一维数组在内存中的存储
 
接下来我们探讨数组在内存中的存储。
 看代码
 
#include <stdio.h>
int main() {
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
		printf("&arr[%d] = %p\n", i, &arr[i]);
	}
	return 0;
}
 

 仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
 由此可以得出结论：数组在内存中是连续存放的。
 
二、二维数组的创建和初始化
 
1.二维数组的创建
 
//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];
 
2.二维数组的创建
 
//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};
 
3.二维数组的创建
 
二维数组的使用也是通过下标的方式。
 看代码：
 
#include <stdio.h>
int main(){   
	int arr[3][4] = {0};   
	int i = 0;   
	for(i=0; i<3; i++)    {
		int j = 0;
		for(j=0; j<4; j++)        {
			arr[i][j] = i*4+j;      
		}  
		  }    
	for(i=0; i<3; i++)    {
		int j = 0;
		for(j=0; j<4; j++)        {
			printf("%d ", arr[i][j]);     
		}   
		 }    
	return 0;
}
 
4.二维数组在内存中的存储
 
像一维数组一样，这里我们尝试打印二维数组的每个元素。
 
#include <stdio.h>
int main(){   
	int arr[3][4];  
	int i = 0;    
	for(i=0; i<3; i++)    {
		int j = 0; 
		for (j = 0; j < 4; j++) { 
			printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
		}
	}   
	return 0;
}
 

 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。
 
二、数组越界
 
数组的下标是有范围限制的。
 数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
 所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
 C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。
 
#include <stdio.h>
int main(){    
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};  
	int i = 0;    
	for(i=0; i<=10; i++)    {
		printf("%d\n", arr[i]);//当i等于10的时候，越界访问了   
	}    
	return 0;
}
 
二维数组的行和列也可能存在越界。
 
1. 数组名是什么?
 
#include <stdio.h>
int main(){    
	int arr[10] = {1,2,3,4,5};    
	printf("%p\n", arr);   
	printf("%p\n", &arr[0]);   
	printf("%d\n", *arr);    
	//输出结果    
	return 0;
}
 
结论：
 数组名是数组首元素的地址。（有两个例外）
 如果数组名是首元素地址，那么：
 
int arr[10] = {0};
printf("%d\n", sizeof(arr));
 
为什么输出的结果是：40？
 补充：
 
sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
&数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。