day07_一维数组

其他 2020-03-24 18:50:17 阅读次数: 0

数组

由来

  • 假如现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。

容器概念

  • 容器：是将多个数据存储到一起，每个数据称为该容器的元素。生活中的容器：水杯，衣柜，教室

数组概念

  • 数组： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。

数组的概述

  • 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。
  • 数组的长度一旦确定，数组的长度在程序运行期间不可改变。
  • 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
  • 数组当中的多个数据，类型必须统一

数组的分类：

  • 按照维度：一维数组、二维数组、三维数组、… 
  • 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

数组的初始化

  • 数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

  • 动态初始化（指定长度）：定义数组且为数组元素分配空间与赋值的操作分开进行。
  • 静态初始化（指定内容）：在定义数组的同时就为数组元素分配空间并赋值。

动态初始化数组

格式：

格式详解：

  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [ ] : 表示数组。
  • 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
  • new：关键字，创建数组使用的关键字。
  • 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
  • [长度]：数组的长度，表示数组容器中可以存储多少个元素。

注意：

  • 数组有定长特性，长度一旦指定，不可更改。和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。

举例：

package demo;

//动态初始化:数组的初始化和数组元素的赋值操作分开进行
public class DemoArray {
    public static void main(String[] args) {
        // 创建一个数组，里面可以存放300个int数据
        int[] arrayA = new int[300];

        // 创建一个数组，能存放10个double类型的数据
        double[] arrayB = new double[10];

        // 创建一个数组，能存放5个字符串
        String[] arrayC = new String[5];
    }
}

静态初始化

基本格式：

  • 数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, ... };

举例：

package demo;


//静态初始化:数组的初始化和数组元素的赋值操作同时进行
public class DemoArray {
    public static void main(String[] args) {
        // 直接创建一个数组，里面装的全都是int数字，具体为：5、15、25
        int[] arrayA = new int[]{5, 15, 25, 40};

        // 创建一个数组，用来装字符串："Hello"、"World"、"Java"
        String[] arrayB = new String[]{"Hello", "World", "Java"};
    }

}

省略格式：

  • 数据类型[ ] 数组名称 = { 元素1, 元素2, ... };

 举例：

package demo01;
 
public class DemoArray {
    public static void main(String[] args) {
        //定义存储1，2，3，4，5整数的数组容器
        int[] arr = {1, 2, 3, 4, 5};
    }
 
}

注意：

  • 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
  • 静态初始化标准格式可以拆分成为两个步骤。
  • 动态初始化也可以拆分成为两个步骤。
  • 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

举例

package demo01;
 
 
/*
使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
 */
public class DemoArray {
 
    public static void main(String[] args) {
        // 省略格式的静态初始化
        int[] arrayA = {10, 20, 30};
 
        // 静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[]{11, 21, 31};
 
        // 动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];
 
        /*
        静态初始化的省略格式，不能拆分成为两个步骤。
        int[] arrayD;
        arrayD = { 10, 20, 30 };
        错误
         */
 
    }
 
}

数组元素的默认初始化值

  • 数组是引用类型，它的元素相当于类的成员变量，因此数组一经 分配空间，其中的每个元素也被按照成员变量同样的方式被隐式 初始化。数组的默认值如下图所示：

               

 一维数组元素的使用

  • 定义并用运算符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的长 度(元素个数) 数组一旦初始化，其长度是不可变的

总结一下：

访问数组中的元素

  • 格式： 数组名[索引]

为数组中的元素赋值

  • 格式：数组名[索引]=数值

获取数组中的元素，赋值给指定变量

  • 格式：变量=数组名[索引]

获取数组中的元素个数

  • 格式：数组名.length

举例：

package demo;

public class DemoArray {
    public static void main(String[] args) {
        // 直接创建一个int类型长度为3的数组
        int[] array = new int[3];
        //如何调用数组的指定位置的元素:通过角标的方式调用。
        System.out.println("int类型数组的默认值是" + array[0]);//int类型数组的默认值是0

        //数组的角标（或索引）从0开始的，到数组的长度-1结束,给数组的指定index赋值。
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        System.out.println(array[0]);//1
        // 获取数组中的元素，赋值给指定变量
        int j = array[2];
        System.out.println(j);//3
        
        //如何获取数组的长度。属性:length
        System.out.println("数组中的元素个数是" + array.length);//数组中的元素个数是3

        //数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。 
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);// 1 2 3
        }

    }

}

数组原理内存图

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

  • JVM的内存划分：

详解：

数组在内存中的存储

一个数组内存图 

package demo02;
 
public class Test {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//[I@5f150435
    }
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素 

                      

两个数组内存图 


package demo02;
 
public class Test {
    public static void main(String[] args) {
        int[] arr = new int[3];
        int[] arr2 = new int[2];
        System.out.println(arr);
        System.out.println(arr2);
    }
}

                             

两个变量指向一个数组

package demo02;
 
public class Test {
    public static void main(String[] args) {
        // 定义数组，存储3个元素
        int[] arr = new int[3];
        //数组索引进行赋值
        arr[0] = 5;
        arr[1] = 6;
        arr[2] = 7;
        //输出3个索引上的元素值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //定义数组变量arr2，将arr的地址赋值给arr2
        int[] arr2 = arr;
        arr2[1] = 9;
        System.out.println(arr[1]);
    }
}

                        

练习题 


import java.util.Scanner;

/*
 * 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
		成绩>=最高分-10    等级为’A’
		成绩>=最高分-20    等级为’B’
		成绩>=最高分-30    等级为’C’
		其余                               等级为’D’
		提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
 *
 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        //1.使用Scanner，读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = scanner.nextInt();

        //2.创建数组，存储学生成绩：动态初始化
        int[] scores = new int[number];
        //3.给数组中的元素赋值
        System.out.println("请输入" + number + "个学生成绩：");
        int maxScore = 0;
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scanner.nextInt();
            //4.获取数组中的元素的最大值:最高分
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }
        //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        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);
        }

    }
}

数组越界异常 

观察一下代码，运行后会出现什么结果。 

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

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。 

数组空指针异常

观察一下代码，运行后会出现什么结果

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

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。 

数组反转 

数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

实现思想：数组最远端的元素互换位置。

  • 实现反转，就需要将数组最远端元素位置交换
  • 定义两个变量，保存数组的最小索引和最大索引
  • 两个索引上的元素交换位置
  • 最小索引++，最大索引--，再次交换位置
  • 最小索引超过了最大索引，数组反转操作结束 

代码实现

package demo03;
 
/*
数组元素的反转：
本来的样子：[1, 2, 3, 4]
之后的样子：[4, 3, 2, 1]
要求不能使用新数组，就用原来的唯一一个数组。
 */
public class Demo07ArrayReverse {
 
    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50 };
 
        // 遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");
 
        /*
        初始化语句：int min = 0, max = array.length - 1
        条件判断：min < max
        步进表达式：min++, max--
        循环体：用第三个变量倒手
         */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
 
        // 再次打印遍历输出数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
 
}

 

java_pedestrian
发布了20 篇原创文章 · 获赞 7 · 访问量 6623
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_44462792/article/details/105003110
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022