java语言入门(三)之数组的学习

我是一个小仓鼠01

已于 2022-12-05 16:33:26 修改

阅读量323

点赞数

分类专栏： JAVA语言文章标签： java 服务器 servlet

于 2022-10-14 14:37:20 首次发布

本文链接：https://blog.csdn.net/weixin_53998054/article/details/127305735

版权

JAVA语言专栏收录该内容

3 篇文章 0 订阅

订阅专栏

数组的概述

数组（Array）是有序的元素序列。 [1] 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便，把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1] 这些有序排列的同类数据元素的集合称为数组。

数组的常见概念

数组名
下标或索引
元素
数组的长度

数组的特点:

数组都是有序的

数组属于引用数据类型的变量,数组的元素,即可以是基本数据类型也可以是引用数据类型

数组本身是引用数据类型,而数组中元素可以是任何数据类型,包括基本数据类型和引用数据类型

创建数组对象会在内存中开辟一整块连续空间,而数组中引用的是这次连续空间的首地址

数组的长度一旦确定,就不能修改。

我们可以直接通过下标的方式调用指定位置的元素,速度很快。

数组的分类:

按照维度,一维数组、二维数组、三维数组......

按照元素的数据类型分:基本数据类型元素的数组,引用数据类型的类型元素

一维数组的使用

一维数组的声明和初始化

如何调用数组的指定位置的元素

如何获取数组的长度

如何遍历数组

数组元素默认初始化值

数组的内存解析

public class ArrayTest{
    public static void main(String[]atgs){
        
        //1.一维数组的声明和对比
        int num;//声明
        num =10;//初始化
        int id =1001;//声明+初始化
        
        int[]ids;//声明
        //1.1静态初始化:数组的初始化和数组元素的赋值同时进行
        ids = new int[]{1001,1002,1003,1004}
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names =new String[5];
        
        //错误的写法
        //int[]arr1=new int[]
        //int[5]arr2=new int[5];
        //int[]arr3=new int[3]{1,2,3};
        //总结:数组一旦初始化完成,其长度就确定了    

    }    

}

数组元素的调用

如何调用数组的指定位置的元素:通过角标的方式调用

数组的角标从0开始的,到数组的长度-1结束

public class ArrayTest{
    public static void main(String[]atgs){
        
        //1.一维数组的声明和对比
        int num;//声明
        num =10;//初始化
        int id =1001;//声明+初始化
        
        int[]ids;//声明
        //1.1静态初始化:数组的初始化和数组元素的赋值同时进行
        ids = new int[]{1001,1002,1003,1004}
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names =new String[5];
        
        //错误的写法
        //int[]arr1=new int[]
        //int[5]arr2=new int[5];
        //int[]arr3=new int[3]{1,2,3};
            
        //这也是正确写法
         int[]arr4={1,2,3,4,5};//类型转换

       //总结:数组一旦初始化完成,其长度就确定了    

        names[0]="王铭";
        names[1]="王赫";
        names[2]="张学良";
        names[3]="孙居龙";
        names[4]="王宏志";

    }    

}

数组的长度与遍历

public class ArrayTest{
    public static void main(String[]atgs){
        
        //1.一维数组的声明和对比
        int num;//声明
        num =10;//初始化
        int id =1001;//声明+初始化
        
        int[]ids;//声明
        //1.1静态初始化:数组的初始化和数组元素的赋值同时进行
        ids = new int[]{1001,1002,1003,1004}
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names =new String[5];
        
        
        //这也是正确写法
         int[]arr4={1,2,3,4,5};//类型转换

        //错误的写法
        //int[]arr1=new int[]
        //int[5]arr2=new int[5];
        //int[]arr3=new int[3]{1,2,3};
        //总结:数组一旦初始化完成,其长度就确定了    

        names[0]="王铭";
        names[1]="王赫";
        names[2]="张学良";
        names[3]="孙居龙";
        names[4]="王宏志";

        //3.如何获取数组的长度
        System.out.println(name.length);//5
        System.out.println(ids.length);
    
        //4.如何遍历数组
     //System.out.println( names[0]);
     //System.out.println( names[1]);        
     //System.out.println( names[2]);
     //System.out.println( names[3]);
     //System.out.println( names[4]);
     //System.out.println( names[5]);


       //优化代码
        for(int i =0; i<names.lengtg;i++){
            System.out.println(names[i]);
            }
       }    

}

数组元素的默认初始值

/*
*数组元素的默认初始值
 数组元素是整数:0
 数组元素是浮点型:0.0
 数组元素是char型 0或者 '\u0000'
 数组元素是boolean型 false
 数组元素是引用类型数据:null
*/
public class ArrayTest1{
    public static void main(String[]atgs){
       //5.数组元素的默认初始值
        int[] arr = new int[4];

        //优化代码
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("*******");

        short[] arr1 = new short[4];
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }

