【Java学习笔记】数组的定义与使用

一、数组的基本概念

（一）为什么要使用数组

在需要使用多个相同类型数据的时候，如果一个一个创建变量会十分麻烦，使用数组可以减少这种问题。

（二）什么是数组

数组就是相同类型元素的一个集合。
数组在内存中的存储是连续的，且都有一个从0开始依次递增的下标。

（三）数组的创建及初始化

1.数组的创建

T[] 数组名 = new T[N];

T：表示数组中存放元素类型
T[]：表示数组的类型
N：表示数组的长度

2.数组的初始化

数组的初始化主要有两种：动态初始化和静态初始化。

        //动态初始化
        int[] a1=new int[7];//第一种
        int[] a2;
        a2=new int[7];//第二种
        //静态初始化
        int[] b1=new int[]{1,2,3,4,5,6,7};//第一种
        int[] b2;
        b2=new int[]{1,2,3,4,5,6,7};//第二种
        //简写版本（不能分开写）
        int[] c={1,2,3,4,5,6,7,8};

也可以像C语言那种写法，但是不推荐，也不做示范了。

（四）数组的使用

1.数组中的元素访问

数组在内存中的存储是连续的，且都有一个从0开始依次递增的下标。数组可以通过下标访问在自己范围内的任意位置的元素。
下标范围：[0,数组.length)。

2.遍历数组

        //遍历数组的两种方式。
        int[] a={1,2,3,4,5,6,7,7,8};
        //for循环
        for (int i = 0; i < a.length; i++) {
            //需要执行的操作语句。
        }
        //for-each循环
        for(int x:a){
            //需要执行的操作语句。（直接对变量a进行操作）
        }

两个遍历方法的区别在于：for循环可以拿到下标，直接对数组进行操作，而for-each循环则是通过把数组值依次赋给变量，间接实现操作的。

二、数组是引用类型

（一）初识JVM的内存分布

目前需要了解到的是两个：

1. 平时说的栈就是虚拟机栈。局部变量啥的都放在这里面。
2. 堆一般是用来存储对象的。
   

（二）基本类型变量与引用类型变量的区别

基本变量是根据基本数据类型创建的变量。它对应的存储空间存储的是自己的真实值。
引用数据类型创建的变量被称为对象的引用，它对应的存储空间存储的是对象所在空间的地址（在堆中空间的起始地址）。引用变量通过地址对对象进行操作。
对象一定在堆上，引用类型不一定在栈上。

（三）再谈引用类型变量

举例：

public class Main {
    public static void main(String[] args) {
       int[] a1={1,2,3};
       int[] a2={10,20,30};
       a1=a2;
       a1[0]=7;
       a1[1]=8;
       a1[2]=9;
       for(int x:a2){
           System.out.println(x);//结果是7,8,9
       }
    }
}

当引用变量不指向堆中的对象时，Java会自动将堆中对象的空间清理干净，不需要自己释放内存。
引用不能指向引用，引用必须指向对象。

（四）认识null

int[] a1=null;

null表示空引用（一个不指向对象的引用）。
输出null会抛出空指针（翻译而已，Java没有指针）异常。

三、数组的应用场景

（一）保存数据

保存相同类型的数据元素。

（二）作为函数的参数

1.参数传基本数据类型

在方法中修改形参的值，无法直接改变实参传递给形参的值。

2.参数传数组类型（引用数据类型）

在方法改变引用类型的内容，方法外的引用类型的内容也会发生变化。
将数组视为引用类型变量可以避免数组的拷贝（如果数组较长，会很麻烦）。

（三）作为函数返回值

import java.util.Arrays;

public class Main {
    public static int[] transform(int[] a){
        for (int i = 0; i < a.length; i++) {
            a[i]*=2;
        }
        return a;
    }
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        System.out.println(Arrays.toString(transform(a)));
    }
}

四、数组练习

（一）数组转字符串

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
       int[] a2={10,20,30};
        System.out.println(Arrays.toString(a2));
    }
}

（二）数组拷贝

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a2={10,20,30};
        int[] a1=new int[3];
        a1=Arrays.copyOf(a2,a2.length);
        System.out.println(Arrays.toString(a1));
    }
}

（三）求数组中元素的平均值

public class Test001 {
    public static double avg(int[] a){
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
        }
        return sum*1.0/a.length;
    }
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        System.out.println(avg(a));
    }
}

（四）查找数组中指定元素（顺序查找）

import java.util.Arrays;

public class Test001 {
    public static void main(String[] args) {
        int[] a1={1,12,2,24,3,0,4,79,5,6,7,8,9,10};
        int i=0;
        Arrays.sort(a1);
        for (int j = 0; j < a1.length; j++) {
            if(a1[j]==i){
                System.out.println(j);//返回下标
                break;
            }
        }
    }
}

（五）查找数组中指定元素（二分查找）

import java.util.Arrays;

public class Test001 {
    public static void main(String[] args) {
        int[] a1={1,12,2,24,3,0,4,79,5,6,7,8,9,10};
        int i=12;
        Arrays.sort(a1);
        int r=a1.length-1;
        int l=0;
        int m=(l+r)/2;
        while(l<=r){
            if(i>a1[m]){
                l=m+1;
                m=(l+r)/2;
            } else if (i<a1[m]) {
                r=m-1;
                m=(l+r)/2;
            }else{
                System.out.println(m);
                break;
            }
        }
    }
}

（六）数组排序（冒泡排序）

import java.util.Arrays;

public class Test003 {
    public static int[] maoPao(int[] a){
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j]>a[j+1]){
                    int t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
        return a;
    }
    public static void main(String[] args) {
        int[] a={10,2,6,3,4,67,2,3,5,2};
        System.out.println(Arrays.toString(maoPao(a)));
    }
}

（七）数组逆序

import java.util.Arrays;

public class Test002 {
    public static void main(String[] args) {
        int[] a1={1,2,3,4,5,6};
        int l=0;
        int r=a1.length-1;
        while(l<=r){
            int tmp=a1[l];
            a1[l]=a1[r];
            a1[r]=tmp;
            l++;
            r--;
        }
        System.out.println(Arrays.toString(a1));
    }
}

五、二维数组

二维数组是特殊的一维数组（本质上是一维数组，每个元素又是一个一维数组）。它默认的初始值都是0。有不规则二维数组。
其他更多维数组使用频率较低，在此不多赘述。

import java.util.Arrays;

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

六、结束语

我是小邓，一个励志写好代码挣大钱的男人。希望通过博客在记录自己的学习历程的同时，认识更多志同道合的朋友。如果您觉得我的文章对您有帮助的话，请不要吝惜您的一键三连(点赞关注加收藏)，这对我很重要，谢谢！