Java语言的基础知识（笔记）—数组

最新推荐文章于 2024-10-02 13:19:39 发布

Williams10

最新推荐文章于 2024-10-02 13:19:39 发布

阅读量240

点赞数

分类专栏： java 语言基础

本文链接：https://blog.csdn.net/Williams10/article/details/106320047

版权

java 语言基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

数组：
1、定义：存储数据长度固定的容器，保证多个数据的数据类型要一致。
2、数组的初始化：在内存当中创建一个数组，并且香气中赋予一些默认值；
3、常见的格式初始化：
1）动态初始化（指定长度）；
（1）格式：
数据类型[ ]数组名称=new 数据类型[数组长度]；
(1) (2) (3) (4) (5)
注释：
(1)数据类型：标明数组中的数据都统一为什么类型；
(2)中括号：数组的标志性符号；
(3)数组名称：帮数组取得名字
(4)中括号的长度：规定数组中可以保存的数据量，是一个int型数字；

public static void main(String[] args) {
    //创建一个数组，里面可以存放200个int型数据；
     //格式：数据类型[]数组名称=new 数据类型[数组长度]；
     int[] arrayA = new int[200];
     //船舰一个数组，里面可以存放8个double型数据；
     double[] arrayB = new double[8];
     //创建一个数组，里面可以存放6个字符串；
     String[] arrayC = new String[6];
   }

2）静态初始化（指定内容）；
（1）标准格式：
数据类型[ ] 数组名称 = new 数据类型[ ] {元素1，元素2，…}；
（2）省略格式：
数据类型[ ] 数组名称 = {元素1，元素2，…};
注意事项：
（1）静态初始化虽然没有直接指定长度，但是会自己进行推算的到长度；
（2）静态初始化标准格式可以拆分成两个步骤；
（3）动态初始化也可以拆分成两个步骤；
（4）静态初始化省略格式不可以拆分成两个步骤；

 public static void main(String[] args) {
        //标准格式 ：
        //创建一个数组，里面全部存放int型数据；
        int[] arrayA =new int[] {5,10,15,20};
        //创建一个数组，里面用域存放字符串；
        String[] arrayB =new String[] {"China","Java","Spring"};
        System.out.println("============");
        //省略格式：
        int[] arrayC = {15,25,35,45};
        //静态初始化的标准格式可以拆分成两个步骤；
        int[] arrayD;
        arrayD=new int[] {12,13,14,15};
        //动态初始化也可以拆分成两个步骤；
        int[] arrayE;
        arrayE= new int[4];
    }

4、访问数组元素进行获取：
1）直接打印数组名称所获得的是数组对应的内存地址（哈希值）；
回顾进制：
（1）二进制：01
（2）十进制：0123456789
（3）16进制：0123456789abcdef
索引访问数组中的元素：
数组名 [索引]=数值，为数组中的元素赋值
变量 =数组名[索引]，获取出数组中的元素
访问数组元素的格式：
数组名称[索引值]；
注释：索引值：为一个int型数字，代表数组当中元素的编号（索引值从0开始，一直到“数组的长度-1”为止。）

  public static void main(String[] args) {
        //静态初始化的省略格式
        int[] array ={12,13,14};
        System.out.println(array);
        //直接打印数组当中的元素
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println("==========");
        //可以将数组当中的某给元素赋值给变量
        int num=array[2];
        System.out.println(num);
    }

5、访问数组元素进行赋值：

