6.java的数组简介（简单入门附练习代码）

最新推荐文章于 2022-11-07 14:04:38 发布

原来如此呀

最新推荐文章于 2022-11-07 14:04:38 发布

阅读量360

点赞数

分类专栏： Java学习之旅文章标签： windows java 算法

本文链接：https://blog.csdn.net/Royalic/article/details/118344545

版权

Java学习之旅专栏收录该内容

34 篇文章 5 订阅

订阅专栏

数组的介绍

数组(Array)，是多个相同类型数据按一定顺序排列
的集合，并使用一个名字命名，并通过编号的方式

对这些数据进行统一管理：
1.数组的常见概念
2.数组名
3.下标(或索引)
4.元素
5.数组的长度：元素的个数

数组的特点：数组是有序排列的。

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
1.创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用是
这块连续空间的首地址。
2. 数组的长度一旦确定，就不能修改。
3. 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
4.数组的分类：
》按照维度：一维数组、二维数组、三维数组、 …
》按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

一维数组的使用

一维数组的声明和初始化
如何调用数组的指定位置元素
如何获取数组的长度
如何遍历数组
数组元素的默认初始化
数组的内存解析

1.一维数组的声明方式和初始化：
type var[ ] 或 type[ ] var；
例如：
int a[ ];
int[] a1;
double b[ ];
String[ ] c; //引用类型变量数组

Java语言中声明数组时不能指定其长度(数组中元素的数)，例如： int a[5];
》动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
》静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

总结：一旦初始化完成，数组的长度就已经确定了

数组元素的引用
基本上引用到索引的问题，索引基本是从0开始的。
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
》数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
》数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、 a[1]、 a[2]
在这里插入图片描述
获取数组的长度
每个数组都有一个属性length指明它的长度，例如： a.length 指明数组a的长度(元素个数)，数组一旦初始化，其长度是不可变的

遍历数组的元素

数组元素的默认初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
例如：
public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}
1.对于基本数据类型而言，默认初始化值各有不同
2.对于引用数据类型而言，默认初始化值为null(注意与0不同！ )
在这里插入图片描述

数组的内存解析

放在方法中的变量都是局部变量！
下面展示一些 ArrayLearning。

public class ArrayLearning {
    public static void main(String[] args) {
        //一维数组的声明和初始化
        //静态初始化：数组的初始化和数组元素的肤质同时操作
        int [] ids = new int[]{1001,2334,4345,211,4245};
        //动态初始化：数组的初始化和数组元素的复制分开进行
        String [] names = new String[5];

        //调用数组的指定元素：通过角标索引
        //数组的索引是从0开始，倒数组的长度-1结束，要根据数组的长度对数组进行赋值，数组的长度一旦确定就无法改变！
        names[0] = "王明";
        names[1] = "王贺";
        names[2] = "易烊千玺";
        names[3] = "王源";
        names[4] = "孙巨龙";

        //获取数组的长度，调用属性length
        System.out.println(names.length);
        System.out.println(ids.length);

        //遍历数组元素
        for (int i = 0; i < ids.length;i++){
            System.out.print(ids[i] + "\t");
        }
        System.out.println();
        for (int i = 0;i < names.length;i++){
            System.out.print(names[i] + "\t");
        }

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


    }
}

**练习1：**升景坊单间短期出租4个月， 550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
注：ctrl + D 删除
在这里插入图片描述
下面展示一些 ArrayTest。

/*
练习1：**升景坊单间短期出租4个月， 550元/月（水电煤公摊，网费35元/月），
空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好
是同行或者刚毕业的年轻人，爱干净、安静。

 */

public class ArrayTest {
    public static void main(String[] args) {
        int [] arr = new int[]{8,2,1,0,3};
        int [] index = new int[]{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);//结果：18013820100
    }
}

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
注：ctrl+shirft+o 将代码所需安装包导入
shirft+enter键进入下一行

下面展示一些 ArrayTest1。

/*
从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
 */


import java.util.Scanner;

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

        //创建数组，存储学生成绩，此时应当是动态初始化
        int [] score = new int[number];
        //给数组中的元素赋值

        //进行优化，将元素最大值计算和成绩输入合并到一起
        System.out.println("请输入" + number + "个同学的成绩：");
        int maxScore = 0;
        for (int i = 0;i < score.length;i++){
            score[i] = scanner.nextInt();
            if (maxScore < score[i]){
                maxScore = score[i];
            }
        }

