一、思维导图
二、JVM内存模型
1、JVM内存划分，人为的根据内存空间的储存特点以及储存的数据。
(1)程序计数器：当前线程所执行的字节码的型号指示器。
(2)本地方法栈：为虚拟机使用的native方法服务。
(3)方法区：线程共享的内存区域存储已被内存加载的类信息、常量、静态变量即时编译器编译后的代码数据。
(4)java虚拟机栈：简称栈，每个方法被执行的时候都会同时创建一个栈帧用于存储该方法的局部变量、操作栈、动态链接、方法出口等 信息。(每当调用一个方法时，创建一个栈帧，存放了当前方法的局部变量，当方法调用完毕，该方法的栈帧就会被销毁)
(5)java堆：被所有线程共享的一块内存区域，在虚拟机启动时创建。所有的对象实例以及都要在堆上分配(每次使用new关键字，表示在堆内存中开辟一块空间)
图示如下
2、GC垃圾回收器。
java的自动垃圾回收机制可以简单理解为，不需要程序员手动的去控制内存的释放。当JVM内存资源不够用的时候，就会自动去清理堆中无用对象(没有被引用到的对象)所占有的内存空间。
三、一维数组：
(一)、数组的定义——什么是数组
1、在之前我们可以通过一个变量表示一个学生的年龄，但如果要表示100个人的年龄则需定义100个变量，操作太繁琐，为了解决这一问题，java就提供了数组。
2、数组，就是把具有相同类型的多个常量值有序组织起来的一种数据形式。
图示如下
3、数组定义语法(重点)
(1)定义变量的方法：
数据类型 变量； 如 int age;
(2)数组的定义语法：
数组元素类型[] 数组名；
如 第一种方式 ：int[] ages; (推存)
第二种方式 ：int ages[]; (不推存)
(3)可以把int[]看成是一种类型———int类型的数组。
int[]数组可以看出，该数组中的元素是int类型的。
String[]数组可以看出，该数组中的元素类型是String类型
(二)、数组的初始化
1、数组在定义后必须初始化才可使用。
初始化，就是在堆内存中给数组分配储存空间，并为每一个元素赋上初值，有两种方式：
(a)静态初始化：程序员直接为每一个元素设置初始值，而数组的长度有系统(JVM)决定。
语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素1,元素2,元素3,…};
如，int[] nums = new int[]{1,3,5,7};————简单写法为 int[] nums = {1,3,5,7};(定义和初始化同时)
例：静态初始化内存分析
代码：
public class ArrayDemo1 {
public static void main(String[] args){
int[] nums=new int[]{1,3,5,7};//在堆中开辟一块新的空间并赋初始值
System.out.println("数组的长度="+nums.length);//打印数组长度用数组名.length
nums=new int[]{2,4,8};
System.out.println("数组的长度="+nums.length);
}
}
代码分析：
int[] nums=new int[]{1,3,5,7};这一行代码可分成三部：
(1)在堆内存中开辟一块空间，用来存储数组数据：new int[]{1,3,5,7,9};如下图所示
(2)在栈中开辟一块空间nums
(3)把堆空间表示数组的内存地址赋给nums
把这种内存地址赋给一个变量，也被称为引用关系。
nums变量引用了堆中某一块内存地址，当操作nums变量的时候，其实底层操作的是nums搜引用内存地址里面的数据。好比遥控板和电视机的关系，因为遥控板和电视机之间有一个引用关系，表面上操作的是遥控板，其实操作的是电视机。
nums = new int[]{2,4,8};
(1)因为从在new，说明又会在堆中开辟一块新的空间，赋初始值。
(2)并把内存地址重新赋值给nums变量，nums原来引用的地址将会被覆盖掉。
所以此时，通过nums.length代码来查看nums数组中有几个元素，结果很明显是3。注意：此时地址为0x1234的内存空间没有被任何变量所引用，所以该空间就变成了无用垃圾，就等着垃圾回收器回收该空间。
如果存在一行代码，如下：
nums = null;
null表示不再引用堆中的内存空间，那么此时nums就好比是没有初始化的，不能使用。
运行： 
(b)动态初始化：程序员只设置数组元素的个数，而数组元素的初始值由系统(JVM)决定。
语法：数组元素类型[] 数组名 = new 数组元素类型[length];
如 int[] nums = new int[5];
不能同时指定元素值和数组长度，反例如下：
int[] nums = new int[5]{1,3,5,7,9};
不同数据类型的初始值：
| 数据类型 | 默认初始化值 |
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符串(空格)，即’\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示不引用任何对象 |
int[] arr1 = new int[3];————int类型数组，每个元素的初始值为0
double[] arr2 = new double[5];————double类型数组，每个元素初始值为0.0
String[] arr3 = new String[2];————String类型数组，每一个元素的初始值为null
例：动态初始化内存分析(重点)
代码
public class ArrayDemo2 {
public static void main(String[] args){
int[] nums = new int[4];
System.out.println("数组长度="+nums.length);
nums = new int[5];
System.out.println("数组长度="+nums.length);
}
}
代码分析
int[] nums = new int[4]; 这行代码可分为三步：
(1)在堆内存中开辟一块空间，用来存储数组数据
(2)在栈中开辟一块空间nums
(3)把堆空间表示的内存地址赋给nums
nums = new int[3];
(1)因为存在new,说明又会堆对空间中开辟一块空间，赋初始值。
(2)并把内存地址重新赋给nums变量,nums原来所引用的地址将被覆盖掉。
运行：
2、无论哪一种初始化，一旦初始化完成，数组的长度(元素的个数)就固定了，不能改变，除非重新对其初始化，也就是说数组是定长的。
3、一般，如果我们事先知道元素是对少，选用静态初始化，事先不知道，选用动态初始化。
(三)、
1、数组的基本操作1
(a)
int[] nums = new int[]{1,3,5,7};
(1)获取数组长度，语法：int size = 数组名.length;
int size = num.length;————结果是4
(2)获取元素值，语法：元素类型 变量名 = 数组名[index];(数组的索引从0开始，最大索引值是数组的长度-1，那么索引的范围是[0,数组 名.length-1])。
获取第一个元素：int ele1 = nums[0];————输出1
(3)设置元素值，语法：数组名[index] = 值；
设置第二个元素的值为20 nums[1] = 30;
(b)操作数组常见的异常
(1)NullPointerException:空指针异常(空引用异常)
操作了一个尚未初始化或者没有分配内存空间的数组
int[] nums = null;
int size = nums.length;
(2)ArrayIndexOutOfBoundsException:数组的索引越界异常
操作的数组的索引不在[0,数组名.length-1]范围内
int[] nums = new int[]{1,3,5,7};
int ele = nums[nums.length];
2、迭代数组(遍历数组)
代码：
public class ArrayDome3 {
public static void main(String[] args){
int[] nums = new int[]{1,3,5,7};
for(int index=0;index<nums.length;index++){
int ele = nums[index];
System.out.println(ele);
}
}
}
运行：
©数组基本操作3
使用for-each(增强for循环)操作数组
for(数组元素类型 变量：数组){
//TODO
}
使用for-each操作数组更简单，因为可以不关心索引，其底层原理依然是上述for循环操作数组。
public class ArrayDome3 {
public static void main(String[] args){
int[] nums = new int[]{1,3,5,7};
for(int ele : nums){
System.out.println(ele);
}
}
}
运行
(四)、
(1)使用循环操作数组-案例1
int[] nums = new int[]{11,22,33,55,22,44};
需求：找出数组中元素22第一次出现的索引位置
代码：
public class ArrayDemo4 {
public static void main(String[] args){
int key = 22;
int[] nums = new int[]{11,22,33,55,22,44};
for(int index=0;index<nums.length;index++){
if(nums[index] == key){
System.out.println(index);
}
}
}
}
运行：
(2)使用循环操作数组-案例2
int[] nums = new int[]{11,22,33,55,22,44};
需求：求出int类型数组中最大元素值
代码：
public class ArrayDome5 {
public static void main(String[] args){
int[] nums = new int[]{11,22,33,55,22,44};
int max = nums[0];
for(int index = 0;index<nums.length;index++){
if(nums[index] > max){
max = nums[index];
}
}
System.out.println("max="+max);
}
}
运行：
三、
1、二维数组：数组中每个元素就是一个一维数组。
其实发现，这种多维数组都可以简单称之为，数组中的数组。
2、定义和静态初始化二维数组的语法：
数组元素类型[][] 数组名 = new 数组元素类型[][]{数组1，数组2，数组3，…}；
注意：二维数组中元素类型是一维数组，把数组元素类型[]看成一个整体，表示数据类型。
代码：
public class ArrayInArrayDemo1 {
public static void main(String[] args){
int[] arr1={1,2,3};
int[] arr2={4,5};
int[] arr3={6};
int[][] arr = new int[][]{arr1,arr2,arr3};
}
}
3、二维数组——动态初始化
(1)定义和静态初始化二维数组的语法：
数组元素类型[][] 数组名 = new 数组元素类型[x][y];
x表示二位数组中有几个一维数组，y表示每个一维数组中有几个元素。
int[][] arr = new int[3][5];
System.out.println(arr.length);//输出3
(2)因为二维数组表示数组中的数组，如果要获取数组的每一个元素值，则需要两个循环嵌套。
//二维数组
int[][] arr = new int[][]{
{1,2,3};
{4,5};
{6};
}
4、迭代二维数组
(a) 使用for循环：
例：
代码：
public class ArrayDome5 {
public static void main(String[] args){
for(int index = 0;index<arr.length;index++){
int[] arr2= arr[index];
for(int j=0;j<arr2.length;j++){
int ele = arr2[j];
System.out.println(ele);
}
System.out.println("------");
}
}
}
(b)使用for-each:
例：
代码：
public class ArrayDome5 {
public static void main(String[] args){
for(int[] arr2:arr){
for(int ele : arr2){
System.out.println(ele);
}
System.out.println("-------");
}
}
}
扫一扫
1189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
