JAVASE 小白学习笔记（5）详解数组的使用

1.数组的相关概念

1.1 数组的定义

所谓数组，简单地来说就是存储一组相同数据类型的容器。
详细点阐述，就是把有限个类型相同的变量用一个名字命名，这个名字称为数组名，编号称为下标或索引。组成数组的各个变量称为数组的元素。数组中元素的个数称为数组的长度。

   int[] scores = {
     80,90,87,68,99,100,79,96};  
    元素1：scores[0]=80;  数组的长度为8

---

1.2 数组的特点

数组的特点：

数组的特点说明
数组的长度一旦确定就不能修改
创建数组对象会在内存中开辟一整块连续的空间。而数组名中引用的是这块连续空间的首地址
遍历数组和获取某个元素的速度快，因为可以通过数组名+下标，直接定位到任意一个元素

数组既可以存储基本数据类型，也可以存放引用数据类型。
注意数组必须将进行初始化，初始化之后才能使用。
所谓的初始化就是在内存中为数组开辟一块空间，并为数组的元素赋其默认值。

// 基本数据类型元素的数组
int[] scores = {
     80,90,87,68,99,100,79,96};  
scores数组的类型是：int[]
元素的类型是int

// 引用数据类型元素的数组
 String[] strings = {
     “hello”,”java”};
 strings数组的类型是：String[]
 元素的类型是String

---

1.3 数组的分类

数组的分类	分类的结果
按照维度	一维数组、二维数组、多维数组
按照元素的数据类型	基本数据类型元素的数据，引用数据类型元素的数组

---

2. 一维数组

定义数组的语法有动态初始化与静态初始化两种方法。

---

2.1 一维数组的动态初始化

// 动态初始化定义一维数组的语法：
数组名 = new 元素数据类型[数组的长度];
int []arr=new int  [5];//定义int类型的数组，数组的长度为5
double [] arr2=new double  [10]；//定义double类型的数组，长度为10
boolean [] arr3=new boolean  [2]；//定义布尔类型的数组，长度为2

动态初始化就是由我们定义数组的长度，由系统自动为数组的元素赋默认值。

这里需要补充下Java中内存分配以及栈和堆之间的区别：

Java虚拟机在执行java程序的过程中会把它管理的内存分成若干不同的数据区域。 下面是java虚拟机的内存管理图：

现在我们着重对堆和栈以及方法区进行解释说明：

栈与堆存放变量的区别与说明
栈：存放的局部变量。所谓局部变量是在方法中定义或者在方法声明上的变量。
堆：存放的是所有new出来的对象（数组也是对象

堆区具有的特点：
1.每一个new出来的东西都会为其分配一个地址值，而且每一个变量都会有一个默认的值
下面是各个数据类型的默认值（缺省值）

2.使用完毕结束后就会变为垃圾，等待垃圾回收站的回收

方法区：存储的字节码文件

---

2.1.1 一个数组的动态初始化

package shuzu.lianxi.demo;

public class ShuZu1 {
     
    public static void main(String[] args) {
     
        int []arr=new int [3];
        //给数组元素进行赋值
        arr[0]=100;
        arr[1]=200;
        arr[2]=300;
        //取出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

---

2.1.2 两个数组的动态初始化

package shuzu.lianxi.demo;
public class ShuZu2 {
     
    public static void main(String[] args) {
     
        int []arr1=new int [3];
        //给第一个数组元素进行赋值
        arr1[0]=10;
        arr1[1]=20;
        //输出数组1的地址值
        System.out.println(arr1);
        
        double []arr2=new double[3];
        //给第二个数组元素进行赋值
        arr2[1]=30.0;
        arr2[2]=50.0;
        //输出数组2的地址值
        System.out.println(arr2);
        //取出数组中的元素
        System.out.println(arr1[1]);
        System.out.println(arr2[0]);
    }
}

---

2.1.3 三个数组的动态初始化

ackage shuzu.lianxi.demo;

public class MyTest{
     
    public static void main(String[] args) {
     
        int []arr1=new int [3];
        arr1[0]=10;
        arr1[1]=20;
        arr1[2]=30;

        int []arr2=new int [3];
        arr2[0]=60;
        arr2[1]=120;
        arr2[2]=130;

        int []arr3=arr1;
        arr3[0]=74;
        arr3[1]=1000;

        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("---------------");

        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println("-----------------");

        System.out.println(arr3[0]);
        System.out.println(arr3[1]);
        System.out.println(arr3[2]);

    }
}

---

2.2一维数组的静态初始化

数组名 = new 元素数据类型[]{
     元素1的值，元素2的值，....};

静态初始化的说明
静态初始化时数组的长度由{}中罗列的元素的个数决定
静态初始化时[]中不可以再写长度
如果声明与初始化一起，可以简写：元素数据类型[] 数组名 = {元素1的值，元素2的值，…};

例如：
int[] arr = {
     1,2,3,4,5,6};
String[] arr = {
     “hello”,”java”,”world”};

package shuzu.lianxi.demo;

public class ShuZu4 {
     
    public static void main(String[] args) {
     
        int []arr=new int[]{
     20,30,50};
        arr[0]=100;
        System.out.println(arr[0]);
        //打印数组的地址值
        System.out.println(arr);
    }
}

---

2.3 一维数组的遍历

一维数组遍历的语法为：

for(int i=0;i<数组名.length;i++){
     System.out.println(数组名[i]);
其中arr.length代表数组的长度

package shuzu.lianxi.demo;

public class ShuZu5 {
     
    public static void main(String[] args) {
     
        int []arr={
     20,30,40,50,60,70};
        //正向遍历数组
        for (int i = 0; i < arr.length; i++) {
     
            System.out.println(arr[i]);

        }
        System.out.println("-----------------------");
        //反向遍历数组
        for (int length = arr.length-1; length >=0; length--) {
     
            System.out.println(arr[length]);

        }
    }
}

---

3.一维数组的常见算法

（1）找出数组中元素的最大值或最小值

public class ShuZu6 {
     
    public static void main(String[] args) {
           
        int[] array = {
      1,2,3,4,5};
        int max = array[0];    
        for (int i = 0; i < array.length; i++) {
     
            if (max < array[i]) {
                
                max = array[i];          
            }     
        }     
        System.out.println("最大值是" + max);  
    }
}

（2）找出数组中元素的最大/小值及其下标

public class ShuZu7 {
     
    public static void main(String[] args) {
     
        int[] array = {
      1,2,3,4,5 };
        int maxIndex = 0;
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
     
            if (max < array[i]) {
     
                max = array[i];
                maxIndex = i;
            }
        }
        System.out.println("最大值是" + max + "，其下标为：" + maxIndex);
    }
}

(3)求元素的总和/平均值

public class ShuZu8 {
     
    public static void main(String[] args) {
     
        int[] array = {
      1,2,3,4,5 };
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
     
            sum += array[i];
        }
        System.out.println("数组元素的和：" + sum + ",平均值为：" + ((double) sum) / array.length);
    }
}

(4)实现数组元素反转

public class ShuZu9 {
     