/*        //获取数组中的元素最大值：即最高分
        int maxScore = 0;
        for (int i = 0;i < score.length;i++){
            if (maxScore < score[i]){
                maxScore = score[i];
            }
        }*/




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

        char level;
        for (int i = 0;i < score.length;i++){
            if (maxScore - score[i] <= 10){
                level = 'A';
            }else if (maxScore - score[i] <= 20){
                level ='B';
            }else if (maxScore - score[i] <= 30){
                level = 'C';
            }else{
                level = 'D';
            }
            System.out.println("该学生的成绩为" + score[i] + "对应的等级为" +level + "。");
        }

    }
}

多维数组的使用：

1.Java 语言里提供了支持多维数组的语法。
2.如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像右图Excel中的表格一样。
3.对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

二维数组的声明和初始化
如何调用数组的指定位置元素
如何获取数组的长度
如何遍历数组
数组元素的默认初始化
数组的内存解析

二维数组的声明和初始化
在这里插入图片描述
如何调用数组的指定位置元素

如何获取数组的长度

如何遍历数组

数组元素的默认初始化
1.针对于初始化方式—:比如: int[ ] arr = new int[4][3];
外层元素的初始化值为:地址值
内层元素的初始化值为:与一维数组初始化情况相同

2.针对于初始化方式二:比如: int[ ][ ] arr = new int[4][ ];
外层元素的初始化值为:null
内层元素的初始化值为:不能调用，否则报错!
在这里插入图片描述
数组的内存解析

下面展示一些 ArrayLearning2。


public class ArrayLearning2 {
    public static void main(String[] args) {
        //二维数组的声明和初始化
        //二维数组的静态初始化
        int [][] arr1 = new int[][]{{1,3,4,5},{1,3,5,7,3},{5,5,7}};
        //动态初始化1
        String [][] arr2 = new String[3][2];
        //动态初始化2
        String [][] arr3 = new String[3][];
        System.out.println("\n");


        //调用多维数组的元素
        System.out.println(arr1[2][1]);
        System.out.println(arr2[1][0]);

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

        //获取二维数组的长度

        System.out.println(arr1.length);
        System.out.println(arr1[2].length);
        System.out.println(arr1[0].length + "\n");

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

    }
}

练习2：
获取arr数组中所有元素的和。提示：使用for的嵌套循环即可。
在这里插入图片描述

下面展示一些 内联代码片。

/*

获取arr数组中所有元素的和。

*/

public class ArrayTest2 {
    public static void main(String[] args) {
        int sum = 0;
        int [][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
        for (int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[i].length;j++){
                sum += arr[i][j];

            }
        }
        System.out.print("总和是：" + sum);
    }
}

**练习3.**声明： int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
a ) x[0] = y; no
b) y[0] = x; yes
c) y[0][0] = x; no
d) x[0][0] = y; no
e) y[0][0] = x[0]; yes
f) x = y; no
提示：
一维数组： int[] x 或者int x[]
二维数组： int[][] y 或者 int[] y[] 或者 int y[][]

**练习4.**使用二维数组打印一个 10 行杨辉三角。
【提示】

第一行有 1 个元素, 第 n 行有 n 个元素
每一行的第一个元素和最后一个元素都是 1
从第三行开始, 对于非第一个元素和最后一个元
素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

下面展示一些 YangHuiSanJiao。

/*
* 使用二维数组打印一个 10 行杨辉三角。
【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元
素的元素。即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

* */


