day_05：循环高级和数组

一、循环高级

1. 无限循环

for循环：

for (;;) {
    System.out.println("学习");
}

while循环：

while(true) {
    System.out.println("学习");
}

do...while循环：

do {
    System.out.println("学习");
}while(true)

注意

无限循环的下面不能再写其他代码了，因为循环永远停不下来，那么下面的代码永远执行不到。

2. 跳转控制语句

在循环的过程中，跳到其他语句上执行。

continue:

跳过本次循环，继续执行下次循环。

break:

结束整个循环。

3. 获取随机数

1. 导包 ---Random这个类在哪

   import java.util.Random;

   导包的动作必须出现在类定义的上边。

2. 创建对象---表示我要开始用Random这个类了

   Random r = new Random ();

​ 上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。

3. 生成随机数---真正开始干活了

   int number =r.nextInt(随机数的范围);

   上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。

   注意：范围包头不包尾。

二、数组

1. 数组介绍

数组：是一种容器，可以用来存储同种数据类型的多个值；

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

2. 数组的定义

格式一：

数据类型 [] 数组名
int [] array

格式二：

数据类型 数组名 []
int array []

3. 静态初始化

初始化：

就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

完整格式：

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

简化格式：

数据类型 [] 数组名 = {元素1，元素2，元素3...};

4. 数组元素访问

地址值

数组的地址值表示数组在内存中的位置。

地址值的格式含义：[D@776ec8df

• [：表示当前是一个数组；
• D：表示当前数组里面的元素都是double类型的；
• @：表示一个间隔符号。(固定格式)；
• 776ec8df：才是数组真正的地址值，(十六进制)；
• 平时我们习惯性的会把这个整体叫做数组的地址值。

元素访问

访问数组：

int 接收变量 = 数组名[索引];

添加元素：

数组名[索引] = 元素值；

5. 数组遍历

将数组中所有的内容取出来，取出来之后可以(打印，求和，判断..)

格式：

for (int i = 0; i < 数组名.length; i++) {
    }

注意

• 数组名.length 是获取数组的长度

• 遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印!

6. 数组动态初始化

始化时只指定数组长度，由系统为数组分配初始值。

格式：

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

范例：

int[] arr = new int[3];

数组默认初始化值规律：

数据类型	初始化值
整数	0
小数	0.0
字符	/u0000，表现为空格
布尔	false
引用	null

7. 两种初始化区别

• 动态初始化：手动指定数组长度，由系统给出默认初始化值。只明确元素个数，不明确具体数值，推荐使用动态初始化
• 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。需求中已经明确了要操作的具体数据，直接静态初始化即可。

8. 数组内存图

Java内存分配：

内存区	作用
栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆	存储对象或者数组，new来创建的，都存储在堆内存
方法区	存储可以运行的class文件
本地方法栈	给CPU使用，和我们开发无关
寄存器	JVM在使用操作系统功能的时候使用，和我们开发无关

规律：

1. 只要是new出来的一定是在堆里面开辟了一个小空间；
2. 如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据；
3. 当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。

9. 数组常见问题

当访问了数组中不存在的索引，就会引发索引越界异常。

• 最小索引：0；
• 最大索引：数组长度 - 1。

10. 数组常见操作

求最值：

• 最大值：

  //定义数组
  int[] arr = {1, 2, 3, 4, 5};
  
  //定义变量记录最大值
  int max = arr[0];
  
  //遍历数组
  for (int i = 1; i < arr.length; i++) {
      if (arr[i] > max) {
          max = arr[i];
      }
  }
  
  //输出结果
  System.out.println(max);

• 最小值：

  //定义数组
  int[] arr = {1, 2, 3, 4, 5};
  
  //定义变量记录最大值
  int min = arr[0];
  
  //遍历数组
  for (int i = 1; i < arr.length; i++) {
      if (arr[i] < min) {
          min = arr[i];
      }
  }
  
  //输出结果
  System.out.println(min);

小技巧

max和min的初始化值一定要是数组中的值；

当初始值为数组索引0时，循环条件可以从1开始，提高效率。

求和：

//定义数组
int[] arr = {1, 2, 3, 4, 5};

//定义变量存储求和
int sum = 0;

//遍历数组求和
for (int i = 0; i < arr.length; i++) {
    sum += arr[i];
}

//输出结果
System.out.println("和为：" + sum);

交换数据：

//定义数组
int[] arr = {1, 2, 3, 4, 5};

//遍历数组
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

//输出结果
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

打乱数据：

//定义数组
int[] arr = {1, 2, 3, 4, 5};

//创建随机数对象
Random r = new Random();

//遍历数组
for (int i = 0; i < arr.length; i++) {
    //获取随机数组索引
    int randomindex = r.nextInt(arr.length);

    //将随机索引与i交换
    int temp = arr[i];
    arr[i] = arr[randomindex];
    arr[randomindex] = temp;
}

//输出结果
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}

附：练习题

1. 需求：有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}，再通过键盘录入一个整数数字，把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。

   //创建键盘录入对象
   Scanner sc = new Scanner(System.in);
   
   //键盘录入一个整数
   System.out.println("请输入一个整数：");
   int num = sc.nextInt();
   
   //定义数组
   int[] arr = {12, 14, 23, 45, 66, 68, 70, 77, 90, 91};
   
   //定义新数组
   int[] arr2 = new int[arr.length + 1];
   
   //遍历数组
   for (int i = 0; i < arr.length; i++) {
       if (arr[i] > num) {
           arr2[i] = num;
           num = arr[i];
       } else {
           arr2[i] = arr[i];
       }
   }
   
   //将最后一个元素添加到arr2中
   arr2[arr2.length - 1] = num;
   
   //输出结果
   for (int i = 0; i < arr2.length; i++) {
       System.out.print(arr2[i] + " ");
   }

2. 需求：定义一个数组其中包含多个数字，用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边（可以创建其他数组，不必须在原数组中改变）。

   //定义原数组
   int[] arr = {1, 2, 3, 4, 5, 6, 7};
   
   //定义新数组
   int[] arr2 = new int[arr.length];
   
   //定义变量存储奇数与偶数的索引
   int index1 = 0;
   int index0 = arr.length - 1;
   
   //遍历数组
   for (int i = 0; i < arr.length; i++) {
       if (arr[i] % 2 == 1) {
           arr2[index1] = arr[i];
           index1++;
       } else {
           arr2[index0] = arr[i];
           index0--;
       }
   }
   
   //输出结果
   for (int i = 0; i < arr2.length; i++) {
       System.out.print(arr2[i] + " ");
   }