        System.out.println("*******");

        float[] arr2 = new float[5];
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }


        System.out.println("*******");

        char[] arr3 = new char[4];
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

        if (arr[3] == 0) {
            System.out.println("你好");
        }

        System.out.println("*******");
        boolean[] arr4 = new boolean[5];
        System.out.println(arr4[0]);

        System.out.println("*******");
        String[] arr5 = new String[5];
        System.out.println(arr5[0]);

            if (arr5[0] == null) {
                System.out.println("北京天气不错");
            }

       }    

}

内存结构的简单说明

一维数组的内存解析

一维数组的课后练习

练习题1

public class ArrayDemo{
     public static void main(String[]atgs) {

        int[] arr = {8, 2, 1, 0, 3};
        int[] index = {2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3};
        String tel= "";
        for (int i = 0; i < index.length; i++) {
            tel += arr[index[i]];
        }
        System.out.println("练习方式"+tel);
        }
    }

练习题2

从键盘读入学生成绩,找出最高分,并输出学生成绩

成绩 >=最高分 -10 等级为A

成绩 >=最高分 -20 等级为B

成绩 >=最高分 -30 等级为C

其余等级为D

public class ArrayDemo1{
     public static void main(String[]atgs) {
           //使用Scanner,读取学生的个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数");
        int number = scanner.nextInt();

            //创建数组,存储学生成绩,动态初始化
          int[] scores = new int[number];
            //给数组的元素赋值
          System.out.println("请输入"+number+"个学生成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i]= scanner.nextInt();
        }

            //获取数组中的元素最大值:最高分
          int maxScore =0;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore<scores[i]){
                maxScore =scores[i];
            }
        }
            // 根据每个学生成绩与最高分的差值,得到每一个学生的成绩,并输出等级和成绩

          char level;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore -scores[i]<=10){
                level ='A';
            }else  if (maxScore -scores[i]<=20){
                level ='B';
            }else if(maxScore -scores[i]<=30){
                level ='C';
            }else {
                level ='D';
            }
            System.out.println("student "+i+"score is"+
                    scores[i]+",grade is"+level);

            }
       
        }
    }

优化代码；

public class ArrayDemo1{
     public static void main(String[]atgs) {
           //使用Scanner,读取学生的个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数");
        int number = scanner.nextInt();

            //创建数组,存储学生成绩,动态初始化
          int[] scores = new int[number];
 
          int maxScore =0;
            //给数组的元素赋值
          System.out.println("请输入"+number+"个学生成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i]= scanner.nextInt();
         //获取数组中的元素最大值:最高分
          
       if (maxScore<scores[i]){
                maxScore =scores[i];
            }
        }

      
            // 根据每个学生成绩与最高分的差值,得到每一个学生的成绩,并输出等级和成绩

          char level;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore -scores[i]<=10){
                level ='A';
            }else  if (maxScore -scores[i]<=20){
                level ='B';
            }else if(maxScore -scores[i]<=30){
                level ='C';
            }else {
                level ='D';
            }
            System.out.println("student "+i+"score is"+
                    scores[i]+",grade is"+level);

            }
       
        }
    }

二维数组的理解和初始化

二维数组的定义

同一维数组类似，二维数组在使用之前必须首先定义。二维数组在定义时需要说明数组的数据类型、数组名和数组元素的个数。

二维数组的定义格式为：

＜数据类型＞＜数组名＞[＜常量表达式1＞][＜常量表达式2＞]；

说明：

（1）常量表达式1指明了二维数组的行数，常量表达式2则指明了二维数组中每行的元素个数，即二维数组的列数。其他与一维数组相同。

（2）二维数组的上标和下标可以是整数常量或整数表达式。如果行下标为m（即常量表达式1的结果），列下标为n（即常量表达式2的结果），则该二维数组共包括m×n个元素。其中，行下标的最大值为m-1，列下标的最大值为n-1。

例如：

intscore[3][4]；

表示定义了一个二维数组score，其元素的数据类型为整型，它有3行4列共12个数组元素，分别为：

可以把二维数组看作为一种特殊的一维数组，即它的每一个元素又是一个一维数组。

二维数组的初始化

与一维数组一样，二维数组也可以进行初始化赋值。二维数组初始化赋值的方法有：

（1）给数组的所有元素赋初值

给数组的所有元素赋初值的方法有两种：

方法一：按行的顺序，将每一行元素的初值放在一个用花括号括起来的、各初值间用逗号分开的序列中，用花括号括起来的序列间用逗号分隔，全部初值再用一个花括号括起来。例如：

int a[3][4]＝｛｛1，2，3，4｝，｛5，6，7，8｝，｛9，10，11，12｝｝；

这个语句的作用是对二维数组的数组元素进行赋值，结果为：

方法二：将所有初值放在一个花括号括起来的序列中，按数组排列的顺序给各元素赋初值。例如：

