Java大数据学习第五天---while do-while循环 数组 方法重载 冒泡排序

于 2021-12-06 19:51:04 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： Java大数据学习 文章标签： java big data 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61747318/article/details/121754485
版权

复习

结构

  1. 顺序结构
  2. 分支结构 if
  3. 循环结构 for
  4. 选择结构 switch

变量

  1. 成员变量
  2. 局部变量

第五天

while循环

  1. 结构：

    while（循环条件）{

    ​ 循环体；

    }

do-while循环

  1. 结构：

    do{

    循环体；

    }while（循环条件）；

三种循环区别

  1. for：知道循环次数
  2. while/do while：当循环次数不确定时
  3. while：先判断，不符合规则，不执行代码
  4. do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
  5. 循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码哦~

数组

  1. 概念：

    数组Array，标志是[ ] ,用于储存多个相同类型数据的集合，想要获取数组中的元素值，可以通过脚标（下标）来获取，数组下标是从0开始的,下标的最大值是数组的长度减1

  2. 创建数组：

    • 静态创建
      • 类型[] 数组名={数组的组成元素}
      • 类型[] 数组名=new 类型{数组的组成元素}
    • 动态创建
      • 类型[] 数组名=new 类型[数组长度]

  3. 数组创建过程

    • 例子：程序创建数组 int[] a = new int[5]; 时发生了什么?
    1. 在内存中开辟连续的空间,用来存放数据,长度是5
    2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
    3. 数组完成初始化会分配一个唯一的地址值
    4. 把唯一的地址值交给引用类型的变量a去保存

  4. 数组长度：数组的长度用 length属性来表示,数组一旦创建，长度不可改变，数组的长度允许为0

    ​ 使用时 数组名.length

  5. 数组特性：

    1. 数组的长度通过**数组名.length;**来获取
    2. 数组一旦创建，长度无法改变
    3. 数组的下标从0开始，最大下标为数组长度-1
    4. 如果访问到了不存在的下标，会数组下标越界异常

  6. 数组的工具类Arrays

    • toString(数组名)，除了char类型以外，其他类型的数组想要查看数组的具体元素，都得使用这个方法，如果不用，打印是数组的地址值
    • sort(数组名)，给数组进行排序
    • copyOf(要复制的数组，新数组的长度)
      如果新的长度大于原数组的长度–数组的扩容
      如果新的长度小于原数组的长度–数组的缩容
      如果新的长度等于原数组的长度–普通的复制
      注意：不管是什么长度，都不是修改原数组，而是创建新数组

  7. 数组的遍历

    • 如果只是想查看数组中有哪些元素，直接使用System.out.println(Arrays.toString(数组名))；就可以
    • 如果想要拿到数组中的一个个的具体元素，或者是对数组中的元素做进一步的操作，就需要对数组进行遍历
    • 遍历：把数组中的所有元素，从头到尾逐个“过一遍”
    • 通过循环遍历数组，所以循环中的循环变量代表的是数组的下标

冒泡排序

排序思路：要比较多轮，每轮两个相邻的元素做比较，位置不对就互换
代码思路：
通过嵌套for循环来完成