    public static void main(String[] args) {
     
        int[] array = {
     1,2,3,4,5};
        for (int i = 0; i < array.length / 2; i++) {
     
            int temp = array[i];
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = temp;
        }
        for (int i = 0; i < array.length; i++) {
     
            System.out.println(array[i]);

        }
    }
}

---

4.二维数组

二维数组就是元素为1维数组的数组。即数组嵌套着数组。

---

4.1 二维数组的声明

二维数组的声明语法为：

格式：元素的数据类型[][]  二维数组名;
例如：int[][] arr;   Student[][] students;

通俗的理解：一维数组比喻成平房，就一层楼，有几间房
二维数组比喻成楼房，有几层楼，每层楼各有几间房

---

4.2 二维数组的初始化

不管静态初始化还是动态初始化，第一维的长度必须确定

4.2.1 静态初始化

静态初始化：数组对象的创建和元素赋值操作同时进行

语法格式：
数组名 = new 元素的数据类型[][]{
     {
     元素1，元素2...},{
     元素1，元素2...}...};
当声明与静态初始化同时进行，
可以简写：
元素的数据类型[][]  数组名 = {
     {
     元素1，元素2...},{
     元素1，元素2...}...}; 

---

4.2.2 动态初始化

动态初始化：数组对象的创建与元素的赋值分开进行

（1）规则矩形

每一行的列数是一样的
（1）指定行数和列数 二维数组名 = new 元素的数据类型[行数][列数]; 
   此时元素都是默认值
（2）为元素一 一赋值  二维数组名[行下标][列下标] = 值;
arr = new int[5][6];  //声明了5行6列的数组 
//或者说声明了一个5个元素一维数组arr，
//然后每个元素又是一个长度为6的一维数组此时所有的数组对象都创建完毕，
//而且所有的元素都有默认值。
arr[0]就是{
     0,0,0,0,0,0}，
arr[1]就是{
     0,0,0,0,0,0}，
arr[2]就是{
     0,0,0,0,0,0}，
arr[3]就是{
     0,0,0,0,0,0}，
arr[4]就是{
     0,0,0,0,0,0}，

（2）不规则矩形

不规则的二维数组：每一行的列数是不相同的
（1）指定行数 二维数组名 = new 元素的数据类型[行数][];
（2）确定每一行的列数，为每一行分配空间  
   二维数组名[行下标] = new 元素的数据类型[该行的列数];
（3）为元素一 一赋值  二维数组名[行下标][列下标] = 值;
	例如：arr = new int[5][];
  此时arr的5个子数组都未创建。
  arr[0]为null，此时arr[0]，想要存储数据，
  必须先new int[长度]，然后再为元素赋值。
  arr[1]为null，同上
  arr[2]为null，同上
  arr[3]为null，同上
  arr[4]为null，同上

4.2.3 二维数组的动态初始化内存图

public class ShuZu10 {
     
    public static void main(String[] args) {
     
        //二维数组的定义与语法
        //动态初始化：由我们定义数组的长度，系统给数组赋予其默认值
        //定义一个int类型的二维数组，
        //数组长度为2，3是二维数组里面存的一维数组的程度
        int [][]arr=new int[2][3];
        System.out.println(arr[0]);
        //取二维数组第一维数组的第一个元素
        System.out.println(arr[0][0]);
    }
    }

---

4.2.4 二维数组的遍历

public class ShuZu5 {
     
    public static void main(String[] args) {
     
        int [][]arr={
     {
     1,2,3},{
     4,5,6}};
        for (int i = 0; i < arr.length; i++) {
     
            for (int j = 0; j < arr[i].length; j++) {
     
                System.out.println(arr[i][j]);
            }
        }

        }
    }