Java基础篇之数组篇

最新推荐文章于 2024-01-24 21:41:51 发布

big coke

最新推荐文章于 2024-01-24 21:41:51 发布

阅读量704

点赞数

本文链接：https://blog.csdn.net/weixin_43657820/article/details/105069415

版权

1.数组遍历（依次输出数组中的每一个元素）：

2.数组中最值获取:

3.数组练习之评委打分：

4.数组练习之不死神兔：

1.数组：

数组：

A：数组是存储多个变量（元素）的东西（容器）

B：这多个变量的数据类型要一致

数组定义格式：

A：数据类型[ ] 数组名；

B：数据类型数组名[ ];

举例：

int 【】arr；定义了一个int类型的数组，数组名是arr

int arr【】；定义了一个int类型的变量，变量名是arr数组

数组初始化：

A：所谓的初始化，其实就是为数组开辟内存空间，并为数组中的每个元素赋予初始值

B：如何进行初始化：

a.动态初始化只给出长度，由系统给出初始化值

b.静态初始化只给出初始化只，由系统决定长度

2.动态初始化：

数据类型【】数组名= new 数据类型【数据长度】；

注意下列代码中注释：

下列代码分步：

1.定义数组

public class ArrayDemo {
    public static void main(String[] args) {
        int [] arr=new int[3];
        /*
        左边：
            int：说明的是数组中的元素类型是int类型
            []:说明这是一个数组
            arr：这是数组的名字
        右边：
            new：为数组申请分配内存空间。
            int：说明的是数组中的元素类型是int类型
            []：说明这是一个数组
            3：数组长度，其实就是数组中的元素个数
         */
    }
}

2.输出数组名会得到数组的地址：

public class ArrayDemo {
    public static void main(String[] args) {
        int [] arr=new int[3];
        /*
        左边：
            int：说明的是数组中的元素类型是int类型
            []:说明这是一个数组
            arr：这是数组的名字
        右边：
            new：为数组申请分配内存空间。
            int：说明的是数组中的元素类型是int类型
            []：说明这是一个数组
            3：数组长度，其实就是数组中的元素个数
         */
        System.out.println("arr:"+arr);
    }
}

输出：arr:[I@7530d0a（此为数组地址）

3.获取数组中的元素值：

概念前沿：

数组中每个元素是有编号的，编号从0开始，最大的编号是数组的长度 -1

通过数组名和编号的配合使用我们即可获得的数组中指定编号的元素值

编号专业叫法：索引

获取元素格式：数组名【索引】

输出地址代码下加：

        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);

输出结果：

arr[0]:0
arr[1]:0
arr[2]:0

3.Java中的内存分配：

栈：（存储的是局部变量）

堆：（存储的是new出了的东西）

方法区：（面向对象部分）

本地方法区：（和系统相关）

寄存器：（给CPU使用的）

关注：栈和堆

栈：

存储的是局部变量。

局部变量其实就是定义在方法中的变量。

堆：

存储的是new出来的东西，实体，对象。

A：每一个对象都有地址值

B：每一个对象的数据都有默认值

byte，short，int，long 0

float，double 0.0

char \u0000（空字符）

boolean false

引用类型 null

C：数据使用完毕后，会在垃圾回收器空闲的时候被回收

数组实操案例：

1.给数组中的元素赋值，再次输出数组名及元素:

代码实现：

public class array_test {
    public static void main(String[] args) {
        int []arr = new int[3];
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);
        System.out.println("--------------");
        arr[0] = 100;
        arr[1] = 150;
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);

    }
}

输出：

arr[0]:0
arr[1]:0
arr[2]:0
--------------
arr[0]:100
arr[1]:150
arr[2]:0

原理图：即初始值的替换

两个数组的内存图：

案例2：

定义两个数组，先定义一个数组，赋值，输出。

然后定义第二个数组的时候吧第一个数组的地址赋值给第二个数据。

然后给第二个数组赋值，再次输出两个数组的名及元素。

原理图如下：

public class array_test2 {
    public static void main(String[] args) {
        int []arr = new int[3];
        arr[0] = 100;
        arr[1] = 111;
        arr[2] = 333;
        System.out.println("arr:"+arr);
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);
        System.out.println("--------------");
        int []arr2 = arr;
        arr2[0] = 222;
        arr2[1] = 444;
        arr2[2] = 555;
        System.out.println("arr[0]:"+arr[0]);
        System.out.println("arr[1]:"+arr[1]);
        System.out.println("arr[2]:"+arr[2]);
        System.out.println("--------------");
        System.out.println("arr2:"+arr2);
        System.out.println("arr2[0]:"+arr2[0]);
        System.out.println("arr2[1]:"+arr2[1]);
        System.out.println("arr2[2]:"+arr2[2]);
        System.out.println("--------------");

    }

}

输出：

arr:[I@7530d0a
arr[0]:100
arr[1]:111
arr[2]:333
--------------
arr[0]:222
arr[1]:444
arr[2]:555
--------------
arr2:[I@7530d0a
arr2[0]:222
arr2[1]:444
arr2[2]:555
--------------

结论：如果两个数组拿的是同一个堆内存的地址，任何一个数组对堆内存数据进行了修改，另一个访问到的也是修改过的。

4.数组初始化之静态初始化：

静态初始化：给出数组中的元素值，由系统决定数组的长度。

格式：

数据类型【】数组名 = new 数据类型【】{元素1，元素2，元素3，...}

举例：

int【】arr = new int【】{1,2,3}；

简化格式：

数据类型【】数组名 = {元素1，元素2，元素3，...}；

举例：

int 【】arr = {1,2,3，....}；

public class array_test3 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println("arr[0]:" + arr[0]);
        System.out.println("arr[1]:" + arr[1]);
        System.out.println("arr[2]:" + arr[2]);
    }
}

