one-05 while 、do-while循环数组

最新推荐文章于 2022-11-30 21:06:21 发布

百川探

最新推荐文章于 2022-11-30 21:06:21 发布

阅读量472

点赞数

分类专栏： one 文章标签： java

本文链接：https://blog.csdn.net/weixin_58828748/article/details/120137588

版权

one 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.while do-while循环

whie循环: 先判断，后执行

while(条件){满足条件执行的循环体 }

public static void main(String[] args) {
		/**参数100是自定义的,此时生成的随机数的范围是[0,100)以内的整数*/
		int r = new Random().nextInt(100);
		System.out.println(r);
		
		guessNum(r);
	}
	//本方法用来完成猜数字的功能
	private static void guessNum(int r) {
		/**while(判断是否能继续循环的条件){如果条件的结果为true,执行此处的代码}
		 * 所以,while经常被用于写死循环: 格式: while(true)
		 * 但是一定注意,死循环一定要设置程序的出口[循环什么时候结束]
		 * */
		System.out.println("猜猜看^_^");
		while(true) {
			int input = new Scanner(System.in).nextInt();
			if(input > r) {
				System.out.println("猜大了");
			}else if(input < r) {
				System.out.println("猜小了");
			}else if(input == r) {
				System.out.println("恭喜你猜对了!");
				break;//当用户猜对了,就结束循环,本处为死循环的出口
			}
		}
	}

do-while循环 : 先执行一次，再判断，如果符合条件，开始第二轮循环，不符合，结束

do{ 循环体 }while(条件);

可以设置死循环，一定注意：死循环一定要设置出口

public static void main(String[] args) {
		int n;
		do{
			System.out.println("我是do");
			n = new Random().nextInt(100);
			System.out.println(n);
		} while(n>50);{
			System.out.println("我是..while");
		}
	}

2.数组

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个字符
	//1.2.2给c3数组动态赋值
	/**通过数组的下标来操作数组中的每一个元素,注意数组下标从0开始*/
	c3[0] = 'h';
	c3[1] = 'e';
	c3[2] = 'l';
	c3[3] = 'l';
	c3[4] = 'o';
	System.out.println(c1);
	System.out.println(c2);
	System.out.println(c3);

1.2 数组创建的过程

开辟内存一块连续的内存空间 ,用来存放多个相同类型的数据
数组完成初始化的过程,给数组内每个元素赋予数组对应的默认值 , 如int的默认值是0
数组完成初始化后 , 分配一个唯一的地址值
把唯一的地址值交给数组的引用类型变量 [数组名] 来保存
先要操作数组中的元素 , 可以根据变量保存的地址找到数组 , 然后根据数组的下标来操作数组的具体元素
注意 : 数组名保存的是数组的地址值,不是数组中的具体元素,数组名是一个引用类型变量

1.3 数组的特性

通过数组的下标来操作数组中的元素, 数组下标从0开始,最大下标是数组的长度减1
数组的长度可以通过"数组名.length"来获取
数组长度不可改变
想要增加或者是删除数组中的元素,需要创建新长度的数组,原数组的长度无法改变

2.数组的工具类Arrays

toString(数组名) : 查看当前数组内的所有元素
除了char类型的数组,其他类型的数组想查看数组内的具体元素都得用toString().

		String[] s1 = {"a","b","c"};
		String[] s2 = new String[] {"a","b","c"};
		String[] s3 = new String[3];
		s3[0] = "a";
		s3[1] = "b";
		s3[2] = "c";
/**char类型的数组底层中做了处理,可以直接打印数组中的具体元素,
* 除了char类型以外的数组想要查看数组中的具体元素,需要使用数组的工具类Arrays
* 具体方式: Arrays.toString(数组名);
* 注意Arrays使用时需要导包*/
		System.out.println(Arrays.toString(s1));
		System.out.println(s2);//直接打印只会输出s2数组的地址值
		System.out.println(s3);

copyOf(要复制的数组名,新数组的长度) : 用来进行数组的复制/缩容/扩容
sort(数组名) : 对数组内的元素快速排序

