6.java数组

于 2022-09-21 21:08:00 发布
阅读量1.2k 收藏 9
点赞数
文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57206092/article/details/126980781
版权

1.数组

1.数组的介绍

2.数组的定义与静态初始化

1.数组的定义

2.数组的初始化

3.数组的元素访问

1.索引

2.数组的元素访问

4.数组遍历

1.数组遍历

2.案例遍历数组并求和

3.案例统计个数

4.案例变化数据

5.数组动态初始化

1.动态初始化

2.数组默认初始化值的规律

3.静态初始化跟动态初始化的区别

6.数组内存图

7.数组常见问题

8.数组常见操作

1.求最值

2.求和并统计个数

3.交换数据

4.打乱数组中的数据

1.数组的介绍

  1. 数组是一种容器，可以用来存储同种数据类型的多个值
    • 数组容在存储数据的时候，需要结合隐式转换考虑。
    • 比如类型大的可以包含小的
    • 容器的类型，和存储的数据类型保持一致

2.数组的定义与静态初始化

1.数组的定义

  1. 格式

    • 格式一：数据类型 [] 数组名

      范例： int [] array

    • 格式二： 数据类型 数组名 []

      范例： int array []

2.数组的初始化

  1. 静态初始化

    • 初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程
    • 完整格式：数据类型 [] 数组名 = new 数据类型 [] { 元素1 元素2 元素3 ……};
    • 范例：int [] array = new int [] {11,22,33,44};
    • 简化格式：数据类型 []数组名 = { 元素1 元素2 元素3 ……};
    • 范例：int [] array = {11,22,33};

  2. 数组的地址值

    • 数组的地址值就是表示数组在内存中的位置
    • 地址值的格式含义：比如[D@776ec8df
      • [：表示一个数组
      • D：表示当前数组里面的元素都是double类型的
      • @：表示一个间隔符号（固定用法，无特殊含义）
      • 776ec8df：才是数组真正的地址值，（十六进制数）
      • 平时我们习惯性的会把这个整体叫做数组的地址值。

3.数组的元素访问

1.索引

索引：也叫做下标，角标。

索引的特点：从0开始，逐个+1增长，连续不间断

abcde
01234

下面的 01234就是索引

2.数组的元素访问

  • 格式：数组名 [索引]；

    package Scanner;

public class Demo11 {
    public static void main(String[] args) {
        //利用索引对数组中的元素进行访问
        //1.获取数组里面的元素
        //格式：数组名 [索引];

        int [] arr = {1,2,3,4,5};
        //获取数组中的第一个元素
        int number = arr[0];
        System.out.println(number);

        //也可以直接放在输出语句中，并打印出来
        System.out.println(arr[1]);

        //2.把数据存储到数组当中
        //格式：数组名[索引] = 具体的数据或者变量;
        //一旦覆盖之后，原来的数据就不存在了
        arr[3] =  100;
        System.out.println(arr[3]);
    }
}

4.数组遍历

1.数组遍历

数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断……）

注意：遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印

package Scanner;

public class Demo12 {
    public static void main(String[] args) {
        //定义数组
        int [] arr = {1,2,3,4,5};
        //2.获取数组里面的所有元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);

        //可以利用循环改进代码
        //开始条件：0
        //结束条件：4
        for (int i = 0; i <= 4; i++) {
            System.out.println(arr[i]);
        }

        //在java中关于数组的一个长度属性：length
        //调用方式：数组名.length
        //可以看出数组的长度
        System.out.println(arr.length);

        //所以上面的代码可以改进为
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
  • 另外，在idea中可以快速生成数组的遍历方式，
    • 格式：数组名.fori

2.案例遍历数组并求和

package anli;
    //需求：定义一个数组，存储12345，遍历数组得到每一个元素，求数组里面所有的数据和
public class anli1 {
        public static void main(String[] args) {
            //定义一个数组
            int [] arr = {1,2,3,4,5};

            //求和变量
            int sum = 0;
            //遍历数组
            for (int i = 0; i < arr.length; i++) {
                //i依次表示数组里面的每个索引
                //arr[]依次表示数组里面的每一个元素
              sum = sum +arr[i];
            }
            //当循环结束，sum的值就是累加之后的结果
            System.out.println(sum);
        }
}

3.案例统计个数

package anli;
/*需求：定义一个数组，存储1，2，3，4，5，6，7，8，9，10，
遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
 */
public class anli2 {
    public static void main(String[] args) {
        //定义一个数组，存储1，2，3，4，5，6，7，8，9，10，
        int arr [] = {1,2,3,4,5,6,7,8,9,10};

        //统计变量
        int count = 0;

        //遍历数组，得到每一个元素
        for (int i = 0; i < arr.length; i++) {

            //判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次
            if (arr[i] % 3 == 0){
                count++;
            }
        }
        //当循环结束之后，就表示数组里面所有的数字都判断完毕了，直接打印count就行了
        System.out.println("数组中能被3整除的数字有" + count +"个");

    }
}

4.案例变化数据

package anli;
//需求：定义一个数组，存储1，2，3，4，5，6，7，8，9，10
//     遍历每一个元素
//     要求：
//     1.如果是奇数，则将当前的数字扩大两倍
//     2.如果是偶数，则将当前的数字变为二分之一
public class anli3 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arr = {1,2,3,4,5,6,7,8,9,10};

        //遍历每一个元素
        for (int i = 0; i < arr.length; i++) {
            //进行判断
            if (arr[i] % 2 == 0){
                //偶数 变为二分之一
                arr[i]= arr[i] / 2;
            }else {
                //奇数 变为2倍
                arr[i] = arr[i] * 2;
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5.数组动态初始化

1.动态初始化

  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
  • 格式：数据类型 [] 数组名 = new 数据类型 [数组长度]
  • 范例：int [] arr = new int [3]

2.数组默认初始化值的规律

  1. 整数类型：默认初始化值为0
  2. 小数类型：默认初始化值为0.0
  3. 字符类型：默认初始化值为’/u0000’ 展示方式是一个空格
  4. 布尔类型：默认初始化值为false
  5. 引用数据类型：默认初始化值为 null

3.静态初始化跟动态初始化的区别

  1. 动态初始化：手动指定数组长度，由系统给出默认初始化值
    • 只明确元素个数，不明确具体数值，推荐使用动态初始化
    • 举例：使用数组容器来存储键盘录入的5个整数
    • int [] arr = new int[5];
  2. 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度
    • 需求中明确了要操作的具体数据，直接静态初始化即可
    • 举例：将全班的学生成绩存入数组中 11,22,33,
    • int [] arr = {11,22,33};

6.数组内存图

1.java的内存分配

  • 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
  • 堆：存储对象或者数组，new来创建的，都存储在堆内存
  • 方法区：存储可以运行的class文件
  • 本地方法栈：JVM在使用操作系统功能的时候使用
  • 寄存器：给CPU使用

7.数组常见问题

  1. 当访问了数组中不存在的索引，就会引发索引越界异常
package anli;

public class anli4 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arr = {1,2,3,4};
        //长度是4
        //最小索引是0
        //最大索引是3（数组长度-1）
        //如果这时候调用不存在索引，比如
        System.out.println(arr[10]);
		//此时就会出现索引越界异常
       	// Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
		//at anli.anli4.main(anli4.java:11)
    }
}

8.数组常见操作

1.求最值

package anli;
//需求：已知数组元素为{33，5，22，44，55}，请找出数组中最大值并打印在控制台
public class anli5 {
    public static void main(String[] args) {
        //定义数组
        int [] arr = {33,2,22,44,55};

        //定义max变量准备记录擂台上的变化
        int max = arr[0];
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //判断找出最大值
            if (arr[i] > max){
                max = arr[i];
            }
        }
        //循环结束，输出比较后的值
        System.out.println(max);
    }
}

2.求和并统计个数

package anli;

import java.util.Random;

/*需求：生成10个1~100之间的随机数存入数组
1.求出所有数据的和
2.求所有数据的平均数
3.统计有多少个数据比平均值小
 */
public class anli6 {
    public static void main(String[] args) {
        //定义数组
        int [] arr = new int[10];
        //生成随机数,把随机数存入数组中
        Random r = new Random();
        //生成10次
        for (int i = 0; i < arr.length; i++) {
            int number = r.nextInt(100) + 1;
            arr[i] = number;
        }
        //求和
        int sum = 0;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //循环每一个元素
            //并把元素累加起来
            sum = sum + arr[i];
        }
        System.out.println("数组中所有元素的和"+ sum);

        //2.求所有数据的平均数
        int avg = sum / 10;
        System.out.println("平均数为"+ avg);

        //3.统计有多少个数据比平均值小
        //统计变量
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < avg){
                count++;
            }
        }
        //循环结束之后，就表示已经找到了比平均值小的数字的个数
        System.out.println("在数组中低于平均数的数字一共有"+ count +"个");

        //遍历数组验证答案
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

3.交换数据

package anli;
//需求：定义一个数组，存入1，2，3，4，5.按照要求交换索引对应的元素
//交换前：1，2，3，4，5
//交换后：5，4，3，2，1
public class anli7 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arr = {1,2,3,4,5};
        //利用循环去交换数据
        for (int i = 0 , j = arr.length - 1;i < j; i++ , j--){
            //利用第三方变量进行交换
            //交换变量i和变量j指向的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //当循环结束，那么数组中的数据就实现了头尾交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }

    }
}

4.打乱数组中的数据

package anli;

import java.util.Random;

//需求：定义一个数组，存入1~5.要求打乱数组中所有数据顺序
public class anli8 {
    public static void main(String[] args) {
        //定义数组
        int [] arr = {1,2,3,4,5};
        //循环遍历数组，从0索引开始打乱数据的顺序
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成一个随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着随机索引指向的元素跟i指向的元素进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        //当循环结束后，数组中的所有数据就已经打乱了
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

    }
}
午后来杯java
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值