零基础入门后端开发师 java基础day5（数组与高级循环）

ll4and11

已于 2024-04-18 14:56:23 修改

阅读量722

点赞数 12

分类专栏： java基础文章标签： java 开发语言

于 2024-04-17 19:32:41 首次发布

本文链接：https://blog.csdn.net/kk666642235/article/details/137882864

版权

java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.数组

数组是一种容器，可以同来存储同种数据类型的多个值。

但是数组容器在存储数据的时候，需要结合隐式转换考虑。

比如：

定义了一个int类型的数组。那么boolean。double类型的数据是不能存到这个数组中的，

但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

建议：

容器的类，和存储的数据类型保持一致。

举例：

整数1 2 3 4 56 就可以使用int类型的数组来存储。

小数1.1 1.2 1.3 1.4 就可以使用double类型的数组来存储。

字符串"aaa" “bbb” “ccc” 就可以使用String类型的数组来存储。

2.数组的定义

数据类型 [] 数组名

比如：int [] array
数组一旦定义，长度无法改变

3.数组的静态初始化

数据类型[] 数组名 = {元素1，元素2，元素3，元素4…};

比如：

int[] array = {1,2,3,4,5};

double[] array = {1.1,1.2,1.3};

打印数组的时候，实际出现的是数组的地址值。

数组的地址值：就表示数组在内存中的位置。

以[I@6d03e736为例：

[ ：表示现在打印的是一个数组。

I：表示现在打印的数组是int类型的。

@：仅仅是一个间隔符号而已。

6d03e736：就是数组在内存中真正的地址值。（十六进制的）

但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。

地址值对于我们来京，作用不大，简单了解。

4.数组元素访问

格式：

数组名[索引];

作用：

获取数组中对应索引上的值
修改数组中对应索引上的值

一旦修改之后，原来的值就会被覆盖了。

代码示例：

public class ArrDemo2 {
    /*

        数组中元素访问的格式：
                数组名[索引];

         作用：
            1.获取指定索引上对应的元素
            2.修改指定索引上对应的元素


    */
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5};
       //需求1：获取arr数组中，3索引上的值
        int number = arr[3];
        System.out.println(number);
        System.out.println(arr[3]);

       //需求2：将arr数组中，3索引上的值修改为10
            arr[3] = 10;
        System.out.println("修改之后为:" + arr[3]);

    }
}

5.索引

索引的特点：

索引一定是从0开始的。
连续不间断。
逐个+1增长。

6.数组的遍历

遍历：就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

通用代码：

for(int i = 0; i < arr.length; i++){
    //在循环的过程中，i依次表示数组中的每一个索引
    sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}

7.数组的动态初始化

格式：

数据类型[] 数组名 = new 数据类型[数组的长度];

举例：

//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];


//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];

数组的默认初始化值：

整数类型：0

小数类型：0.0

布尔类型：false

字符类型：‘\u0000’

引用类型：null

8.数组两种初始化方式的区别

静态初始化：int[] arr = {1,2,3,4,5};

动态初始化：int[] arr = new int[3];

静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。

动态初始化：手动指定数组长度，由系统给出默认初始化值。

使用场景：

只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。

已经明确了要操作的所有数据，推荐使用静态初始化。

举例：

使用数组来存储键盘录入的5个整数。

int[] arr = new int[5];
将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100

int[] arr = new int[5];

arr[0] = 66;

arr[1] = 77;

… 虽然可以实现，但是太麻烦了。

建议使用静态初始化：int[] arr = {66,77,88,99,100};

9.数组常见问题

当访问了数组中不存在的索引，就会引发索引越界异常。

避免：

针对于任意一个数组，索引的范围：
最小索引：0
最大索引：数组的长度 - 1
数组名.length - 1

public class ArrDemo6 {
    public static void main(String[] args) {
       int[] arr = {1,2,3,4,5,5,5,5,5};
        //用索引来访问数组中的元素
        System.out.println(arr[1]);
        System.out.println(arr[10]);//ArrayIndexOutOfBoundsException

    }
}

10.无限循环

概念：

又叫死循环。循环一直停不下来。

for格式：

for(;;){
    System.out.println("循环执行一直在打印内容");
}

while格式：

while(true){
    System.out.println("循环执行一直在打印内容");
}

小括号里面就不能省略了，true一定要写出来，否则代码会报错。

do…while格式：

do{
    System.out.println("循环执行一直在打印内容");
}while(true);

小括号里面就不能省略了，true一定要写出来，否则代码会报错。

无限循环的注意事项：