输出：

arr[0]:1
arr[1]:2
arr[2]:3

5.数组中常见小问题：

问题1：

public class Array_test4 {
    public static void main(String[] args) {
      int []arr = {1,2,3};
      System.out.println(arr[3]);
    }
}

输出：

报错：ArrayIndexOutOfBoundsException ：数组索引越界异常

问题2：

public class Array_test4 {
    public static void main(String[] args) {
      int []arr = {1,2,3};
//      System.out.println(arr[3]);
        arr = null;
        System.out.println(arr[1]);
    }
}

输出：

报错：NullPointerException ：空指针异常

图解：

常量：null是可以赋值给引用数据类型的，表示该引用不再指向堆内存的数据

6.数组实操练习：

1.数组遍历（依次输出数组中的每一个元素）：

案例代码：

public class array_test5 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5};
        for(int x = 0;x<=4;x++){
            System.out.println("arr["+x+"]:"+arr[x]);
        }
    }
}

输出结果：

arr[0]:1
arr[1]:2
arr[2]:3
arr[3]:4
arr[4]:5

改进：

若不知元素个数，提供一个属性：length

用于获取数据中的元素个数

使用格式：数组名.length

public class array_test5 {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5};
//        for(int x = 0;x<=4;x++){
//            System.out.println("arr["+x+"]:"+arr[x]);
//        }
        for(int x = 0;x<arr.length;x++){
            System.out.println("arr["+x+"]:"+arr[x]);
        }
    }
}

输出结果：

arr[0]:1
arr[1]:2
arr[2]:3
arr[3]:4
arr[4]:5

2.数组中最值获取:

思路：

找一个参照物，这个参照物是数组中的元素，不能为外部元素

A：拿数组中的第一个元素作为参照物

B：遍历数组，从第二个元素开始，依次和参照物进行比较

如果元素比参照物大（小），就留下来做参照物

C：整个比较完毕后，参照物就是最大（小）的数据了

public class max_min {
    public static void main(String[] args) {
        int []arr= {11,21,9,25,31};
        int max = arr[0];
        int min = arr[0];
        for(int x = 1;x<arr.length;x++){
            if(arr[x]>max){
                max = arr[x];
            }
        }
        for (int x =1;x<arr.length;x++){
            if(arr[x]<min){
                min = arr[x];
            }
        }
        System.out.println("max:"+max);
        System.out.println("min:"+min);
    }
}

输出结果：

max:31
min:9

3.数组练习之评委打分：

需求：在编程竞赛中，有6个评委为参赛选手打分，分数为0-100的整数分。

选手最后得分为：减去一个最高分和一个最低分的4个评委平均分

分析：

A：定义一个长度为6的数组

B：评委打分通过键盘录入实现

C：写代码获取数据的最大值（最高分）

D：写代码获取数据的最小值（最低分）

E：求数组中元素的和（总分）

F：平均分 = （总分-最低分-最高分）/（arr.length - 2）

G：输出平均分

public class max_min {
    public static void main(String[] args) {
        int []arr= new int[6];
        Scanner sc = new Scanner(System.in);
        for(int x = 0;x<arr.length;x++){
            System.out.println("请输入评委成绩");
            arr[x] = sc.nextInt();
        }
        int max = arr[0];
        int min = arr[0];
        for(int x = 1;x<arr.length;x++){
            if(arr[x]>max){
                max = arr[x];
            }
        }
        for (int x =1;x<arr.length;x++){
            if(arr[x]<min){
                min = arr[x];
            }
        }
        System.out.println("max:"+max);
        System.out.println("min:"+min);
        int sum = 0;
        for (int x = 0; x<arr.length;x++){
            sum +=arr[x];
        }
        int avg = (sum - max - min)/(arr.length-2);
        System.out.println(avg);
    }
}

4.数组练习之不死神兔：

需求：有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子

假如兔子都不死，问第二十个月的兔子对数为多少？

思路：找规律可得

第一个月： 1

第二个月：1

第三个月：2

第四个月：3

第五个月：5

......

代码实现：

public class rabbits_test {
    public static void main(String[] args) {
        int []arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for(int x =2;x<arr.length;x++){
            arr[x] = arr[x-1]+arr[x-2];
        }
        System.out.println("第二十个月的兔子对数为："+arr[19]);
    }
}

输出：

第二十个月的兔子对数为：6765

big coke

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇之数组篇

1.数组：数组：A：数组是存储多个变量（元素）的东西（容器）B：这多个变量的数据类型要一致数组定义格式：A：数据类型[ ] 数组名；B：数据类型数组名[ ];举例：int 【】arr；定义了一个int类型的数组，数组名是arrint arr【】；定义了一个int类型的变量，变量名是arr数组数组初始化：A：所谓的初始化，其实就是为数组开辟内存空...
复制链接

扫一扫