Java大数据学习第五天---while do-while循环 数组 方法重载 冒泡排序
复习
结构
- 顺序结构
- 分支结构 if
- 循环结构 for
- 选择结构 switch
变量
- 成员变量
- 局部变量
第五天
while循环
-
结构：
while（循环条件）{
循环体；
}
do-while循环
-
结构：
do{
循环体；
}while（循环条件）；
三种循环区别
- for：知道循环次数
- while/do while：当循环次数不确定时
- while：先判断，不符合规则，不执行代码
- do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
- 循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码哦~
数组
-
概念：
数组Array，标志是[ ] ,用于储存多个相同类型数据的集合，想要获取数组中的元素值，可以通过脚标（下标）来获取，数组下标是从0开始的,下标的最大值是数组的长度减1
-
创建数组：
- 静态创建
- 类型[] 数组名={数组的组成元素}
- 类型[] 数组名=new 类型{数组的组成元素}
- 动态创建
- 类型[] 数组名=new 类型[数组长度]
- 静态创建
-
数组创建过程
- 例子：程序创建数组 int[] a = new int[5]; 时发生了什么?
- 在内存中开辟连续的空间,用来存放数据,长度是5
- 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
- 数组完成初始化会分配一个唯一的地址值
- 把唯一的地址值交给引用类型的变量a去保存
-
数组长度：数组的长度用 length属性来表示,数组一旦创建，长度不可改变，数组的长度允许为0
使用时 数组名.length
-
数组特性：
- 数组的长度通过**数组名.length;**来获取
- 数组一旦创建，长度无法改变
- 数组的下标从0开始，最大下标为数组长度-1
- 如果访问到了不存在的下标，会数组下标越界异常
-
数组的工具类Arrays
- toString(数组名)，除了char类型以外，其他类型的数组想要查看数组的具体元素，都得使用这个方法，如果不用，打印是数组的地址值
- sort(数组名)，给数组进行排序
- copyOf(要复制的数组，新数组的长度)
如果新的长度大于原数组的长度–数组的扩容
如果新的长度小于原数组的长度–数组的缩容
如果新的长度等于原数组的长度–普通的复制
注意：不管是什么长度，都不是修改原数组，而是创建新数组
-
数组的遍历
- 如果只是想查看数组中有哪些元素，直接使用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(input100);
/**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;ja[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("哈哈哈我没有参数~~");
}
}