最为常用的格式：while
无限循环下面不能再写其他代码了，因为永远执行不到。

11.条件控制语句

break
continue

break:

不能单独存在的。可以用在switch和循环中，表示结束，跳出的意思。

代码示例：

//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
    System.out.println("在吃第" + i + "个包子");
    //2.吃完第三个的时候就不吃了
    if(i == 3){
        break;//结束整个循环。
    }
}

continue:

不能单独存在的。只能存在于循环当中。

表示：跳过本次循环，继续执行下次循环。

代码示例：

//1.吃1~5号包子
for (int i = 1; i <= 5; i++) {
    //2.第3个包子有虫子就跳过，继续吃下面的包子
    if(i == 3){
        //跳过本次循环（本次循环中，下面的代码就不执行了），继续执行下次循环。
        continue;
    }
    System.out.println("在吃第" + i + "个包子");
}

12. Random

Random跟Scanner一样，也是Java提前写好的类，我们不需要关心是如何实现的，只要直接使用就可以了。

使用步骤：

导包

import java.util.Random;
导包的动作必须出现在类定义的上边。

创建对象

Random r = new Random ();
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。

生成随机数

int number = r.nextInt(随机数的范围);
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。
随机数范围的特点：从0开始，不包含指定值。比如：参数为10，生成的范围[0,10)

代码示例：

//1.导包
import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {
        //2.创建对象
        Random r = new Random();
        //3.生成随机数
        int number = r.nextInt(100);//包左不包右，包头不包尾
        //0 ~ 99
        System.out.println(number);

    }
}

练习：
请创建一个长度为6的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。

public class arrCircle {
    public static void main(String[] args) {
        int[] arr =new int[6];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=i+1;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

    }
}

现有一个小数数组{12.9, 53.54, 75.0, 99.1, 3.14}。请编写代码，找出数组中的最小值并打印。

public class arrMin {
    public static void main(String[] args) {
        double[] arr = {12.9, 53.54, 75.0, 99.1, 3.14};
        double min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]<min){
                min = arr[i];
            }

        }
        System.out.println(min);
    }
}

创建一个长度为6的整数数组。请编写代码，随机生成六个0（包含）-100（不包含）之间的整数存放到数组中，然后计算出数组中所有元素的和并打印。

import java.util.Random;

public class arrRodom {
    public static void main(String[] args) {
        Random rom = new Random();
        int[] arr = new int[6];
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            int number =  rom.nextInt(100);
            arr[i] = number;
            System.out.print(arr[i]+" ");
        }
        System.out.println(" ");
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];

        }
        System.out.println(sum);
    }

}

现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。

public class arrTesr {
    public static void main(String[] args) {
        int[] arr = {2, 1, 3, 5, 4};
        int num = 0;
        int num2 = 1;
        for (int i = arr.length-1; i >= 0; i--) {

            num += arr[i]*num2;
            num2 *= 10;



        }
        System.out.println(num);
    }
}

定义一个数组来存储10个学生的成绩，例如：{72, 89, 65, 87, 91, 82, 71, 93, 76, 68}。计算并输出学生的平均成绩。

public class arrGrade {
    public static void main(String[] args) {
        int[] arr = {72, 89, 65, 87, 91, 82, 71, 93, 76, 68};
        int sum = 0;
        int l = arr.length;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
       double avg = sum/l;
        System.out.println(avg);
    }
}

有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。

import java.util.Scanner;

public class arrTest1 {
    public static void main(String[] args) {
        int[] arr = {12,14,23,45,66,68,70,77,90,91};
        int[] arr1 = new int[11];
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int index = 0;
        //先把num的位置找出来
        for (int i = 0; i < arr.length; i++) {
            if(num<arr[i]){
               index = i;
               break;
            }

            }
        //录入数据到arr1
        for (int i = 0; i < arr1.length; i++) {
            if(i==index) {
            arr1[i] = num;
            }else if(i<index){
                arr1[i] = arr[i];

            }else if(i>index){
                arr1[i] = arr[i-1];
            }
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
        }

    }

定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）

public class arrArrange {
    public static void main(String[] args) {
        int[] arr = {12, 23, 34, 45, 67, 78, 11, 22};
        int[] arr1 = new int[arr.length];
        int start = 0;
        int end = arr.length-1;
        for (int i = 0; i < arr.length; i++) {

                if (arr[i] % 2 == 1) {
                    arr1[start] = arr[i];
                    start++;

                } else {
                    arr1[end] = arr[i];
                    end--;

                }

            }


        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
}