• 数组


    数组

    数组的定义

    存储同一种数据类型多个元素的容器

    数组的定义格式

    第一种格式(推荐)

    int[] array
    double[] array
    char[] array
    boolean[] array 
    

    第二种格式

    int array[]
    double array[]
    char arra[]
    boolean array[] 
    

    数组的动态初始化

    初始化格式

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

    int[] arr = new int[5];//数组长度arr.length
    

    初始化特点

    我们给定数组的长度, 初始化值由系统决定

    初始化:就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程

    数组的静态初始化

    初始化格式

    int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7} //完整版格式
    
    int[] arr = {1, 2, 3, 4, 5, 6, 7}          //简化版格式
    

    数组的两种初始化格式的区别

    动态初始化:只给定数组长度,由系统分配默认初始化值

    静态初始化:创建数组时,直接将元素确定

    数组操作的两个常见问题

    数组索引越界异常

    public class ArrayException {
        public static void main(String[] args) {
            int[] arr = new int[3]; //索引 0 1 2
            System.out.println(arr[10]);
        }
    }
    

    ​ 出现原因:访问了不存在的数组索引

    ​ 解决方案:改成正确的索引范围即可

    数组空指针异常

    public class ArrayException {
        public static void main(String[] args) {
            int[] arr = new int[3]; // 索引0 1 2
            System.out.println(arr[2]);
            // 空指针异常
            arr = null; // 空值
            System.out.println(arr[0]);
        }
    }
    

    ​ 出现原因:数组引用为null时,再去操作数组

    ​ 解决方案:给数组一个真正的堆内存空间引用即可

    数组元素访问

    访问数组元素的格式

    arr[0]  第1个元素
    arr[1]  第2个元素
    arr[2]  第3个元素
    arr[3]  第4个元素
    arr[4]  第5个元素
    ...     ...
    

    索引

    
    //索引是给每个元素起一个编号,通过编号可以获取指定元素
    
    //索引从0开始,索引是连续的,索引逐一增加,每次加1,最大索引是数组长度(arr.length)-1
    

    内存分配

    栈内存: 方法运行时,进入的内存,局部变量都存放于这块内存

    堆内存: new出来的内容都会进入堆内存,并且会存在地址值

    方法区: 字节码文件(.class文件)加载时进入的内存

    本地方法栈: 调用操作系统相关资源

    寄存器: 交给CPU去使用

    注意:每new一次,在堆内存中,都是一块新的空间,堆内存中的空间地址不会出现重复的现象

    数组的实际应用

    数组的遍历

    遍历数组通用格式

    int[] arr = {……};
    for(int i=0; i<arr.length; i++) {
    	arr[i]	 //对arr[i]进行操作
    }
    

    数组获取最大值和最小值

    public class MaxArray {
        public static void main(String[] args) {
            int[] arr = {12,45,98,73,60};
            // 1. 假设数组中的第一个元素为最大值
            int max = arr[0];
            // 2. 遍历数组, 获取每一个元素, 进行比较
            for(int i = 1; i < arr.length; i++){
            // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
                if(arr[i] > max){
                    max = arr[i];
                }
            }
            //  4. 循环结束后, 打印最大值.
            System.out.println("max:" + max);
        }
    }       //获取最小值只需要把if判断中的>改为<即可
    

    数组元素求和

    public class SumArray {
        public static void main(String[] args) {
            // 1.创建键盘录入对象,准备键盘录入
            Scanner sc = new Scanner(System.in);
            // 2.定义一个求和变量,准备记录累加后的结果
            int sum = 0;
            // 3.动态初始化一个长度为5的int数组,准备存储键盘录入的数值
            int[] arr = new int[5];
            // 4.将键盘录入的数值存储到数组中
            for(int i = 0; i < arr.length; i++){
                System.out.println("请输入第" + (i+1) + "个整数:");
                arr[i] = sc.nextInt();
            }
            // 5.遍历数组,取出每一个元素,并求和
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            // 6.输出总和
            System.out.println("sum:" + sum);
        }
    }
    

    数组基本查找

    public class SearchArray {
        public static void main(String[] args) {
            // 1.定义一个数组,用静态初始化完成数组元素的初始化
            int[] arr = {19, 28, 37, 46, 50};
            // 2.键盘录入要查找的数据,用一个变量接收
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您要查找的元素:");
            int num = sc.nextInt();
            // 3.定义一个索引变量,初始值为-1
            // 假设要查找的数据, 在数组中就是不存在的
            int index = -1;
            // 4.遍历数组,获取到数组中的每一个元素
            for (int i = 0; i < arr.length; i++) {
            // 5.拿键盘录入的数据和数组中的每一个元素进行比较,如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
                if(num == arr[i]){
            // 如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
                    index = i;
                    break;
                }
            }
            //  6.输出索引变量
            System.out.println(index);
        }
    }
    

    反转数组

    public class ReversalArray {
        public static void main(String[] args) {
            //1. 定义数组
            int[] arr = {11, 33, 22, 55, 44};
            //2. 反转数组
            for (int i = 0; i < arr.length/2; i++) {
                int temp = arr[i];
                arr[i] = arr[arr.length - 1 - i];
                arr[arr.length - 1 - i] = temp;
            }
            //3. 打印数组.
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);;
            }
        }
    }
    
  • 相关阅读:
    多种 网页文本编辑器 分析
    struts2 令牌 实现源代码 JSP
    ibatis 数据库时间 插入数据
    Eclipse/Myeclipse生成serialVersionUID方法
    SSM框架整合遇到的问题
    搭建Elasticsearch5.6.8 分布式集群
    使用SuperWebSocket 构建实时 Web 应用
    HAPROXY
    .NET面试题系列(二)GC
    MongoDB-3.4集群搭建:分片
  • 原文地址:https://www.cnblogs.com/tyrion4396/p/13375088.html
Copyright © 2020-2023  润新知