int a[3][4]＝｛1，2，3，4，5，6，7，8，9，10，11，12｝；

这个语句的效果同上。

如果对二维数组的所有元素都赋初值，则定义二维数组时第一维的长度（数组的行数）可以不指定，而第二维的长度（数组的列数）必须指定。例如：

int a[][4]＝｛｛1，2，3，4｝，｛5，6，7，8｝，｛9，10，11，12｝｝；

或：

int a[][4]＝｛1，2，3，4，5，6，7，8，9，10，11，12｝；

（2）给数组的部分元素赋初值

给数组的部分元素赋初值的方法与给数组的所有元素赋初值的方法类似，例如：

int a[3][4]＝｛｛1，2｝，｛5｝，｛9，10，11｝｝；

表示给二维数组a的元素a[0][0]、a[0][1]、a[1][0]、a[2][0]、a[2][1]、a[2][2]赋了初

/*
* 二维数组的声明
* 二维数组的声明和初始化
* 如何调用数组的指定位置的元素
* 如何获取数组的长度
* 如何遍历数组
* 数组元素的默认初始化值
* 数组的内存解析
* */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = {1, 2, 3};//一维数组
        //静态初始化
        int[][] arr1 = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //动态初始化
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //错误的情况
//       String[][]arr4= new String[][4];
//       String[4][3]arr5 = new String[][];
//       int[][] arr6 =new int[4][3] {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //正确
        int[] arr4[]=new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr5[]={{1, 2, 3}, {4, 5}, {6, 7, 8}};
    }
}

二维数组的使用

/*
 * 二维数组的声明
 * 二维数组的声明和初始化
 * 如何调用数组的指定位置的元素
 * 如何获取数组的长度
 * 如何遍历数组
 * 数组元素的默认初始化值
 * 数组的内存解析
 * */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = {1, 2, 3};//一维数组
        //静态初始化
        int[][] arr1 = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //动态初始化
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //错误的情况
//       String[][]arr4= new String[][4];
//       String[4][3]arr5 = new String[][];
//       int[][] arr6 =new int[4][3] {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //正确
        int[] arr4[]=new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr5[]={{1, 2, 3}, {4, 5}, {6, 7, 8}};

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);
        System.out.println(arr2[1][1]);//null

        arr3[1]= new String[4];
        System.out.println(arr3[1][0]);
    }
}

二维数组的长度和遍历

/*
 * 二维数组的声明
 * 二维数组的声明和初始化
 * 如何调用数组的指定位置的元素
 * 如何获取数组的长度
 * 如何遍历数组
 * 数组元素的默认初始化值
 * 数组的内存解析
 * */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = {1, 2, 3};//一维数组
        //静态初始化
        int[][] arr1 = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //动态初始化
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //错误的情况
//       String[][]arr4= new String[][4];
//       String[4][3]arr5 = new String[][];
//       int[][] arr6 =new int[4][3] {{1, 2, 3}, {4, 5}, {6, 7, 8}};
        //正确
        int[] arr4[]=new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        int[] arr5[]={{1, 2, 3}, {4, 5}, {6, 7, 8}};

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);
        System.out.println(arr2[1][1]);//null

        arr3[1]= new String[4];
        System.out.println(arr3[1][0]);

        //获取数组的长度
        System.out.println(arr4.length);
        System.out.println(arr4[0].length);
        System.out.println(arr4[1].length);

        //如何遍历二维数组
        for (int i = 0; i < arr4.length; i++) {
            for (int j = 0; j < arr4[i].length; j++) {
                System.out.print(arr4[i][j]+" ");
            }
            System.out.println();
        }


    }
}

二维数组元素默认初始化值

/*
*二维数组的使用
*规定:二维数组分为外层数组的元素,内层数组的元素
*  int[][]arr=new int[4][3];
*  外层元素:arr[0],arr[1]等
*  内层元素:arr[0][0],arr[1][2]等
*
*
*
*
* 数组元素的默认初始化
* 针对初始化方式一:比如 int[][]arr=new int[4][3];
* 外层元素的初始化值为:地址值
* 内层元素的初始化值为:与一维数组初始化情况相同
* 
* 针对初始化方式二:比如 int[][]arr=new int[4][];
* 外层元素的初始化值为: null
* 内层元素的初始化值为:不能调用,否则报错
*
*
*
*
*
*
*
*
*
*
* 数组的内存解析
*
*/

public class ArrayTest3{
    public static void main(String[]args){
        int[][]arr=new int[4][3];
        System.out.println(arr[0]);
        System.out.println(arr[0][0]);


        System.out.println("*************");
        float[][] arr1 =new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][0]);//0，0

        System.out.println("******");
        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null

        System.out.println("******");
        double[][] arr3 = new double[4][2];
        System.out.println(arr3[1]);//地址值
        //System.out.println(arr3[1][0]);//报错


    }