09 while循环 以及 数组
1 while循环
1.1 形式
while 语句是先判断，后执行
while（执行条件）{
循环体
}
1.2 前序知识
1.2.1生成一个随机数
生成随机数方法：需要调用Random方法；使用与Scanner，需要导包；
int r = new Random().nextInt(100);
其中，100，是为了限定int的取值，控制在【0-100）的范围内；
1.3 案例
package day05;
import java.util.Random;
import java.util.Scanner;
/**
* 本类用于练习while循环
* @author Administrator
*
*/
public class testfor5 {
public static void main(String[] args) {
//需求：产生一个随机数和用户一直输入的数做比较，直到猜对
// 1.生成一个随机数
int r = new Random().nextInt(100); //生成一个整数的随机数，用法与Scanner一致
// System.out.println(r);
// 2.调用一个自定义的猜数字方法
guessNum(r);
}
private static void guessNum(int r) {//方法定义的时候有参数，方法调用的时候必须传参
// 设置调用的方法
/**
* while(判断是否能继续循环的条件）{如果条件的结果为true执行此处循环体的内容}
* 所以，我们用while写死循环，格式while（true）
* 一定注意，死循环设置程序的出口--循环什么时候结束
*/
while(true) {//设置了一个一直会执行的死循环
//1.接收用户猜的数字
System.out.println("请输入您要猜的数：");
int input = new Scanner(System.in).nextInt();
//2.判断用户猜对没有
if(input>r) {
System.out.println("猜大了");
}else if(input1.4 do while 循环
1.5 形式
do{
循环体
}while （执行条件）；
1.6 执行顺序
do while 循环不判断条件，先执行一次循环体输出，然后根据后续while中的执行条件进行判断，如果符合，那么继续执行，如果不符合，停止执行
1.7 案例
package day05;
import java.util.Random;
/**
* 此类用于do while循环的练习
* @author Administrator
*
*/
public class testDowhile {
public static void main(String[] args) {
//
int a;
do {
System.out.println("我是循环体");
a = new Random().nextInt(100);
System.out.println(a);
}while(a>50);
}
}
如果第一次生成的随机数大于50，那么再次执行do中循环体，直至不满足while中执行条件时，停止执行；
2 数组
2.1 概念
数组Array，表示是[ ]，用于存储多个相同类型数据的集合；
想要获取数组中的元素值，可以通过脚标（下标）来获取；
数组下标是从0开始的,下标的最大值是数组的长度减1；
2.2 创建数组
数组的创建方式一般分为动态初始化和静态初始化
动态初始化：
int[] a = new int[5];
只定义了类型与长度，现在只有默认值，没有定义明确的每一个位置上的值，后续使用中可以继续赋值；
静态初始化：
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};
定义了类型，与每一个位置的值，后续已经无法再修改值；
package array;
/**
* 本类用于数组练习的创建
* @author Administrator
*
*/
public class testCareateArray {
public static void main(String[] args) {
//1.创建数组
//1.1 静态创建
char[] c1 = {'h','e','l','l','o'};
char[] c2 = new char[] {'h','e','l','l','o'};
// 第一种写法更简单，所以日常使用更频繁，但应认识第二种写法，俩种功能完全一致；
// 创建的时候已经知道了每一个元素的值
//1.2动态创建
char[] c3 = new char[5];
//在内存中开辟一块连续的内存空间，用来存放5个字符
//现在数组中没有具体的值，后续使用中可以给此数组赋值；
c3 [0]='h'; //给数组赋值第1个元素值
c3 [1]='e'; //给数组赋值第2个元素值
c3 [2]='l'; //给数组赋值第3个元素值
c3 [3]='l'; //给数组赋值第4个元素值
c3 [4]='0'; //给数组赋值第5个元素值
//注意数组下标从0开始
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
//1.3 创建String类型的数组，存放数据“a”，“b”，“c”；
String[] s1 = {"a","b","c"};
String[] s2 = new String [] {"a","b","c"};
String[] s3 = new String[3];
s3[0] = "a"; //给s3数组的第1个元素赋值为"a";
s3[1] = "b"; //给s3数组的第2个元素赋值为"b";
s3[2] = "c"; //给s3数组的第3个元素赋值为"c";
// 1.4 打印创建好的数组
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//打印结果为数组类型的保存地址
System.out.println(Arrays.toString(s3));
//打印结果为具体元素值
// 1.5 查看数组的长度--数组中存放元素的个数
System.out.println(c1.length);
System.out.println(s1.length);
}
}
2.2.1 数组的查看方式
char类型的数组底层中做了处理，可以直接打印数组中的具体元素，除了char类型以外的数组想要查看数组中的具体元素，需要使用数组的工具类Arrays；
具体方式：Arrays.toString(数组名);
注意：Arrays使用时，需要导包
2.2.2 查看数组的长度–数组中存放元素的个数
System.out.println(c1.length);
直接打印输出定义数组的长度即可；注意数组一旦创建，长度不可改变，其在创建时，已经规定好了长度，如果想要增加或者删除数组中的元素，只能先创建一个新长度的数组，再将原数组的数据复制过去；
2.2.3 数组的缩容与扩容
数组的扩容：给数组扩大容量，新数组的长度>原数组的长度
int[]to2=Arrays.copyOf(from, 10);
System.out.println(Arrays.toString(to2));
数组的缩容：所小数组的容量，新数组的长度<原数组的长度
int[] to3 = Arrays.copyOf(from, 3);
System.out.println(Arrays.toString(to3));
2.2.4 指定首尾截取数组中的元素
copyOFRange()用于完成截取数组中的元素，共有3个参数：
参数1：要截取哪个数组【原数组】
参数2：从原数组的哪个下标开始
参数3：从原数组的哪个下标结束
int [] to4 = Arrays.copyOfRange(from, 2, 4);
System.out.println(Arrays.toString(to4));
注意数组下标是从0开始的；
2.3 数组的遍历
数组可以通过for循环进行遍历，从头到尾将数组的每个位置轮一遍
package array;
/**
* 本类用于进一步练习数组
* @author Administrator
*
*/
public class ArraysExct {
public static void main(String[] args) {
//1.创建一个数组，用来存放12个月的天数
int[] month = {31,28,31,30,31,30,31,31,30,31,30,31};
//数组的遍历
//2.通过for循环遍历数组
for (int i=0; i<=month.length-1; i++) {
System.out.println((i+1)+"月有"+month[i]+"天");
}
}
}
我们通过数组下标来操作数组中的元素：
month[0]代表数组的开始，
month[month.lenght-1]表示数组的结束，
变化情况为++
3 数组的练习
3.1 数组与方法的存数据，取数据
1.将上方代码常见一个m1方法，方便后续使用，用于从数组中取数据
2.创建一个动态数组，长度为10，放入方法m2中，用于从数组中存数据
package array;
import java.util.Arrays;
/**
* 本类用于进一步练习数组
* @author Administrator
*
*/
public class ArraysExct {
public static void main(String[] args) {
m1(); //用于从数组中取数据
m2(); //用于从数组中存数据
}
private static void m2() {
// 动态创建长度为10的数组
int[] a= new int [10];
//遍历数组，一次给数组的每一个位置上的元素赋值
//i代表的是数组的下标，从0开始，最大下标是数组的长度-1
for(int i=0; i<=a.length-1; i++){
// 根据每轮循环到的i，作为数组下标，操作数组对应位置上的元素
a[i] = i+4;
}
//循环结束后，说明数组的每个位置都经历了赋值（存数据）
System.out.println(Arrays.toString(a));
//[4,5,6,7,8,9,10,11,12]
}
private static void m1() {
// 创建方法
//1.创建一个数组，用来存放12个月的天数
int[] month = {31,28,31,30,31,30,31,31,30,31,30,31};
//数组的遍历
//2.通过for循环遍历数组
for (int i=0; i<=month.length-1; i++) {
System.out.println((i+1)+"月有"+month[i]+"天");
}
}
}
3.2 存入随机数据以及存入随机长度的数据
package day05;
import java.util.Arrays;
import java.util.Random;
public class ArraysExct2 {
public static void main(String[] args) {
m1(); //创建一个随机数组
m2(); //创建一个随机长度的数组
}
private static void m2() {
// 创建一个长度随机的数据
// int lenght = new Random().nextInt(10); 限定最多位数为10；
int lenght = new Random().nextInt(5)+5; //[0,5]---[5,10]
int[] a = new int[lenght]; //数组的长度是生成的随机长度lenght
//遍历数组，依次向数组中的的每个位置存入随机值
for (int i=0; i<=a.length-1; i++) {
System.out.println(Arrays.toString(a));
}
}
private static void m1() {
//动态创建一个长度为10的数组
int[] a = new int[10];
//遍历数组，依次向数组中的每个位置存入随机值
for (int i=0; i<=a.length-1; i++) {
a[i] = new Random().nextInt(100);
}
//打印存入的数组
System.out.println(Arrays.toString(a));
}
}
长度与数值均可以随机存入；
4 二维数组的创立及遍历
4.1 概念
存放数组的数组，也就是说数组里存的还是数组的数据形式；
4.2 创造二位数组
int[][] a = { {3,5},{7,9},{1,2}};
–创建外部数组,长度是3
–给每个外部数组的位置创建内部数组,每个内部数组的长度是2
–给每个内部数组进行数据初始化
–二维数组生成唯一的地址值
–把地址值交给引用类型变量a来保存
4.3 遍历二维数组
for (int i = 0; i < a.length; i++) {//遍历外部数组
for (int j = 0; j < a[i].length; j++) {//遍历内部数组
System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
}
}
package day05;
import java.util.Arrays;
/**本类用于打印二维数组中的数据*/
public class ArraysExct2 {
public static void main(String[] args) {
//1.创建二维数组
// 3 5
//a[0][0] a[0][1]
// 7 9
//[1][0] a[1][1]
// 1 2 3
//a[2][0] a[2][1] a[2][2]
int[][] a = {
{3,5},{7,9},{1,2,3}};
//2.遍历二维数组
for (int i = 0; i < a.length; i++) {
// System.out.println(Arrays.toString(a[i]));
for (int j = 0; j < a[i].length; j++) {
//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
5 冒泡排序
5.1 概念
冒泡排序（Bubble Sort），是计算机科学领域中较简单的一种排序算法。
它重复地走访需要进行排序的元素，依次比较两个相邻的元素，如果元素的顺序（如从大到小、首字母从A到Z）错误就把元素的位置互换。
走访元素是重复进行的,直到没有任何相邻位置上的元素需要交换位置，排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
5.2 排序思路
依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。
(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
(2)比较第2和第3个数，将小数 放在前面，大数放在后面。
…
(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
(6)依次类推，每一趟比较次数减少依次
5.3 冒泡排序实例
package day05;
import java.util.Arrays;
//本类用于实现冒泡排序
public class BubbleSort {
public static void main(String[] args) {
// 1.创建一个无序的数组
int[] a = {17,96,73,25,21};
//2.调用排序的方法进行排序
method(a);
}
private static void method(int[] a) {
// 需要使用嵌套for循环
// 从1开始，从a.length-1结束
for(int i=1; i<=a.length-1; i++) {//控制的是轮数，加入有n个数，最多比较n-1轮
System.out.println("第"+i+"轮");
//内层循环控制的是在这一轮中比较的次数;j代表的是数组的下标，我们要通过下标操作数组中的元素相邻比较
for(int j=0; ja[j+1]) {//如果前面的数大于后面的数，就交换俩个位置上的元素
int c;
c = a[j]; //将a[j]的值赋值给c
a[j]= a[j+1]; //将a[j+1]的值赋值给a[j]
a[j+1]=c; //将c的值赋值给a[j+1]
}
//System.out.println("排序完成后的数组为："+Arrays.toString(a)); 此处可以查看在每一轮结束后的效果
}
}
System.out.println("排序完成后的数组为："+Arrays.toString(a));
}
}
6 冒泡排序的优化
6.1 排序次数优化
前边代码中，其实已经有关于冒泡排序的优化：
因为前面几轮排序产生的最大值不需要参与后几轮的比较，执行过几轮就会产生几个值不需要参与比较 , i 轮产生 i 个值,所以需要 - i
for(int j=0; j6.2 信号灯思想
实际排序过程中，有时不一定全部执行完循环排序才成功；
排序过程中，只要数据还有交换的变化，那么数据就还在继续执行排序中；
反之，只要数据没有交换的变化，那么表示数据已经排序完成，不需要继续执行后续的循环，