1.数组的定义

相同数据类型的数据的有序集合

特点：

1）数组的长度是固定的，数组一旦被创建，长度不可以改变；

2）数组中的元素的数据类型可以是任何类型，包括基本类型和引用类型

3）数组变量是引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

2.数组的声明与创建

1）写法一

声明：

dataType[] arrayRefVar;     //首选

dataType arrayRefVar1[];    //效果相同，但不是首选，是c，c++的风格

创建：

arrayRefVar=new dataType[10];

例子：

int[] nums; //声明数组
nums =new int[10];  //创建数组

2）写法二

声明和创建：

dataType[] arrayRefVar=new dataType[arraySize];

例子：

int[] nums = new int[10];

3）最常用，直接静态初始化

int[] array = {1,2,3,4,5,6,7,8,9,10};

 1 public class Demo02 {
 2     public static void main(String[] args) {
 3         //变量类型  变量名=变量值
 4         //int[] nums; //声明数组
 5         //nums =new int[10];  //创建数组
 6         int[] nums = new int[10];   //声明+创建一个包含10个数的数组
 7         nums[0]=1;  //数组下标从0开始，代表给数组的第一个元素赋值
 8         nums[1]=2;  //给数组的第二个元素赋值
 9         nums[2]=3;
10         nums[3]=4;
11         nums[4]=5;
12         nums[5]=6;
13         nums[6]=7;
14         nums[7]=8;
15         nums[8]=9;
16         nums[9]=10;
17 
18         int sum=0;
19         //求数组所有元素的和
20         for (int i=0;i<=nums.length;i++){
21             sum=sum+i;
22         }
23         System.out.println(sum);
24     }
25 }

package com.rzd.Method;
//数组的声明和创建
public class Demo02 {
    public static void main(String[] args) {
        //变量类型  变量名=变量值
        //int[] nums; //声明数组
        //nums =new int[10];  //创建数组
        int[] nums = new int[10];   //声明+创建一个包含10个数的数组
        nums[0]=1;  //数组下标从0开始，代表给数组的第一个元素赋值
        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;

        int sum=0;
        //求数组所有元素的和
        for (int i=0;i<=nums.length;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

3.内存分析

Java内存

1）堆：存放new的对象和数组；可以被所有线程共享，不会存放别的对象引用

2）栈：存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）

3）方法区：可以被所有的线程共享；包含了所有的class和static变量

4.数组的三种初始化

 1 public class Demo03 {
 2     public static void main(String[] args) {
 3         //静态初始化：创建+赋值
 4         int a[]={1,2,3};
 5         System.out.println(a[0]);
 6 
 7         //动态初始化，包含默认初始化
 8         int[] b = new int[3];
 9         b[0]=1;
10         b[1]=2;
11         System.out.println(b[0]);
12 
13         //默认初始化,c[0]的默认值是int的默认值0
14         int[] c = new int[3];
15         System.out.println(c[0]);
16     }
17 }

package com.rzd.Method;
//数组的三种初始化
public class Demo03 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int a[]={1,2,3};
        System.out.println(a[0]);
        //数组下标越界
        //System.out.println(a[4]);

        //动态初始化，包含默认初始化
        int[] b = new int[3];
        b[0]=1;
        b[1]=2;
        System.out.println(b[0]);

        //默认初始化,c[0]的默认值是int的默认值0
        int[] c = new int[3];
        System.out.println(c[0]);
    }
}

5.数组下标越界

报错信息为：ArrayIndexOutOfBoundsException

数组下标的范围为：[0 ~ length-1]

1         int a[]={1,2,3};
2         System.out.println(a[0]);
3         //数组下标越界
4         System.out.println(a[4]);    　　//报错ArrayIndexOutOfBoundsException

6.数组的使用例子

1）

 1 package com.rzd.Method;
 2 
 3 public class Demo04 {
 4     public static void main(String[] args) {
 5         int[] array = {1,2,3,4,5,6,7,8,9,10};
 6 
 7         //打印全部的数组元素，也就是遍历数组
 8         for (int i=0;i<array.length;i++){
 9             System.out.print(array[i]+"\t");
10         }
11         System.out.println();
12 
13         //增强for循环遍历数组,array表示该数组，i表示数组中的每一个元素。适合遍历，但取不到数组的下标
14         for (int i : array) {
15             System.out.print(i+"\t");
16         }
17         System.out.println();
18         
19         //计算数组所有元素的和
20         int sum=0;
21         for (int i=0;i<array.length;i++){
22             sum+=array[i];   //sum=sum+array[i];
23         }
24         System.out.println(sum);
25 
26         //查找数组的最大元素
27         int max=array[0];
28         for (int i=0;i<array.length;i++){
29             if (array[i]>max){
30                 max=array[i];
31             }
32         }
33         System.out.println(max);
34 
35         //
36     }
37 
38 }

package com.rzd.Method;

public class Demo04 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};

        //打印全部的数组元素，也就是遍历数组
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();

        //增强for循环遍历数组,array表示该数组，i表示数组中的每一个元素。适合遍历，但取不到数组的下标
        for (int i : array) {
            System.out.print(i+"\t");
        }
        System.out.println();
        
        //计算数组所有元素的和
        int sum=0;
        for (int i=0;i<array.length;i++){
            sum+=array[i];   //sum=sum+array[i];
        }
        System.out.println(sum);

        //查找数组的最大元素
        int max=array[0];
        for (int i=0;i<array.length;i++){
            if (array[i]>max){
                max=array[i];
            }
        }
        System.out.println(max);

        //
    }

}


打印数组的方法
反转数组