Java循环与数组详解-优快云博客

课程回顾：

Java分支结构
- 循环是程序设计语言中反复执行某写代码的一种计算机处理过程，是一组相同或相似语句被有规律的重复执行。说白了就是反复执行一段相同或相似的代码
- 循环三要素：
  - 循环变量的初始化
  - 循环的条件(以循环变量为基础)
  - 循环变量的改变(向着循环的结束变)
- 需要多次重复执行一个或多个任务的问题考虑使用循环来解决，一般情况for循环使用最多。
- 循环问题定义——当循环：
  - 如果业务转换为当这样时，优先选择while语句来实现。
- 循环问题定义——直到循环：
  - 如果业务转换为直到这样时，优先选择do-while语句来实现。
- 循环问题定义——固定次数循环
  - 如果业务中获取一个确切的循环次数，考虑for循环。

什么是数组：

程序 = 算法 +数据结构
if、if-else、switch、for等循环解决都是流程问题，即算法问题。
所谓的数据结构，就是把数据按照特定的某种结构来保存。
数据是最基本的一种数据结构。
相同数据类型的元素组成的集合。
元素按线性顺序排列，所谓线性顺序是指除第一个元素外，每个元素都有唯一的前驱元素，除最后一个元素外，每一个元素都有唯一的后继元素（一个跟一个）
可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始、最大到元素个数-1）
数组的声明：

int[] arr = new int[10];
int[] 是指数组种每一个元素都是int类型的值。
arr 数组的变量。
int[10] 数组的长度。

定义数组的要点：
- 确切的数据类型。
- 整体的数组名字。
- 不能缺少 “[]”。
在执行new语句才使得数组分配到指定的大小空间。
int[] arr | int arr[] 两种写法都可以。
声明数组时，不规定数组长度，new关键字分配空间时需要指定分配的空间大小。
基本类型的数组创建后，元素的初始值：byte、short、char、int、long为0，float、double为0.0，boolean为false。
可以在数组的声明同时对数组的元素进行初始化：

int[] arr = {15,22,33,12,10,1};
元素的个数即为数组的长度。

这种写法只能用于声明时的初始化，不能用户赋值。

int[] arr；
arr = {15,22,33,12,10,1};
这样写法会导致代码编译错误。

可以通过已声明的数组进行初始化。

int[] arr；
arr = new int[]{15,22,33,12,10,1};
这种写法[]中不可以写长度，元素的个数就是数组的长度。

获取数组的长度：

int[] arr = new int[]{1,2,3};
int i = arr.length;
System.err.println(i);
结果：3

通过下标访问数组元素。

int[] arr = new int[] { 1, 2, 3 };
int i = arr[2]; // 获取数组中的最后一个元素，因为数组的下标是从0开始计算。
System.err.println(i);

遍历数组中的元素，通常选择fo循环语句，循环变量作为访问数组元素的下标，即可以访问数组中的每一个元素。

int[] arr = new int[] { 1, 2, 3 };
for (int i = 0; i < arr.length; i++) {
	System.err.println(arr[i]);
}

使用System.arraycopy()方法可以实现数组的复制。

int[] a = {1,2,3,4,5,6};
int[] b = new int[6];
System.arraycopy(a,1,b,0,4);
从a数组的第二个元素开始复制，b数组从0开始粘贴，共复制4个元素。

使用java.util.Arrays类的copyOf方法可现实数组的复制类型。
- 特点：生成的新数组是原始数组的副本。
- 所以产生的新数组可以大于复制数组的长度。

int[] a = {1,2,3,4,5};
int[] b = Arrays.copyOf(a,6);
b数组中的元素为：1,2,3,4,5,0

数组的长度在创建后是不可改变的，所谓扩建是指创建一个更大的新数组并将原有数组的内容复制到其中。
可以通过Arrays.copyOf()方法，实现数组的扩展。

int[] a = {1,2,3,4,5};
a = Arrays.copyOf(a,a.length + 1);
扩展以后数组中的元素为：1,2,3,4,5,0

排序是对数组施加的最常用的算法。
所谓排序，是指将数组中元素按照大小顺序（从大到小或者从小到大），重新排列，
常用的排序算法有：插入排序，冒泡排序、快速排序等。
冒泡排序的原则：比较相邻的元素，如果违反最后的顺序准则，则交换
- 第一次找到所有元素中最大的放在最后一个位置上，不在变动。
- 第二次找到剩余所有元素中最大的放在倒数第二个位置上，以此类推。
JDK提供了Arrays.sort()方法封装了数组的排序算法。

int[] arr = {98，22,35,12,19,56,31,2,3};
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
	System.out.println(arr[i]);
}
排序后：2,3,12,19,22,31,35,56,98

使用for循环输出99乘法表：

public static void main(String[] args) {	
	for (int i = 1; i <= 9; i++) { // 控制行
		for (int j = 1; j <= i; j++) { // 控制列
			System.out.print(j + "*" + i + "=" + j * i + "\t");
		}
		System.out.println(); // 换行
	}
}
结果为：
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

冒泡算法执行顺序：

public static void main(String[] args) {
	System.err.println("随机数组声明");
	int[] arr = new int[10];
	for (int i = 0; i < arr.length; i++) {
		arr[i] = (int) (Math.random() * 100);
		System.out.println(arr[i]);
	}
	System.err.println("冒泡算法开始");
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
		System.err.println(Arrays.toString(arr));
	}
	System.err.println("冒泡算法结束");
	System.err.println(Arrays.toString(arr));
}
随机数组为：
	34,88,97,38,67,5,95,71,89,66
执行顺序为：
	[34, 88, 38, 67, 5, 95, 71, 89, 66, 97]
	[34, 38, 67, 5, 88, 71, 89, 66, 95, 97]
	[34, 38, 5, 67, 71, 88, 66, 89, 95, 97]
	[34, 5, 38, 67, 71, 66, 88, 89, 95, 97]
	[5, 34, 38, 67, 66, 71, 88, 89, 95, 97]
	[5, 34, 38, 66, 67, 71, 88, 89, 95, 97]
	[5, 34, 38, 66, 67, 71, 88, 89, 95, 97]
	[5, 34, 38, 66, 67, 71, 88, 89, 95, 97]
	[5, 34, 38, 66, 67, 71, 88, 89, 95, 97]
冒泡结束为：
	[5, 34, 38, 66, 67, 71, 88, 89, 95, 97]
原理：
	在元素中先查找最大的，放到数组中的最后一位，
	在从剩下的元素中查找第二大的，放到倒数第二的位置上，以此类推。