外层循环：控制的是轮数，如果有n个数，最多n-1轮
内层循环：控制的是每轮中比较的次数，每一轮的次数会递减，之前轮确定的最大值不应该参与后面轮的比较
注意：外层循环的循环变量代表的是轮数1 2 3 4…
内层循环的循环变量代表的是数组的下标[0,a.length-i）

方法的重载

/*我们通过方法名+参数列表确定具体调用哪个方法/

	/**方法的重载
	 * 在同一个类中 存在方法名相同 但是参数列表不相同的方法
	 * 如果在同类中 同名方法的参数个数不同 一定构成重载
	 * 如果在同类中 同名方法的参数个数相同 可能构成重载
	 * (int a,String b)和(int b,String a)---不构成重载  
	 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
	 * (int a,String b)和(String a,int b)---构成重载
	 * */

今日案例

案例一
package cn.yedu.review;

import java.util.Random;
import java.util.Scanner;

import javax.annotation.processing.SupportedSourceVersion;

/**测试while*/
public class TestWhile {
	public static void main(String[] args) {
		//需求  产生一个随机数,和用户猜的数字进行比较,直到用户猜对
		//1.创建并调用生成随机数的方法  根据业务分析 哟返回值
		int r = creatNum();
		System.out.println("生成的随机数:"+r);
		//3.创建并调用 猜数字的方法
		guessNum (r);
	
	}

	private static void guessNum(int r) {
		//让用户去猜数字
		/**while常用作死循环  循环条件直接写true.但 死循环必须再合适的时候 设置出口*/
		while(true ){//死循环要设置出口
			//5.提示并接受用户才的数字
			System.out.println("猜猜看:");
			int input = new Scanner(System.in).nextInt();
			//6.判断用户是否猜对()
			if(input>r) {
				System.out.println("猜大了,悠着点");
			}else if(input<r) {
				System.out.println("猜小了,悠着点");
			}else if(input==r) {
				System.out.println("猜对了");
				break;//猜对了就停止循环  死循环的出口
			}
			
		}
		
	}

	private static int creatNum() {
		//2.让方法产生一个随机数
		/**这个值100是我们自定义的,此时生成的随机数范围是[0,100)以内的整数*/
		int random = new Random().nextInt(100);//表示生成int类型随机数
		return random;
	}
}
        
案例二
package cn.yedu.review;

import java.util.Random;

/**测试do-while*/
public class TestDoWhile {
	public static void main(String[] args) {
		int n ;
		do {
			System.out.println("我是循环体");
			n = new Random().nextInt(300);//导包Random   生成随机数0-300不包含300
			System.out.println(n);
		}while(n>100);
		/**do-while  至少会执行一次 , 再做判断 ,符合条件,继续循环   适合至少会执行一次的循环*/
		
	}
}
案例三
    package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的创建*/
public class TestArray {
	public static void main(String[] args) {
		//1.创建数组
		//1.1静态创建数组--创建数组的时候已经确定了每个元素的具体值
		char[] c1= {'h','e','l','l','o'};//创建一个char类型数组  char[]   是一个引用类型 表示一个char类型数组
		char[] c2= new char[] {'h','e','l','l','o'};
		
		//1.2动态创建数组--只知道数组的长度 后续再动态给数组每个元素赋值
		char[] c3=new char[5];//在内存中开辟一块连续空间,用来存放5个字符--数组长度为5,有默认值
		/**我们通过数组的下标来操作数组中的每一个元素,数组下标从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);
		
		//3.创建String类型数组  存放 a  b  c
		//3.1静态
		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(Arrays.toString(s2));
		System.out.println(Arrays.toString(s3));
	}
}
案例四
package cn.tedu.array;

import java.util.Arrays;

/**回顾数组创建方式*/
public class TestArray2 {
	public static void main(String[] args) {
		//1.
		int[] a= {1,2,3,4,5,6};
		int[] b=new int[] {1,2,3,4,5,6};
		int[] c= new int[6];
		c[0] = 1;
		c[1] = 2;
		c[2] = 3;
		c[3] = 4;
		c[4] = 5;
		c[5] = 6;
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.toString(b));
		System.out.println(Arrays.toString(c));
		/**int 是基本类型 int[]代表的是int数组,是引用类型
		 * 而 数组类型的变量比如a,保存的就是数组的地址值,而不是数组中的多个具体元素*/
		System.out.println(a);
		/**注意:数组一旦创建,数组的长度不可以改变 
		 *如果想要增加或者删除数组中的元素,只能重新创建一个新长度的数组,再将原来的数据复制过去*/
		System.out.println(a.length);//6  数组a的长度  
		
	}
}
案例五
package cn.tedu.array;

import java.util.Arrays;
import java.util.Random;

/**本类用于数组练习*/
public class TestArrayExec {
	public static void main(String[] args) {		
		//1.创建一个获取1年中12个月每个月天数的方法 ,打印x月有x天
		dayOfMonth();
		//2.存数据 创建一个方法 像int数组存入1-10
		addNumToArrays();
		//3.创建随机数组:创建一个长度为6的随机整型数组 
		creatArrays();
	
	}
//3.
	private static void creatArrays() {
		int[] a=new int[6];//创建长度为6的动态数组
		for(int i = 0;i<6;i++) {//数组遍历 依次存入数据
			a[i]=new Random().nextInt(100);//随机0-100的数据
		}
		//循环结束 打印数组
		System.out.println(Arrays.toString(a));
	}
//2.
	private static void addNumToArrays() {
		//创建一个长度为10的int数组
		//遍历数组 像数组中每个位置依次存入数据
		int[] a=new int[10];
		for(int i=0;i<10;i++) {
			a[i]=i+1;			
		}
		//for循环结束之后
		//循环存入数据以后 打印查看数组中的具体元素
		System.out.println(Arrays.toString(a));
	}
//1.
	private static void dayOfMonth() {
		// 创建一个int类型数组来存12个月的天数
		int[] a= {31,28,31,30,31,30,31,31,30,31,30,31};
		//数组的遍历--
		//从那开始:数组的第一个元素:a[0]
		//到那结束:数组的第十二个元素:a[11]-----a[a.length-1]
		//如何变化:数组的下标++
		for(int i=0;i<=a.length-1;i++) {
			System.out.println(a[i]);
			System.out.println((i+1)+"月有"+a[i]+"天");
		}
		
	}
}
案例六
 package cn.tedu.array;

import java.util.Arrays;

/**本类用于练习数组的扩容与缩容*/
public class TestArraysCopyOf {
	public static void main(String[] args) {
		//1.创建数组
		int[] from= {1,2,3,4,5};//数组一旦创建,长度不可改变
		//1.1数组的普通复制
		/**
		 * Arrays.copyOf()用于完成数组的赋值,两个参数
		 * 参数1:要复制那个数组
		 * 参数2:新数组的长度
		 * */
		int[] to=Arrays.copyOf(from,5);//有返回值  所以要用int[]接受一下复制完毕的新数组	
		System.out.println(Arrays.toString(to));//[1,2,3,4,5]
		
		//1.2数组的扩容
		/**
		 * 扩容:给数组扩大容量,新数组的容量大于原数组的容量
		 * 扩容思路:先创建对应新长度的新数组,每个位置初始化默认值0
		 * 然后从原数组中将数据复制到新数组,没有被覆盖的位置还是0
		 * */
		int[] to2=Arrays.copyOf(from,10);	
		System.out.println(Arrays.toString(to2));//[1,2,3,4,5,0,0,0,0,0]
		
		//1.3数组的缩容
		/**
		 * 缩容:缩小数组容量,新数组容量<原数组容量
		 * 缩容思路:先创建对应长度的新数组,每个位置初始化默认值为0
		 * 然后从原数组中赋值指定个数的数据到新数组中,类似于"截取"一部分
		 * */
		int[] to3=Arrays.copyOf(from,3);
		System.out.println(Arrays.toString(to3));//[1,2,3]
		
		//1.4 指定首尾 截取原数组中的元素
		/** copyOfRange()用于完成数组的截取
		 * 参数1:要截取那个数组[原数组]
		 * 参数2:从哪个下标开始[包含此元素]
		 * 参数3:到那个下标结束[不包含此下标的元素]*/
		int[] to4=Arrays.copyOfRange(from,2,4);
		System.out.println(Arrays.toString(to4));//[3,4]
		
		int[] to5=Arrays.copyOfRange(from,1,7);//截取并扩容
		System.out.println(Arrays.toString(to5));//[2,3,4,5,0,0]  
		
		
		
	}
	
		
}   
案例七
package cn.tedu.basic;

import java.util.Arrays;

/**冒泡排序*/
public class BubbleSort {
	public static void main(String[] args) {
		//创建一个无序数组
		int[] a= {27,96,73,25,21};
		//调用自己实现的排序方法进行排序
		//方法一
		method(a);
		//方法二  
		/**我们使用数组工具类Arrays的sort()对数组元素进行排序*/
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
	}

	private static void method(int[] a) {
		//外层循环 控制比较的轮数 假设有n个数 最多比较n-1轮
		//循环变量代表的是轮数 比如五个数 最多比较四轮,i取值[1,2,3,4]代表4轮
		for(int i=1;i<=a.length-1;i++) {
			System.out.println("第"+i+"轮");
			//内层循环 控制数组中的两个相邻元素进行比较 位置不对就进行互换位置
			//循环变量代表的是数组的下标
			for(int j=0;j<a.length-i;j++) {
				//相邻比较,a[j]代表数组的前一个数,a[j+1]表示后一个数
				if(a[j]>a[j+1]) {
					//交换位置
					int t;
					t=a[j];
					a[j]=a[j+1];
					a[j+1]=t;
					
				}
			}
			System.out.println("第"+i+"轮比较后的结果:"+Arrays.toString(a));
		}
		System.out.println(Arrays.toString(a));
	}
}    
案例八
package cn.tedu.basic;
/**本类用于测试方法的重载*/
public class TestMethod {
	public static void main(String[] args) {
		/**我们通过方法名+参数列表确定具体调用哪个方法*/
		
		/**方法的重载
		 * 在同一个类中 存在方法名相同 但是参数列表不相同的方法
		 * 如果在同类中 同名方法的参数个数不同 一定构成重载
		 * 如果在同类中 同名方法的参数个数相同 可能构成重载
		 * (int a,String b)和(int b,String a)---不构成重载  
		 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
		 * (int a,String b)和(String a,int b)---构成重载
		 * */
		//1
		method();
		//2
		method(666);
		//3
		method(999,"感冒灵");
		//4
		method("感冒灵",999);
	}
	
	//1
	private static void method() {
		System.out.println("哈哈哈我没有参数~~");
	}
	//2
	private static void method(int a) {
		System.out.println("哈哈哈哈我的参数是:"+a);
	}
	//3
	private static void method(int a,String b) {
		System.out.println("哈哈哈我没有参数~~");
	}
	//4
	private static void method(String a,int b) {
		System.out.println("哈哈哈我没有参数~~");
	}
}
打字超慢
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现选择排序(for do_while while 递归)
qq_41962626的博客
11-10 734
原理（默认从小到大排序） ** 遍历数组，找到最小的元素下标 假设第一个是最小的key=A[0]，如果后边的比key大小，比如A[5] <A[key] ，那么key = 5，直到找到最小的 下标 0 1 2 3 4 5 6 7 8 9 元素 5 8 2 1 6 9 4 3 7 0 key = 0 for(int j = 0+1;j < N;j...
python嵌套循环实现冒泡排序_Python嵌套循环实现冒泡排序
weixin_39871562的博客
12-03 678
冒泡排序是中的经典算法，手动实现冒泡排序，对初学者锻炼自己的编程逻辑有很大帮助，本节就带领大家使用循环结构实现冒泡排序算法。冒泡排序算法的实现思想遵循以下几步：比较相邻的元素，如果第一个比第二个大，就交换它们两个。从最开始的第一对到结尾的最后一对，对每一对相邻元素做步骤 1 所描述的比较工作，并将最大的元素放在后面。这样，当从最开始的第一对到结尾的最后一对都执行完后，整个序列中的最后一个元素便是最...
java 冒泡排序 do while
LWSX2010的专栏
03-19 281
/** * @param a */ public static void bubbleSort1(int[] a) { int j = a.length-1;// 最后一个没有排序过元素的指数 boolean exchange;// 交换旗帜变量 = 假 （False） do { exchange = false; for (int i = 0; i < j; i++) ...
冒泡求和排序do while
zhangxh1013的专栏
09-30 852
$sum=0;  $sum1=0;  $sum2=0;  for($i=1;$i  {   $sum+=$i;   $sum1+=++$i;  //偶数和   $sum=$i+$sum;   $sum2=$sum-$sum1;  }    echo$sum.'
python遍历数组冒泡排序_在Python中使用while循环的冒泡排序
weixin_39929566的博客
11-29 568
我已经为家庭作业设置了一个冒泡排序，我一直在尝试使用while循环。我知道用for循环是可能的，但我并不真正理解它们，我想写一些我能理解的东西。在unsorted = Truenumbers = []unsortchecker = 0start = 0maxlist = int(input("How many numbers should be sorted?"))if len(numbers) ...
Java软件开发实战 Java基础与案例开发详解 9-8 练习题 共4页.pdf
07-07
- do-while循环：至少执行一次后再判断。 #### 3-8 跳转语句 - **break**：跳出当前循环。 - **continue**：跳过本次循环的剩余部分，继续下一次循环。 #### 3-9 MyEclipse工具介绍 - **MyEclipse**：基于Eclipse...
Java-interview-programs:解决了Java面试问题
04-12
2. **控制结构**：包括条件语句（if-else，switch-case）和循环（for，while，do-while）。面试官可能通过编写简单的逻辑来测试你的理解和应用能力。 3. **异常处理**：Java中的try-catch-finally语句块用于处理...
java代码-笔试第二题
07-15
1. **基本语法**：变量声明、赋值、条件语句（if-else）、循环（for, while）、数组操作等。 2. **类与对象**：封装、继承、多态，以及构造函数、访问修饰符的理解。 3. **数据结构**：数组、链表、栈、队列、集合...
Java软件开发实战 Java基础与案例开发详解 15-4 练习题 共5页.pdf
最新发布
07-07
- Java中的多态主要通过方法重载和方法覆盖实现。 ### 7. 面向对象的设计与分析 - **设计模式**： - 设计模式是一种在特定上下文中解决问题的最佳实践。 - 常见的设计模式有工厂模式、单例模式、观察者模式等。...
java-basic-knowledge:Java基础知识，基础算法，其他基础相关内容练习
03-21
2. **控制结构**：包括条件语句（if-else、switch-case）、循环（for、while、do-while）以及跳转语句（break、continue），这些用于实现程序的逻辑流程。 3. **类与对象**：Java是面向对象的语言，学习如何定义类...
冒泡排序while
10-16
使用while循环的冒泡排序，陆续会上传双for循环，以及递归方式的冒泡
网易极客战记官网codecombat|干货：数组合并小技巧 与 如何只用While实现冒泡排序
codecombat163的博客
01-08 234
今天将为大家讲解一下Python中如何把两个list合并，并按从小到大顺序排列。 本题分为两个部分：一个是list的合并，一个是用while loop循环将合并后的数组从小到大进行排序——排序问题。 1. List的合并： list的合并其实非常简单，只需要用“+”号对两个数组进行相加，另一个数组就会被加到前一个数组的末端，如代码： list1 = [7,3,10,12,5,1,2] list2...
冒泡排序—while语句实现
LKB的专栏
06-14 3471
//#include #include #include void main() { int a[] = { 2, 5, 3, 6, 8, 7, 1, 11, 10 }; int n = sizeof(a) / sizeof(int); //求数组的长度 printf("排序前："); int i=0; while (i!=n) { printf(" %d",a[i]); /
使用while、do-while、for打印九九乘法表、三角形和冒泡排序
编码青年的专栏
03-29 7300
//用while打印九九乘法表： int i = 1; while (i <= 9) { int j = 1; while (j <= i) { float result = j * i;
01Java基础语法-16. while循环结构
学无止境
08-01 1315
01Java基础语法-16. while循环结构*
冒泡排序-while实现
weixin_30455661的博客
12-10 716
/**功能：冒泡排序，从小到大输出。*/public class Demo { 　　public static void main(String[] args) 　　{ 　　　　int[] b=new int[9]; 　　　　b=new int[]{8,3,6,1,9,5,4,2,7}; 　　　　bubble_sort(b,9); 　　　　for(int i=0;i<9;i++) ...
one-05 while 、do-while循环 数组
游百川的博客
09-07 461
数组 数组的创建方式 //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数组动态赋值 /**通过数组的下标来操作数组中的每一个元素,注意数组
C语言求一个正整数位数、正序输出、倒序输出的简单通用方法(do-while语句)
butterzhao的博客
03-28 4111
在谭浩强的《C程序设计》中习题4.8要求：给一个不多于5位的正整数的上面三个问题，发现很多只能适用于题目条件下，而不能用于计算机可识别的全部正整数，故将我的经验分享给大家。更加方便的方法欢迎与我探讨。 #include<stdio.h> #include<math.h> int main() { unsigned long int a;//本类型取值范围: 0~42...
Java学习全攻略：从基础到高级
此外，它涵盖了流程控制语句（如if-else、switch、for、while等），数组的理解与操作，字符串处理，以及基础的排序算法如插入排序和冒泡排序，以及二分法查找。这部分还涉及到了Java API的使用，二进制基础知识，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值