数组是相同类型数据的有序集合
数组描述的是相同的若干个数据，按照一定的先后次序排列组合而成
其中，每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问他们
数组的下标是从0开始的
首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法
dataType[] arrayRefVar;// 首选的方法
dataType arrayRefVar[];// 不是首选的方法
Java语言中使用new操作，来创建数组，语法如下
dataType[] arrayRefVar = new dataTyoe[arraySize];
数组的元素是通过索引访问的，数组索引是从 0 开始的
用 .length 来获取数组的长度
如果不对数组里面赋值的话则是默认值int 的默认值就是0
DEMO
public class Demo01 {
// 变量的类型 变量的名字 = 变量的值
//数组类型
public static void main(String[] args) {
?
int[] nums;//1.声明了一个数组
?
nums = new int[10];//2.创建一个数组 这里面可以存放十个int类型的数字
int[] ints = new int[10];//也可以声明创建一起来做
?
//3.给数组元素中赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
?
System.out.println(nums[9]);
?
//计算所有元素的和
int sum=0;
//获取数组长度 arrays。length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
?
}
System.out.println("总和为："+sum);
}
}
静态初始化
动态初始化
数组的默认值初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量的方式被隐式初始化
public class Demo02 {
public static void main(String[] args) {
//静态初始化：创建加赋值
int[] a = {1, 2, 3, 4, 5, 6};
System.out.println(a[0]);
//动态初始化：包含默认初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]);
System.out.println(b[1]);
}
}
其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组的变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中
下标的合法区间：[0,length - 1],如果越界就会报错
public static void main(String[] args){
int[] a = new int[2];//创建了有两个空间的数组
System.out.println(a[2]);//下标越界
}
ArraylndexOutOfBoundsException : 数组下标越界异常！
小结：
数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组的长度确定，不可改变的，如果越界，则报：ArraylndexOutOfBoundsException
普通for循环使用
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
?
//打印全部的元素
for (int i=0;i<arrays.length;i++){
System.out.println(arrays[i]);
}
?
//计算所有元素的总和
int sum = 0;
for (int a=0;a<arrays.length;a++){
sum = sum + arrays[a];
}
System.out.println(sum);
?
//查找最大元素
int b = 0;
for (int i=0;i<arrays.length;i++){
if (b>arrays[i]){
b = b;
}else{
b = arrays[i];
}
}
System.out.println(b);
}
}
for-Each 循环
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
?
//JDK1.5,没有下标
//for-each 循环使用 增强型的for循环
for (int array : arrays) {
//int array 数组中的每一个元素 arrays数组
System.out.println(array);
}
}
这个没有下标适合打印输出要使用下标的话这个就不合适了这个取不到下标
数组做方法参入
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
printarry(arrays);
}
?
//打印数组元素 数组做方法如参
public static void printarry(int[] arrys){
for (int i = 0; i < arrys.length; i++) {
System.out.print(arrys[i]+" ");
}
}
数组作返回值
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
int[] ints = fanZhuan(arrays);
//打印输入数组ints
for{int i =0;i<ints.length,i++}{
System.out.print(ints[i]);
}
}
//反转数组 数组做返回值入惨
public static int[] fanZhuan(int[] array){
int[] b = new int[array.length];
for (int i = 0,j=array.length-1; i <array.length ; i++,j--) {
b[i] = array[j];
}
?
return b;
}
}
多为数组额可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组堆
二维数组：
int a[][] = new int [4][2]
解析：以上数组a可以看成一个四行两列的一个数组
public static void main(String[] args) {
//二维数组
int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
/*
1, 2 array[0] 1 array[0][0]
2 array[0][1]
?
2, 3 array[1] 2 array[1][0]
3 array[1][1]
?
3, 4 array[2] 3 array[2][0]
4 array[2][1]
?
4, 5 array[3] 4 array[3][0]
5 array[3][1]
*/
printarry(array[0]);//用方法打印出数组
erWei(array);//打印二维数组
}
?
//打印数组元素 数组做方法如参
public static void printarry(int[] arrys){
for (int i = 0; i < arrys.length; i++) {
System.out.println(arrys[i]);
}
}
//打印二位数组
public static void erWei(int [][] ace){
for (int i = 0; i <ace.length ; i++) {
for (int j = 0; j <ace[j].length ; j++) {
System.out.print(ace[i][j]+" ");
}
System.out.println();
}
}
原文：https://www.cnblogs.com/dengyi102986/p/14731322.html