day07数组

数组学习

• JVM的内存模型

  • clas文件,加载进类装载器,进入内存(内存中有方法区,虚拟机栈,堆)
  • 程序计数器:当前线程所执行的字节码的行号指示器
  • 本地方法栈:为虚拟机使用的native本地方法服务
  • 方法区:线程共享的内存区域,存储已被虚拟机加载的类信息,final常量,静态变量即时编译器编译后的代码数据等(内存回收的目标主要针对常量池的回收和对类型的卸载)
  • 虚拟机栈(stack):每个方法执行的时候都会同时创建一个栈区,用于存储方法的局部变量,操作栈,动态链接,方法出口等信息每当调用一个方法时,创建一个栈,存放当前的局部变量,方法调用完毕,栈就被销毁了:java方法执行时,在栈区执行
  • 堆(heap):被所有的线程共享的一块内存区域,所有的对象实例和数组都要放在堆上分配/每次使用new关键字,就表示要在堆上开辟一块新的存储空间
  • GC(Garbage Collection):垃圾回收器:不需要程序员手动释放内存,JVM内存资源不够的时候,会自动的清理堆中的无用对象所占用的内存空间.

• 数组(Array)

  • 定义:把具有相同类型的多个值有序组织起来的一种数据形式,数组中的每一个常量叫做数组元素(item/ele),索引(index)用来表示元素存放位置,从0开始,步长为1.数组在内存中是一段连续的内存空间.

  • 数据类型[] 变量名;

  • 1.数组是引用数据类型,引用堆中的地址(内存空间). 2.引用数据类型默认值是null.3.数组定以后必须初始化才能使用,也就是在堆内存中分配存储空间; 初始化:通过new关键字,开辟一块连续的内存空间.

    • 静态初始化:给数组中的每一个元素都给定初始化值,数组的长度由系统决定,不能再给定数组的长度. 实际开发中,如果已知了数组的值,优先使用静态初始化.

      • 动态初始化:只设置数组元素的个数,而数组元素的初始值由JVM决定. 也就是程序员提前申请好内存空间,在程序运行的过程中再添加数值./

        • 堆中的内存空间是有默认值的,必须先声明后初始化,再使用,

        • 栈中的内存没有默认值,变量内存分配在栈中,所以变量必须先声明,后赋值,再使用.

        • 整形为0,

          float为0.0,

          String为null,

          char为一个空字符(不是空格),

          boolean为false.

          语法: 数组元素类型[] 数组名 = new 数组元素类型[length];

  int[] arr;
  //声明一个float类型的数组
  float[] scores;//加s
  float[] scoreArr;//结尾加Arr或者Array
  //声明一个数组用来存储整个班级的姓名
  String[] nameArray = null;
  //声明数组
  int[] array;
  //动态初始化
  array = new int[4];//在jvm内存中申请了4块int类型连续的内存空间;栈中的array引用了堆中的0x1234这块地址,也叫作array指向了堆中的地址
  //静态初始化
  int[] array1 = new int[]{10,20,30,40};
  //访问数组的长度(元素的个数)
  System.out.println(array1.length);
  //访问元素 语法: 数组名[index],index从0开始到length - 1
  int item1 = array1[0];
  System.out.println(item1);
  //修改数组元素的值
  array[0] = 100;
  System.out.println(array[0]);
  array = new int[]{100,200,300};//在堆中重新划分一块新的内存空间,让array重新引用堆中的地址/内存空间.
  
  
  //声明数组的字面量写法
  //数组的字面量声明和赋值必须写在一行上
  int[] array2 = {1,2,3,4};
  

• 数组的长度:arr.length

  • 存取数组的元素:arr[index];会存在下标越界的问题[0,length - 1];ArrayIndexOutOfBoundsException/越界异常 第二个问题:空指针异常NullPointerException,堆中没有内存空间

  • 遍历数组:挨个访问数组的每一个元素; 数组一定会结合for使用,

    • 语法:for循环或者增强for循环for (int item : arr){ }

      item叫做迭代变量

      增强for循环特别适合于读取数据,但是不适合做数组的更改操作

    • 普通遍历和快速遍历的区别

      1.普通遍历:通过index既能读取数据,又能改变数据

      2.快速遍历:只能读取元素,不能改变元素的值

      3.如果在开发过程中,index如果参与业务逻辑,最好不要用快速遍历

//需求:找出数组中元素XX第一次出现的索引位置,如果找不到,打印该元素不存在
int[] arr = {11,22,33,44,22,55};
int target = 44;
for(int i = 0;i < arr.length;i++){
    if (arr[i] == 44){
        System.out.println("第一次出现的位置是" + i);
        return;
    } 
}
System.out.println("您找的元素不存在");

//或者
int index = -1;
for(int i = 0;i < arr.length;i++){
    if (arr[i] == target){
        index = i;
        break;
    }
}
if (index < 0){
    System.out.println("找的元素不存在");
} else {
    System.out.println("元素" + target + "第一次出现的位置为" + index);
}

//或者
int j = 0;
for(;j < arr.length;j++){
    if(arr[j] == target){
        break;
    }
}
if (j == arr.length){
    System.out.println("不存在");
} else {
    System.out.println("出现的位置在" + j);
}

//或者
boolean isFound = false;
for(int i = 0;i < arr.length;i++){
    if (arr[i] == target){
        isFound = true;
        break;
    }
}
if(isFound){
    System.out.println("找到了");
} else {
    System.out.println("没找到");
}

//求数组中的最大元素值
int[] nums = {11,22,33,44,22,55};
int max = nums[0];
for (int i = 1;i < nums.length;i++){
    if (nums[i] > max){
        max = nums[i];
    }
}
System.out.println(max);

//需求:按照某种格式打印元素,数组放在方括号当中
int[] arr = {11,22,33,44,55};
String info = "[";
for (int i = 0;i < arr.length;i++){
    if(i == arr.length - 1){
     info += arr[i] + "]";
    } else {
   	 info += arr[i] + ",";
    }
}
System.out.println(info);

• 二维数组:数组中的每一个元素都是一个一维数组,元素存的是一维数组的地址

  语法:数组元素类型[ ] [ ] 数组名 = new 数组元素类型 [ ] [ ] {数组1,数组2,数组3,…};

//定义一个二维数组
int[][] array = null;
int[] arr1 = {1,2,3};
int[] arr2 = {10,20,30};
int[] arr3 = {100,200,300};
array = new int[][]{arr1,arr2,arr3};

//遍历数组
for (int i = 0;i < array.length;i++){
    for (j = 0;j < array[i].length;j++){
        System.out.print(array[i][j] + "  ");
    }
    System.out.println();
}