Java中的数组详解笔记(2022.4.18)

数组

1、数组的定义

  • 数组是相同类型数据的有序结合。
  • 数组存储的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
  • 其中,每一个数据称做一个数组元素,每个数组元素可以通过一个下标来访问它们。

2、数组的声明与创建

  • 首先必须声明数组变量,才能在程序中使用数组。声明数组变量的语法:
      int[] i;   // 首选的方法  Java中使用这种
      
      int i[];  // 效果相同,但不是首选方法
  • Java中语言使用new关键字来创建数组,语法如下:
      int[] i = new int[arraySize];   // 就是说定义什么类型的数组,就要new什么类型的数组并且给予值
      
      int[] i = new int[5];  // 意思就是这个int中可以存储5个数字
  • 数组的元素是通过索引访问的,数组索引从0开始
      package com.zhai.array;
      
      public class Array {
          public static void main(String[] args) {
      //        int[] i;   // 第一种方法:定义一个数组
      //        i = new int[3];  // 创建一个数组
              int [] i = new int[2];   // 第二种方法:一次性创建数组
              i[0]=3;
              i[1]=12;
              System.out.println("我是数组中第一个数据:"+i[0]);
              System.out.println("我是数组中第二个数据:"+i[1]);
          }
      }
      输出:
      	我是数组中第一个数据:3
      	我是数组中第二个数据:12

- 获取数组长度时候array.length

    package com.zhai.array;
    public class ArrayDemo2 {
        public static void main(String[] args) {
            int[] i = new int[10];
            i[0]=1;
            i[1]=2;
            i[2]=3;
            i[3]=4;
            i[4]=5;
            i[5]=6;
            i[6]=7;
            i[7]=8;
            i[8]=9;
            i[9]=10;
            int sum = 0;
            for (int j = 0; j <i.length ; j++) {
               sum = sum + i[j];   // i:就表示数组的长度,j:就是循环的次数最后把和赋给sum
            }
            System.out.println(sum);  // 进行输出
        }
    }
    输出:
    	55

3、数组中的内存分析

01、堆内存

  • 就是存放new对象和数组
  • 可以被所有线程共享,不会存放别的对象引用。
    如:int[] i = new int[2];

解析:=左边的就是栈内存,在计算机中有块内存名为 i 没有数据的时候并无意义;相反当=右边有关键字new出现的时候,在计算机中会开辟一块内存里面并且可以存储2个数据都是相同类型的数据,这些数据的编号(也就是所谓的下标)是从0开始的,就是取出数据的时候会用到也就是堆内存(存储行同类型的数据)。

02、栈内存

  • 存放基本变量类型(包含这个进本类型的具体数值)
  • 引用对象的变量(会存放这个引用在堆里面的具体地址)

03、方法区

  • 可以被所有线程共享
  • 包含了所有class和static变量