//查看数组的长度 -- 数组中存放的元素的个数
		/**数组一旦创建,长度不可改变,如果想要增加或者删除数组中的元素,
		 * 只能先创建一个新长度的数组,再将原来的数据复制过去*/
		//System.err.println(c1.length);
		//System.err.println(s1.length);

public static void main(String[] args) {
	int[] from = {1,2,3,4,5};
	//sort()用于数组的排序
	System.out.println(Arrays.toString(sort(from)); 
	/**copyOf()用于完成数组的复制,两个参数:
	 * 参数1: 要复制的数组
	 * 参数2: 新数组的长度
	 * */
	//数组的复制
	int[] to = Arrays.copyOf(from, 5);
	System.out.println(Arrays.toString(to));
	//数组的扩容
	/**扩容: 给数组扩充容量, 新数组的长度 > 原数组的长度*/
	/**扩容思路: 先创建对应长度的新数组,每个位置上都是默认值0
	 * 然后从原数组中将元素复制到新数组,没有被覆盖的元素还是默认值0*/
	int[] to2 = Arrays.copyOf(from, 10);
	System.out.println(Arrays.toString(to2));
	
	/**缩容: 缩小数组的容量, 新数组的长度 <  原数组的长度*/
	/**缩容思路: 先创建对应长度的新数组,每个位置上都是默认值0
	 * 然后从原数组中复制指定个数的元素到新数组中,类似于截取*/
	int[] to3 = Arrays.copyOf(from, 3);
	System.out.println(Arrays.toString(to3));
	
	//指定首位截取原数组中的元素
	/**copyOfRange()用于完成数组的截取,3个参数:
	 * 参数1: 要截取哪个数组 [原数组] 
	 * 参数2:从原数组的哪个下标开始
	 * 参数3:到原数组的那个下标结束*/
	/**注意: 截取的元素包含开始下标处的元素,不包含结束下标处的元素*/
	int[] to4 = Arrays.copyOfRange(from, 2,4);
	System.out.println(Arrays.toString(to4)); //打印结果为[3,4],含头不含尾,左闭右合;
}

3. 遍历动态数组,取数据与存数据

public static void main(String[] args) {
	//m1();//遍历数组取数据
	m2();//遍历数组存数据
}

private static void m2() {
	//1.创建一个长度为10的动态数组
	int[] a = new int[10];
	//2.遍历数组,依次给数组的每个位置上的元素赋值
	for(int i=0 ; i <= a.length-1 ; i++) {
		//a[i] 根据每轮循环得到的i,作为数组下标,操作数组对应位置上的元素
		a[i] = i+100;
	}
	//3.循环结束以后,说明数组的每个位置都经历了赋值 [存数据] 
	System.out.println(Arrays.toString(a));
}

private static void m1() {
	//1.创建一个数组,用来存放12个月每个月的天数
	int[] month = {31,28,31,30,31,30,31,31,30,31,30,31};
	/**数组的遍历: 从头到尾把数组每个位置轮一遍*/
	//通过for循环遍历数组,通过数组下标来操作数组中的元素
	for(int i=0; i<=month.length-1; i++) {
		System.out.println((i+1)+"月有"+month[i]+"天");
	}
}

4.冒泡排序实现代码

具体实现参考: 程序媛泡泡老师

排序思路参考: 程序媛泡泡老师

排序思路：
1）需要比较多轮，如果有n个数，最多比较n-1轮
2）在每一轮中，需要进行多次的相邻比较，如果相邻元素前一个大于后一个，就互换
注意：前面轮中确定的最大值，不需要参与本轮的比较
3）我们使用的是嵌套for循环来完成的：
外层循环循环变量代表的是轮数【数组的长度-1】
内层循环循环变量代表的是数组的下标【轮数越后，次数越少，所以j 随着i 的增大而减小】
4）优化思路：
之前轮中的最大值，不需要参与本轮的比较
如果顺序没有那么乱，我们有可能不需要比较n-1轮，这个时候就需要确定什么时候提前结束剩下的轮数
所以，我们可以设置一个信号量flag,初始值为false,如果一但发生数据的交换，说明顺序还为排好，我们就把flag改为相反的值true,在本轮所有相邻比较结束以后，判断flag是初始值还是中途被修改成了true,如果所有相邻比较都完成，flag没有中途被修改，说明所有数据没有发生交换位置，也就是说，数据已经提前排好序了，那么我们就直接结束剩下几轮的循环，提高效率。

public static void main(String[] args) {
	int [] a = {17,96,73,25,21};
	//3.实际开发中使用Arrays数组工具类的排序方法sort(数组名);
	Arrays.sort(a);
	System.out.println(Arrays.toString(a));
	//method(a);
}

private static void method(int[] a) {
	//1.外层循环 从哪开始1  到哪结束a.length-1  怎么变化++
	/**控制的是轮数,假如有n个数,最多比较n-1轮
	 * 从第一轮开始,最大轮数就是 n [数组元素个数] -1
	 * */
	// i代表的是轮数
	for(int i=1; i <= a.length-1; i++) {
		boolean flag = false; //冒泡排序优化
		System.out.println("第"+i+"轮");
		//内层循环 从哪开始0   到哪结束a.length-i   怎么变化
		/**控制的是在这一轮中比较的次数
		 * 注意j代表的是数组的下标,因为要通过下标操作数组中的元素, 相邻比较
		 * 从数组的0号下标开始,最大下标不是固定的,随着i的变化而变化
		 * 注意: 上一轮确定的最大值,不需要参与本轮的比较,所以i确定i个,要-i
		 * */
		for(int j=0; j<a.length-i;j++) {
			//3.相邻比较,位置不对就,互换位置
			if(a[j] > a[j+1]) { //如果前面的数大于后面的数
				//交换两个位置上的元素
				int t;
				t = a[j];
				a[j] = a[j+1];
				a[j+1] = t;
				flag = true;
			}
		}
		if(flag == false) { //如果经历了内层循环的所有比较,flag还是初始值
			//说明,所有数据已经排序成功,无需进行下一轮排序
			break;
		}
		System.out.println("第"+i+"轮排序后的效果"+Arrays.toString(a));
	}
	System.out.println("排序完成后的数组"+Arrays.toString(a));
}

5.混合案例

    /**本方法用来实现创建随机数组,并通过冒泡排序实现随机生成的数组的排序*/
    public static void main(String[] args) {
        //1.将一个随机数赋值给变量length
        int length = new Random().nextInt(10)+5;
        //2.将变量length存入动态数组a中
        int[] a = new int[length];
        //System.out.println(Arrays.toString(a));
        //3.遍历a数组,并在a数组中存入随机数
        for(int i=0; i<=a.length-1; i++){
            a[i] = new Random().nextInt(100);
        }
        System.out.println(Arrays.toString(a));
        //4.利用冒泡排序实现随机数组a的排序
        //4.1外层循环控制所有数组要比较的轮数
        //从 1 开始  到a.length-1结束  i++
        for(int i=1; i<=a.length-1; i++){
            //5.1冒泡排序优化,设置一个信号变量,赋值false
            boolean flag = false;
            //4.2内层循环控制每轮中相邻数组比较的次数,j代表的是数组的下标
            //从 0 开始  到a.length-i结束(每轮比较都会得出数组内最大元素的结果)  j++
            for(int j=0; j<a.length-i; j++){
                //4.3判断相邻的元素前一个是否大于后一个
                if(a[j] > a[j+1]){
                    //4.4满足条件的相邻元素交换位置
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                    //5.2如果flag的值变成true,则说明数组内还有相邻元素在互换位置
                    flag = true;
                }
            }
            //5.3如果flag的值还是false,则说明数组内没有相邻元素互换位置了,此时结束循环
            if (flag == false){
                break;
            }
            System.out.println("第"+i+"轮循环"+Arrays.toString(a));
        }
        //6.输出排序的最终结果
        System.out.println("排序结果为:"+Arrays.toString(a));
    }