数组

 

数组

• 数组就是存储数据长度固定的容器，要保证多个数据的数据类型一致；

数组声明创建

note：数组有定长特性，长度一旦指定，不可更改；

方式一：

​
// 数组存储的数据类型[] 数组名称 = new 数组存储的数据类型[长度]；
​
int[] nums = new int[10];//定义存储10个整数的数组容器
    

方式二：

//数据类型[] 数组名 = new 数据类型[]{元素1，元素2，……}
​
int[] nums = new int[]{1,2,3};
​

方式三：

数据类型[] 数组名 = {元素1，元素2，……}；

 

数组的访问

• 索引（index）：每个存储到数组的元素，都会自动拥有一个编号，从0开始

这个自动编号我们称索引。数组元素通过索引访问；

// 数组名[index];
//数组长度： 数组名.length
//取出素组元素：
System.out.println(nums[2]);

 

 public static void main(String[] args) {
          int[] nums;//声明一个数组
          nums=new int[3];//创建一个数组
          //------> int[] nums=new int[3];
          nums[0]=1;//数组赋值
          nums[1]=2;
          nums[2]=3;
          //------> int[] nums={1,2,3};
          System.out.println(nums[2]);
      }

数组的几个基本特点

• 长度确定，且不可更改；

• 数组元素可以是任何数据类型，包括基本类型和引用类型，但同一个数组中的元素必须是相同类型；

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

   

Java内存

区域名	作用
寄存器	给CPU使用，与我们无关
本地方法栈	VM在使用操作系统功能时使用，与我们开发无关
方法区	存储可以运行的class文件，可被所有的线程共享，包含了所有的class和static变量
堆内存	存放new的对象和数组，可以被所有线程共享，不会存放别的对象引用
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行； 存放基本变量类型（包含该类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）

 

public static void main(String[] args) {
        //静态初始化
        int[] a={9,3,5,6,7};
        System.out.println(a[0]);// 9
​
        //动态初始化,包含默认初始化
        int[] b=new int[3];
        b[0]=10;
        System.out.println(b[2]);//int型数据默认值为0
​
    }

 

 

数组在内存中的存储

• 一个数组内存圈

  public static void main(String[] args) {
        int[] arr=new int[3];
      //这里的arr只是有三个地址而已，它被称为引用数据类型
        System.out.println(arr);//[I@3f3afe78
    }