4、数组的三种初始化

  • 静态初始化
    int[] a = {1,2,3}    // 这个创建数组的含义就是直接赋值为1,2,3 不灵活
    Man[] mas = {new Man(1,1),new Man(2,2);   // 引用类型,把自定义类通过new进行初始化
  • 动态初始化
    int[] i = new int[2];  // 这个数组就是在堆内存中开辟一块大小为2的内存,只能存储两个数据类型统一是int
    i[0]=3;     // 给开辟好的内存进行赋值  0就是第一个数据为3
    i[1]=12;    // 第二个数据为12
  • 数组的默认初始化
    • 数组是引用类型,它的元素相当于类的实例变量,一次数组经分配空间,其中的每个元素也被按照实力变量同样的方式被隐式初始化。
    package com.zhai.array;
    
    public class ArrayDemo3 {
        public static void main(String[] args) {
            // 静态数组
            int[] i = {2,3,4,5,6,7,8,9};
            System.out.println("我是静态数组:"+i[5]);
            // 动态数组
            int[] i1 = new int[8];
            i1[0]=312;    // 赋值为第一个数据为312
            System.out.println("我是动态数组:"+i1[0]);
            // 默认初始化值
            System.out.println("我是动态数组的默认初始化值:"+i1[1]);
        }
    }
    输出:
    	我是静态数组:7
    	我是动态数组:312
    	我是动态数组的默认初始化值:0

01、数组的四个基本特点

  • 长度是确定的,数组一旦被创建,它的大小就是不可改变的;
  • 其元素必须是相同类型,不能出现混合类型;
  • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
  • 数组变量是属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量;数组本身就是对象,Java中对象是存储在堆内存中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

02、数组边界

  • 下标的合法区间:[0,length-1],如果越界就会报错;
    package com.zhai.array;
    
    public class ArrayDemo3 {
        public static void main(String[] args) {
    		// 数组越界异常
            int[] i2 = new int[2];
            i2[1]=2;
            System.out.println("我是正常的边界:"+i2[1]);   // 这个是可以正常输出的
            System.out.println(i2[2]);   
      // 因为下标是从0开始所以这个已经越界了,因为在初始化数组时已经给过容量大小,所以不能超过最大数值
        }
    }
    输出:
    	我是正常的边界:2
    	java.lang.ArrayIndexOutOfBoundsException    // 数组越界异常
  • 小结:
    • 数组是相同的数据类型(数据类型可以为任意类型)的有序集合
    • 数组也是对象,数组元素与对象的成员变量
    • 数组长度是确定的,不可变的;如果越界,则报:java.lang.ArrayIndexOutOfBoundsException

03、数组使用

  • For-Each 循环
  • 数组作为方法传入参数
  • 数组作为返回值

小练习:

    package com.zhai.array;
    public class ArrayDemo4 {
        public static void main(String[] args) {
            // 输出所有的数组数据
            int[] a = {12,23,34,56,67,78,89};
            for (int i = 0; i <a.length ; i++) {
                System.out.println(a[i]);
            }
            System.out.println("======================================");
            // 输出所有数据的和
            int b = 0;
            for (int i = 0; i <a.length ; i++) {
                b+=a[i];
            }
            System.out.println("总和为:"+b);
            System.out.println("======================================");
            // 抽取这些数字中最大的数字 
            int c = a[0];   // 这个就是把那些数字的第一个数字赋值给c
            for (int i = 0; i <a.length ; i++) {
                if (c<a[i]){      // 然后拿c跟后面的数字进行比较,谁比第一个数字大
                    c = a[i];    // 就把谁赋值给c
                }
            }
            System.out.println("最大数为:"+c);  // 然后进行输出
        }
    }
    输出:
        12
        23
        34
        56
        67
        78
        89
        ======================================
        总和为:359
        ======================================
        最大数为:89
数组的使用:
    package com.zhai.array;
    
    public class ArrayDemo5 {
        public static void main(String[] args) {
            // 定义静态数组
            int[] a = {1,2,3,4,5};
    
            // 调用普通for循环的输出方法
            printArrays(a);
            // 调用forEach循环的输出方法
            Each(a);
            // 比较大小
            int b = a[0];
            for (int i = 0; i <a.length ; i++) {
                if (b<a[i]){
                    b = a[i];
                }
            }
            System.out.println("最大的数为:"+b);
            // 调用反转的方法
            int[] res = fanZhuan(a);
            printArrays(res);
        }
    
        // 普通的输出数组中的所有数据
        public static void printArrays(int[] b){
            for (int i = 0; i < b.length; i++) {
                System.out.println(b[i]);
            }
        }
        // 使用foreach进行输出所有的数据
        public static void Each(int[] c){
            for (int x:c) {   // forEach 有个弊端就是没有下标
                System.out.println("使用ForEach进行输出的结果:"+x);
            }
        }
        // 反转数组
        public static int[] fanZhuan(int[] arrays){
            int[] ints = new int[arrays.length];
            // 反转操作
            for (int i = 0, j=ints.length-1; i <arrays.length; i++,j--) {
                 ints[j] = arrays[i];
            }
            return ints;
        }
    }

以上就是Java中数组使用的方式!

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值