[Java]循环高级+数组

无限循环（死循环）

循环条件一直为真时，循环体内的内容会反复重复的执行。

无限循环下不能写其他代码了，循环一直执行会使无限循环下面的代码执行不到

for(;;){

}

while(true){

}

do{

}while(true);

跳转控制语句

循环执行过程中跳转到其他语句执行。

案例：小老虎吃包子

public class Test3 {
    public static void main(String[] args) {
        for (int i = 0; i <=5; i++) {
            if (i == 3) {
                continue;
            }
            System.out.println("吃："+i);
        }
    }
}

·continue ：结束本次循环继续下一次循环

·break：结束所有的循环

数组

存储同种数据类型的多个值的容器

但是数组容器在存储数据的时候，需要结合隐式转换考虑。例如：

        定义了一个int类型的数组。那么boolean。double类型的数据是不能存到这个数组中的，

但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

建议：容器的类，和存储的数据类型保持一致。

数组的定义：

格式一：数据类型[] 数组名

int [] array

格式二：数据类型 数组名[]

int array[]

数组的初始化：

初始化：在内存中为数组容器开辟空间并将数据存到容器的过程

格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，....}

简化格式：数据类型[] 数组名 = {元素1，元素2，....}

范例：int[] array = new int[]{11,22,33}

package day6;
//静态初始化
public class Msz1 {
    public static void main(String[] args) {
        int[] arr1 = {10,12,14,13};
        String[] arr2 = new String[]{"tom","bob","alie","faye"};
    }
}

地址值：

数据在内存中存放的位置的编号

打印数组的时候，实际出现的是数组的地址值。

public class Msz1 {
    public static void main(String[] args) {
        int[] arr1 = {10,12,14,13};
        String[] arr2 = new String[]{"tom","bob","alie","faye"};
        System.out.println(arr1);//输出数组地址[I@776ec8df
    }
}

[ ：表示现在打印的是一个数组。

I：表示现在打印的数组是int类型的。

@：仅仅是一个间隔符号而已。

776ec8df：就是数组在内存中真正的地址值。（十六进制的）

数组元素访问：

public class Msz2 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        arr1[2] = 10;
        System.out.println(arr1[2]);
    }
}

格式：

数组名[索引];

索引：

也叫角标、下标；就是数组容器中每一个小格子对应的编号。

• 索引一定是从0开始的。
• 连续不间断。
• 逐个+1增长。

作用： 

• 获取数组中对应索引上的值
• 修改数组中对应索引上的值

数组的遍历：

遍历：就是把数组里面所有的内容一个一个全部取出来

数组长度：数组名.length

public class Msz2 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        arr1[2] = 10;
        System.out.println(arr1[2]);

        for (int i = 0; i < arr1.length-1; i++) {
            System.out.println("第"+i+"为"+arr1[i]);
        }
    }
}

一个循环只干一件事情 ！！！

动态初始化：

初始化时只给定数组的长度，由系统分配初始值

创建的时候，数组的长度由我们自己给定，由虚拟机给定默认初始化值

格式：

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

int[] arr =new int[3];

public class Msz6 {
    public static void main(String[] args) {
        String[] arr = new String[10];
        arr[0] = "tom";
        arr[1] = "jack";
        arr[2] = "lisi";

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

数组默认初始化值： 

整数类型：0

小数类型：0.0

布尔类型：false

字符类型：'\u0000'

引用类型：null

两种初始化的区别：

静态初始化：int[] arr = {1,2,3,4,5};

动态初始化：int[] arr = new int[3];

静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。

动态初始化：手动指定数组长度，由系统给出默认初始化值。

使用场景：

只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。

已经明确了要操作的所有数据，推荐使用静态初始化。

例如：

1.使用数组来存储键盘录入的5个整数。

int[] arr = new int[5];       //动态初始化

2.将全班的学生成绩存入数组中，已知学生成绩为：66,77,88,99,100   

使用静态初始化：int[] arr = {66,77,88,99,100};

Java内存分配

Java的内存分配图：

栈：本地方法运行时使用的内存，比如main方法运行，进入方法栈中执行

堆：存储对象或者数组，new来创建的，都在堆中存储

方法区：存储可以运行的class文件

本地方法栈：JVM操作系统功能的时候使用

寄存器：给CPU使用

程序开始执行时，程序的入口（main）会进栈，代码执行完毕出栈。

public static void main(String[] args){//栈
int a = 10;//栈
int b = 10;//栈
c = a+b;//栈
sout(c);//栈
}

 栈中存储数组名，数组开辟的内存空间存储在堆内存中。arr用数组在堆中的地址获取到数组存储的数据。只要是new出来的一定是在堆里面开辟一个小空间，如果new了多次就会在堆里开辟多个小空间，每个小空间有各自的数据

public static void main(String[] args){//栈
int[] arr = new arr[10];//栈中存储数组名，都组开辟的内存空间存储在堆内存中。arr用数组在堆中的地址获取到数组存储的数据
sout(arr[1]);
arr[0]= 11;
sout[arr0];
}

arr2 赋予arr1的地址后，arr2所存储的数据和arr1中存储的数据相同 ，因为他们访问的是同一片内存地址。其中一个数组对小空间中的值改变，另一个数组访问得到是改变后的值

int[] arr1 = new arr[10];
int[] arr2 = arr1; //将arr1存储的堆内存地址赋值给arr2