我们发现输出的结果是 [I@5f150435，这个是数组在内存中的地址，

new出来的内容，都是在堆内存中存储的，⽽⽅法中的变量array保存的是数组的

地址。

 

• 两个数组内存圈

public static void main(String[] args) { 
 int[] arr = new int[3];
 int[] arr2 = new int[2];
 System.out.println(arr);
 System.out.println(arr2);
}

 

• 两个变量指向⼀个数组

public static void main(String[] args) { 
 // 定义arr数组，存储3个元素
 int[] arr = new int[3]; 
//数组索引进⾏初始化赋值
 arr[0] = 5;
 arr[1] = 6;
 arr[2] = 7;
 //输出3个索引上的元素值
 System.out.println(arr[0]);//5
 System.out.println(arr[1]);
 System.out.println(arr[2]);
 //定义数组变量arr2，将arr的地址赋值给arr2
 int[] arr2 = arr;
 arr2[1] = 9;
 System.out.println(arr[1]); }

数组的几个常见异常

1.数组越界异常

public static void main(String[] args){
    int[] arr={1,2,3};
    System.out.println(arr[3]);//取出arr中第4个数----->越界
}

该数组的索引是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运⾏后，将会抛出

ArrayIndexOutOfBoundsException 数组越界异常。

2.数组空指针异常

• NullPointerException

public static void main(String[] args) { 
 int[] arr = {1,2,3};
 arr = null;     // 变量arr将不会再保存数组的内存地址，此时不允许操作数组
 System.out.println(arr[0]);//   NullPointerException
}

• 空指针异常在内存图中的表现

 

数组的遍历使用

• 将数组中的每个元素分别获取出来，就是遍历

• 数组的索引是 0 到 lenght - 1 ，可以作为循环的条件出现。

​
    public static void main(String[] args) {
        int[] arr={1,2,3};
        for (int i = 0; i < arr.length ; i++) {
            //注意这里只能小于arr.length，如果等于，会有数组越界异常
            System.out.println(arr[i]);
        }
    }

• // 数组遍历

    public static void main(String[] args) {
        int[] arr={1,2,3,45};
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
        //计算总和
        int sum=0;
        for (int i = 0; i < arr.length ; i++) {
            sum=sum+arr[i];
        }
        System.out.println(sum);
​

查找最大元素

• 最⼤值获取:从数组的所有元素中找出最⼤值。

• 实现思路:

• 定义初始元素变量，这里可以是数组0索引上的元素
• 遍历数组，获取出数组中的每个元素
• 将遍历到的元素和保存数组0索引上值的变量进⾏⽐较
• 如果数组元素的值⼤于了变量的值，变量记录住新的值
• 数组循环遍历结束，变量保存的就是数组中的最⼤值

        int max=arr[0];
            //遍历数组，取出每个元素
        for (int i = 1; i < arr.length ; i++) {
            //遍历到的元素和max比较
            if (arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println(max);

 

数组的反转

• 实现思想:实现反转，就需要将数组最远端元素位置交换

• 定义两个变量，保存数组的最⼩索引和最⼤索引
• 两个索引上的元素交换位置
• 最⼩索引++，最⼤索引--，再次交换位置
• 最⼩索引超过了最⼤索引，数组反转操作结束

 

 

 

 

public static void main(String[] args) { 
 int[] arr = { 1, 2, 3, 4, 5 };
 /*
 循环中定义变量min=0最⼩索引 max=arr.length‐1最⼤索引 min++,max‐‐
 */
 for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐)
 { //利⽤第三⽅变量完成数组中的元素交换
 int temp = arr[min];
 arr[min] = arr[max];
 arr[max] = temp;
 }
 // 反转后，遍历数组
 for (int i = 0; i < arr.length; i++) {
 System.out.println(arr[i]);
 }
}

 

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4,5};
​
    int[] result=reverse(arr);
        printArray(result);
    }
    public static int[] reverse(int[] array){
        int[] resule=new int[array.length];
        for (int i=0,j=resule.length-1;i<array.length ;i++,j--){
            resule[j]=array[i];
        }
        return resule;
    }
    public static void printArray(int[] array){
        for (int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }

 

数组作为⽅法参数

public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7，9};
     /*   arr.for+回车// 遍历数组元素
        for (int i : arr) {
        }
     */
    
    printArray(arr); // 调用方法，数组作为方法参数
    
    }
// 打印数组元素
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

数组作为方法返回值

• 返回的是数组的内存地址

public static void main(String[] args) { 
 //调⽤⽅法，接收数组的返回值
 //接收到的是数组的内存地址
 int[] arr = getArray();
 for (int i = 0; i < arr.length; i++) {
 System.out.println(arr[i]);
 /*
 创建⽅法，返回值是数组类型
 return返回数组的地址
 */
public static int[] getArray() { 
 int[] arr = { 1, 3, 5, 7, 9 }; //返回数组的地址，返回到调⽤者 
    return arr;
}

 

 

⽅法的参数类型区别

public static void main(String[] args) { 
    int a = 1;
    int b = 2; 
    System.out.println(a); 
    System.out.println(b); 
    change(a,b);
public static void change(int a, int b) { 
    a = a + b;
    b = b + a; 
}

 

public static void main(String[] args) {
 int[] arr = {1,3,5};
 System.out.println(arr[0]);
 change(arr); 
 System.out.println(arr[0]);
 }
 public static void change(int[] arr) {
     arr[0] = 200;
 }

总结:

• ⽅法的参数为基本类型时,传递的是数据值.

• ⽅法的参数为引⽤类型时,传递的是地址值.

 

二维数组

public static void main(String[] args) {
​
        int[][] arr = {{1,2} ,{2,3}, {3,0},{4,5} };
        //4x2
        /*
        1，2   arr[0]
        2，3   arr[1]
        3，0   arr[2] 
        4，5   arr[3]
       */
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j <arr[i].length ; j++) {
                System.out.print(arr[i][j]);
            }
        }
    }

二维数组类似于往大箱子里面装小箱子，再往小箱子里面放一个“数值”

 

Arrays类

• Arrays类中的方法都是static修饰的静态方法，在使用时可直接使用类名调用，而不用“使用对象来调用”（是“不用“，不是“不能”）

具体方法可查看jdk帮助文档

 

public static void main(String[] args) {
​
        int[] arr={1,3,4,7,8,96,34};
        System.out.println(Arrays.toString(arr));// 打印数组元素 Arrays.toString
​
        Arrays.sort(arr);// 数组排序（升序）
        System.out.println(Arrays.toString(arr));
    }