使用动态初始化数组是，数组中的元素将自动拥有一个默认值。如下：
如果是整数型，则默认为0；
如果是浮点型，则默认为0.0；
如果是字符型，则默认为‘\u0000’；
如果是布尔型，则默认为false；
如果是引用类型，则默认为null；
注意：
静态初始化也有默认值的过程，知识系统会自动将默认值替换成了大括号内的具体数值；

 public static void main(String[] args) {
        //动态初始化数组
        int[] array =new int[3];
        System.out.println(array); //内存地址值；
        System.out.println(array[0]); //0
        System.out.println(array[1]); //0
        System.out.println(array[2]); //0
        System.out.println("=============");
        //将数据540赋值到数组array中的1号元素内
        array[1] =540;
        System.out.println(array[0]); //0
        System.out.println(array[1]); //540
        System.out.println(array[2]); //0

二、Java中的内存划分：
在这里插入图片描述

1、一个数组的内存图：

2、两个数组的内存图：

public static void main(String[] args) {
       int[] arrayA = new int[3];
        System.out.println(arrayA[0]); //地址值；
        System.out.println(arrayA[1]); // 0
        System.out.println(arrayA[2]); // 0
        System.out.println("============");
        arrayA[1] = 10;
        arrayA[2] = 20;
        System.out.println(arrayA); // 地址值
        System.out.println(arrayA[0]); // 0
        System.out.println(arrayA[1]); // 10
        System.out.println(arrayA[2]); // 20
        System.out.println("===========");
        int[] arrayB = new int[3];
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 0
        System.out.println(arrayB[2]); // 0
        System.out.println("============");
        arrayB[1] =150;
        arrayB[2] =200;
        System.out.println(arrayB); // 地址值
        System.out.println(arrayB[0]); // 0
        System.out.println(arrayB[1]); // 150
        System.out.println(arrayB[2]); // 200
    }

在这里插入图片描述
3、两个引用指向同一数组的内存图：

public static void main(String[] args) {
    int[] arrayA = new int[3];
    System.out.println(arrayA[0]); //地址值；
    System.out.println(arrayA[1]); // 0
    System.out.println(arrayA[2]); // 0
    System.out.println("============");
    arrayA[1] = 10;
    arrayA[2] = 20;
    System.out.println(arrayA); // 地址值
    System.out.println(arrayA[0]); // 0
    System.out.println(arrayA[1]); // 10
    System.out.println(arrayA[2]); // 20
    System.out.println("===========");
    int[] arrayB = arrayA;
    System.out.println(arrayB); // 地址值
    System.out.println(arrayB[0]); // 0
    System.out.println(arrayB[1]); // 10
    System.out.println(arrayB[2]); // 20
    System.out.println("============");
    arrayB[1] = 150;
    arrayB[2] = 200;
    System.out.println(arrayB); // 地址值
    System.out.println(arrayB[0]); // 0
    System.out.println(arrayB[1]); // 150
    System.out.println(arrayB[2]); // 200
}

在这里插入图片描述
4、常见问题：
1）、数组索引越界异常；
数组中的索引编码由0起，一直到“数组的长度-1”为止；
如果访问数组元素时索引编号不存在，则发生数组索引越界异常；

public static void main(String[] args) {
        int[] array ={10,15,20};
        System.out.println(array[0]); // 10
        System.out.println(array[1]); // 15
        System.out.println(array[2]); // 20
        //System.out.println(array[3]); //错误。未发现3号元素，出现异常
    }

2）、空指针异常：
所有的引用类型变量均可以赋值为个nuul值，但并不代表什么都没有；
数组必须进行new初始化才能使用其中的元素
仅赋值个个null没进行new的创建，将会发生空指针异常。

public static void main(String[] args) {
        int[] array = null;
        // array = new int[3];
        System.out.println(array[0]);
    }

5、如何获取数组的长度：
在这里插入图片描述
格式：
数组名称.length;
将会得到个int型数据，代表长度；
注:数组创建后，程序运行期间，长度无法改变。

public static void main(String[] args) {
        int[] arrayA = new int[];
        int[] arrayB ={1,2,3,4,5,6,7,8,12,15,16,18,22,36,88};
        int len =arrayB.length;
        System.out.println("arrayB数组的长度为："+ len);
        System.out.println("============");
        int[] arrayC = new int[3];
        System.out.println(arrayC.length); 
        arrayC =new int[6];
        System.out.println(arrayC.length);
    }

6、数组的遍历输出：
遍历数组：对数组中的每个元素进行逐个处理，默认的处理方式为打印输出；

 public static void main(String[] args) {
        int[] array ={15,20,25,30,35,40,45};
        // 使用原始方式：
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
        System.out.println(array[5]);
        System.out.println("=========");
        //使用循环，次数为数组长度：
        for (int i = 0; i <array.length ; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=========");
        // int len =array.length; // 长度
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

7、求数组中的最值：
1）最大值：

public static void main(String[] args) {
        int[] array = {5,10,60,45,-10,15,44,36};
        int max =array[0];
        for (int i = 0; i < array.length; i++) {
            //当前值比max大时，换位；
            if (array[i]>max)  {
                max = array[i];
            }
        }
        //选出最大值max
        System.out.println("最大值为："+max);
    }

2）最小值：

public static void main(String[] args) {
        int[] array = {5,10,60,45,-10,15,44,36};
        int min =array[0];
        for (int i = 0; i < array.length; i++) {
            //当前值比min小时换位；
            if (array[i]<min)  {
                min = array[i];
            }
        }
        //选出最大值max
        System.out.println("最小值为："+min);
    }

8、数组元素反转：
在这里插入图片描述
{1，2，3，4，5}反转后变成{1,2,3,4,5};
要求不能使用新数组实现反转；

public static void main(String[] args) {
        int[] array = {10,20,30,40,50};
        //遍历数组打印；
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");
        /*初始化语句： int min = 0,max = array.length-1
          条件判断：min<max
          进步表达式：min++，max--
          循环体：用第三个变量倒手
        */
        for (int min = 0,max=array.length-1;max>min;min++,max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max]=temp;
        }
        //再次打印遍历输出反转后的数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

9、数组作为方法参数：
当调用方法时，先方法的小括号进行传参，传递进去的为数组的地址值；

public static void main(String[] args) {
        int[] array = {10,15,20,25,30};
        System.out.println(array); // 地址值
        printArray(array); //传递进去的 为array中保存的地址值；
        System.out.println("======MMMM======");
        printArray(array);
        System.out.println("======NNNN======");
        printArray(array);
    }
    /* 三要素：
    返回值类型：仅进行打印，无需计算也没结果，用void
    方法名称：printArray
    参数列表：必须给我数组，我才可以打印输出其中元素。int[] array
    */
    public static void printArray(int[] array) {
        System.out.println("printArray方法收到的参数为：");
        System.out.println(array); //地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

10、数组作为方法返回值：
一个方法可以有多个参数，但禁止个已有0或1个返回值。
一个方法中产生多个结果进行返回：
（解决方案：使用一个数组作为返回值类型。）
任何数据类型决斗可以作为方法的参数类型或返回值类型；
数组作为方法的参数，传递进去的为数组的地址值；
数组作为方法的返回值，传递进去的为数组的地址值；

public static void main(String[] args) {
        int[] result =calculate();
        System.out.println("main方法接收到的返回值数组为：");
        System.out.println(result); // 返回值
        System.out.println("总和："+result[0]);
        System.out.println("平均数："+result[0]);
    }
    public static int[] calculate(int a,int b,int c) {
        int sum =a+b+c;
        int avg=sum/3;
        //两个数都希望进行返回；
        //需要一个数组，因为数组可以保存多个结果
        /*int[] array =new int[2];
        array[0] =sum;
        array[1] =avg;*/
        int[] array ={sum,avg};
        System.out.println("calculate方法内部数组为：");
        System.out.println(array); //地址值
        return array;
    }