public class YangHuiSanJiao {
    public static void main(String[] args) {
        int [][] yangHui = new int[10][];

        for(int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];

            //给首末元素进行赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //给非首末元素进行赋值


//            if (i > 1){
//                //当i>1时，单看每行非首末元素i = 2时，j = 1，以此类推，j < yangHui[i].length - 1
//                for (int j = 1;j < yangHui[i].length - 1;j++){
//                    yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
//                }
//            }

            //优化后，数据结构，只有i>1时，以下运算才有效
            for (int j = 1;j < yangHui[i].length - 1;j++){
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
            }

        }
        //遍历数组
        for(int i = 0;i < yangHui.length;i++){
            for (int j = 0;j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

数组中涉及的常见算法

数组元素的赋值(杨辉三角、回形数等)
求数值型数组中元素的最大值、最小值、平均数、总和等
数组的复制、反转、查找(线性查找、二分法查找)
数组元素的排序算法

**练习5：**定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。要求：所有随机数都是两位数。
提示；[0,1) * 90 [0,90) + 10  [10,100) [10,99]
(int)(Math.random() * 90 + 10) 在这里插入图片描述

下面展示一些 ArrayTest3。

/*
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值， 最小值，和值， 平均值， 并输出出来。
要求： 所有随机数都是两位数。
提示；[0,1) * 90 [0,90) + 10  [10,100) [10,99](int)(Math.random() * 90 + 10)


*/

public class ArrayTest3 {
    public static void main(String[] args) {
        int [] arr = new int[10];
        for (int i = 0; i < arr.length;i++){
            //由于是两位数则范围为(0,99]，根基随机数的计算公式
            arr[i] = (int)(Math.random() *(99 -10 + 1) + 10 );
        }

        //遍历一维数组元素
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println("***************");
        //求最大值
        int maxValue = 0;
        for (int i = 0;i < arr.length;i++){
            if (maxValue < arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值是：" + maxValue);

        //求最小值
        int minValue = 100;
        for (int i = 0;i < arr.length;i++){
            if (minValue > arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值是：" + minValue);


        //求总和
        int sumValue = 0;
        for (int i = 0;i < arr.length;i++){
            sumValue += arr[i];
        }
        System.out.println("总和是：" + sumValue);

        System.out.println("平均值是：" + sumValue/arr.length);



    }
}

**练习 6：**使用简单数组
(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数： 2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
(如array[0]=0,array[2]=2)。打印出array1。
思考： array1和array2是什么关系？ array1合array2的地址值相同，都是指向栈空间中的一个数组实体。
拓展：修改题目，实现array2对array1数组的复制
在这里插入图片描述

数组的复制、反转、查找(线性查找、二分法查找)

下面展示一些 ArrayTest4。

/*
(1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数： 2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
(如array[0]=0,array[2]=2)。打印出array1。
思考： array1和array2是什么关系？  array1合array2的地址值相同，都是指向栈空间中的一个数组实体。
拓展： 修改题目，实现array2对array1数组的复制

*/


public class ArrayTest4 {
    public static void main(String[] args) {
        int [] arr1,arr2;
        arr1 = new int[]{2,3,5,7,11,13,17,19};

        //显示arr1的内容
        for (int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + "\t");
        }
        //赋值arr2变量等于arr1
        arr2 = arr1;

        //修改arr2中的偶索引元素，使其等于索引值
        for (int i = 0;i < arr1.length;i++){
            if (i % 2 == 0){
                arr2[i] = i;
            }
        }
        System.out.println();
        //打印arr1的内容
        for (int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + "\t");
        }


        System.out.println();
        //数组的复制
        arr2  = new int[arr1.length];
        for (int i = 0;i < arr2.length;i++){
            arr2[i] = arr1[i];
            System.out.print(arr2[i] + "\t");
        }


        System.out.println();
        String [] array = new String[]{"JJ","KK","OO","LL","VV"};
        String [] array1 = new String[array.length];
        for (int i = 0;i < array.length;i++){
            array1[i] = array[i];
            System.out.print(array1[i] + "\t");
        }

        //数组的反转
        //方法一：
        System.out.println();
        //数组的反转只需要将数组前半部分与后半部分进行对调，只需遍历数组长度的一半
        for (int i = 0;i < array.length / 2;i++){
            String temp = array[i];
            //如果无法判断j的取值只需要选取多个i的值进行验证
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = temp;

        }
        //再次进行遍历
        for (int i = 0;i < array.length;i++){
            System.out.print(array[i] + "\t");
        }

        //方法二
        System.out.println();
        for (int i = 0,j = array.length  - 1;i < j;i++,j--){
            String temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
        for (int i = 0;i < array.length;i++){
            System.out.print(array[i] + "\t");
        }


        //查找（或搜索)
        //线性查找
        String dest = "BB";
        boolean isFlag = true;
        System.out.println();

        for(int i = 0;i < array.length;i++){
            if (dest.equals(array[i])){
                System.out.println("找到指定的元素位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag){
            System.out.println("很遗憾没有找到对应元素！");
        }

        //二分法查找
        //前提：所要查找的数组必须要有序排列
        int [] array2 = new int[]{-78,-67,4,13,24,34,64,75,765,867,4564,6456,53534,353533};

        boolean isFlag1 = true;
        int dest1 = 24;
        int head  = 0;//初始的首索引
        int end = array2.length - 1;//初始的末索引
        while (head <= end){
            int middle = (end + head) / 2;
            if (dest1 == array2[middle]){
                System.out.println("找到指定的元素位置是：" + middle);
                isFlag1 = false;
                break;
            }else if (array2[middle] < dest1){
                head = middle + 1;
            }else{//array2[middle] > dest1
                end = middle - 1;
            }
        }
        if (isFlag1){
            System.out.println("没有找到指定元素!");
        }
    }

}

原来如此呀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
6.java的数组简介（简单入门附练习代码）

数组的介绍数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理：1.数组的常见概念2.数组名3.下标(或索引)4.元素5.数组的长度：元素的个数数组的特点：数组是有序排列的。数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。1.创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用是这块连续空间的首地址。2. 数组的长度一旦确定，就不能修改。3. 我们可以.
复制链接

扫一扫