第五天：
3) for结构：应用率最高，固定次数循环
3.1）语法：
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体 ----------反复执行的代码 4
}
3.2）执行过程：
1243 243 243 243 243 243...2
int times=0; //1
while(times<10){ //2
System.out.println(“行动是成功的阶梯”); //4
times++； //3
}
执行过程：1243 243 243 243 243 2
//1 //2 //3
for(int times=0; times<10; times++){
System.out.println(“行动是成功的阶梯”); //4
}
执行过程：1243 243 243 243 243 2
执行过程一样，但是for结构更简洁清晰
-----------------------------------------------
for(int times=0;times<6;times++){
System.out.println("行动是成功的阶梯");
}
System.out.println("继续...");
执行过程：
times=0 true 输出
times=1 true 输出
times=2 true 输出
times=3 true 输出
times=4 true 输出
times=5 true 输出
times=6 false for循环结束
输出继续...
--------------------------------------------------
//for中循环变量num的作用域----仅在当前的for中好使
for(int num=1;num<=9;num++){
System.out.println(num+"*9="+num*9);
}
for(int num=1;num<=9;num+=2){
System.out.println(num+"*9="+num*9);
}
for(int num=9;num>=1;num--){
System.out.println(num+"*9="+num*9);
}
------------------------------------------------
for(int num=1;num<=9;num++){
if(num==5){ //在某种特定条件下，提前结束循环
break;
}
System.out.println(num+"*9="+num*9);
}
执行过程：
num=1 1*9=9
num=2 2*9=18
num=3 3*9=27
num=4 4*9=36
num=5 break 跳出循环，循环结束
--------------------------------------------------
//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
if(num%3==0){
continue; //跳过循环体中剩余语句而进入下一次循环
}
System.out.println(num+"*9="+num*9);
}
执行过程：
num=1 1*9=9
num=2 2*9=18
num=3
num=4 4*9=36
num=5 5*9=45
num=6
num=7 7*9=63
num=8 8*9=72
num=9
num=10
或：
//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
if(num%3!=0){
System.out.println(num+"*9="+num*9);
}
}
---------------------------------------------------
案例：
package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int score = 0; //总分
for(int i=1;i<=10;i++){ //10次 （1）23+56=？ 算吧！ 79 答对了
int a = (int)(Math.random()*100); //加数a
int b = (int)(Math.random()*100); //加数b
int result = a+b; //存和
System.out.println("("+i+")"+a+"+"+b+"=?"); //1.出题
System.out.println("算吧！---- 输入-1时提前结束循环");
int answer = scan.nextInt(); //2.答题
if(answer==-1) {
break;
}
if(answer==result){ //3.判题
System.out.println("答对了");
score +=10; //答对1题加10分 score=score+10;
}else{
System.out.println("答错了");
}
}
System.out.println("总分为："+score);
}
}
需求：
int score = 0; //总分
for(int i=1;i<=10;i++){ //10次
//1)出题 2)答题 3)判题
}
System.out.println("总分为:"+score);
(1)25+65=?
算吧!
90
答对了
(2)67+35=?
算吧!
100
答错了
(3)25+65=?
算吧!
90
答对了
(4)67+35=?
算吧!
100
答错了
(5)25+65=?
算吧!
90
答对了
(6)67+35=?
算吧!
100
答错了
(7)25+65=?
算吧!
90
答对了
(8)67+35=?
算吧!
100
答错了
(9)25+65=?
算吧!
90
答对了
(10)67+35=?
算吧!
100
答错了
总分为:50
2、关键字：
break：在某种条件下提前结束循环 跳出循环 （可用在switch…case或循环里）
continue：跳过循环体中剩余语句而进入下一次循环（只能用于循环中）
3、三种循环结构的更佳使用情况：
1)while：“当…”循环
2)do…while：“直到…”循环
要素1与要素3相同时首选do…while
要素1与要素3不同时用while
3)for：固定次数循环，应用率最高
循环的选择：
1. 先看固定次数吗 ?
1)固定次数---------------for
2)不固定次数，再看要素1与要素3相同吗 ?
2.1)相同则------------- do...while
2.2)不同则------------- while
4、嵌套循环：
九九乘法表：
1）循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2) 执行规则：外层循环走一次，内层循环走所有次
3) 建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层，
若需求必须通过三层以上的循环才能解决，说明设计有问题
4) break只能跳出一层循环（只能跳出它当前的循环）
package day05;
//九九乘法表
public class MultiTable {
public static void main(String[] args) {
for(int num=1;num<=9;num++){ //外层 控制行
for(int i=1;i<=num;i++){ //内层 控制列
System.out.print(i+"*"+num+"="+i*num+"\t");
}
System.out.println(); //换行
}
执行过程：
num=1 true
i=1 true 1*1=1
i=2 false 里层的for循环结束
换行
num=2 true
i=1 true 1*2=2
i=2 true 2*2=4
i=3 false 里层的for循环结束
换行
num=3 true
i=1 true 1*3=3
i=2 true 2*3=6
i=3 true 3*3=9
i=4 false 里层的for循环结束
换行
num=4
...
}
}
6000次
for(int i=1;i<=10;i++){
for(int j=1;j<=20;j++){
for(int k=1;k<=30;k++){
System.ou.println(“aaa”);
}
}
}
过程：
i=1
j=1
k30次
j=2
k30次
、、、
j=20
k30次 i=1时，里面已经走了600次了
程序=算法+数据结构
1）算法：解决问题的流程/步骤（顺序、分支、循环）
2）数据结构：将数据按照某种特定的结构来保存
数怎么存
设计良好的/合理的数据结构会导致好的算法
总结：先设计数据机构再设计算法
第六天：
数组： 是最基本的一种数据结构 int和int[ ]是两种完全不同的数据类型
1）是一种数据类型（引用类型）
2）相同数据类型的元素的集合
3）数组的定义：
//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
int [ ] arr = new int[10];
注：
arr数组固定长度为10 （数组的长度一旦定义好，就不能更改了）
在内存中会开辟一块连续的存储空间给数组
（1个int占4个字节，在内存中会分配 连续40个字节来存储arr数组）
4）数组的初始化：---------- 初始化数组中的数据
int [ ] arr = new int[4]; //0,0,0,0
int [ ] arr = {3,5,7,9}; //3,5,7,9
int [ ] arr = new int[ ]{3,5,7,9}; //3,5,7,9
int [ ] arr;
arr = {3,5,7,9}; //编译错误，此方式必须 声明同时初始化
arr = new int[ ]{3,5,7,9}; //正确
-----------------------------------------------------------------------------
int a; //声明整型变量a
int [ ] b; //声明整型数组变量b
double [ ] c; boolean [ ] b; char [ ] d;
// 0,0,0,0,0,0,0,0,0,0
int [ ] a = new int[10]; // 声明整型数组a，包含10个元素
// 每个元素都是int类型，默认值为0
double [ ] d = new double[8]; //声明浮点型数组d，包含8个元素
//每个元素都是double类型，默认值为0.0
boolean [ ] b = new boolean[26]; //声明布尔型数组b，包含26个元素
//每个元素都是boolean型，默认值为false
数组和类属于引用类型，引用类型默认值为null
5）数组的访问： 访问的是数组中的元素
5.1）通过（数组名 .length）可以获取数组的长度（元素的个数）
int [ ] arr = new int[4];
System.out.println(arr.length); //4 arr.length就是arr数组的长度 . 读 的
5.2）通过下标/索引来访问数组中的元素
下标从0开始，最大到（数组的长度-1）
int [ ] arr = new int[3]; //0,0,0
arr[0] = 100; // 给第1个元素赋值为100
arr[1] = 200; // 给第2个元素赋值为200
arr[2] = 300; // 给第3个元素赋值为300
arr[3] = 400; // 运行时发生数组下标越界异常
System.out.println(arr[2]);
System.out.println(arr.length); //输出arr数组的长度
System.out.println(arr[0]); //输出第1个元素的值
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
arr[0]---------------代表arr中的第1个元素
arr[1]---------------代表arr中的第2个元素
arr[2]---------------代表arr中的第3个元素
6）数组的遍历/迭代：从头到尾挨个走一遍
int [ ] arr = new int[10]; // arr数组
for(int i=0;i<arr.length;i++){ //遍历arr数组 原来是i<10;
arr[i] = 100; //给每个元素赋值为100 把值写死了
arr[i] = (int)(Math.random()*100); //每个元素为0~99随机生成的数
arr[i] = scan.nextInt(); //每个元素用户输入的值
System.out.println(arr[i]); //输出每个元素的值
}
//写代码时只要用到数组的长度一律写为.length，不把数据写死
//输出这10个元素的值:
int [ ] arr = new int[10]; //正序
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
int [ ] arr = new int[10]; //倒序
for(int i= arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
案例一：
package day06;
//求数组元素的最大值
public class MaxOfArray {
public static void main(String[] args) {
int[] arr = new int[10]; //定义arr数组
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
System.out.println(arr[i]); //输出arr中每个元素的值
}
int max = arr[0]; //假设第1个元素为最大值
for(int i=1;i< arr.length;i++){ //遍历剩余元素
if(arr[i]>max){ //若剩余元素大于max
max = arr[i]; //修改max的值为较大的
}
}
System.out.println("最大值为："+max);
/* 执行过程：
0, 1, 2,3
int[] arr = {23,56,89,4}; // max=23/56/89
*/
}
}
7）数组的复制
7.1）System.arraycopy(a,1,b,0,4); 效率高、灵活性好
第1种方式：
int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a：源数组
//1：源数组的起始下标
//b：目标数组
//0：目标数组的起始下标
//4：要复制的元素个数
System.arraycopy(a,1,b,0,4);
for(int i=0;i<b.length;i++){ //遍历b数组
System.out.println(b[i]); //输出b中每个元素的值
}
案例二：
package day06;
//求数组元素的最大值 , 并将最大值放到数组最后一个元素的下一个位置
import java.util.Arrays;
public class MaxOfArray02 {
public static void main(String[] args) {
int[] arr = new int[10]; //定义arr数组
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
System.out.println(arr[i]); //输出arr中每个元素的值
}
int max = arr[0]; //假设第1个元素为最大值
for(int i=1;i< arr.length;i++){ //遍历剩余元素
if(arr[i]>max){ //若剩余元素大于max
max = arr[i]; //修改max的值为较大的
}
}
System.out.println("最大值为："+max);
arr = Arrays.copyOf(arr,arr.length+1); //扩容
arr[arr.length-1] = max; //将最大值max赋值到arr最后一个元素上
for(int i=0;i<arr.length;i++){ //遍历arr数组
System.out.println(arr[i]); //输出arr中每个元素的值
}
}
}
7.2）int[ ] b = Arrays.copyOf(a, 6);
a = Arrays.copyOf(a, a.length+1); //扩容 效率低、灵活性差，但有优点(扩容)
第2种方式：
int[] a = {10,20,30,40,50};
//a：源数组
//b：目标数组
//6：目标数组的长度(元素个数)
// ---若目标数组长度 > 源数组长度，则末尾补默认值
// ---若目标数组长度 < 源数组长度，则从末尾截取
int[] b = Arrays.copyOf(a,6);
for(int i=0;i<b.length;i++){ //遍历b数组
System.out.println(b[i]); //输出b中每个元素的值
}
第2种方式的优点： 扩容
int[] a = {10,20,30,40,50};
//数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
a = Arrays.copyOf(a,a.length+1); //扩容
for(int i=0;i<a.length;i++){ //遍历a数组
System.out.println(a[i]); //输出a中每个元素的值
}
8）数组的排序 冒泡排序、快速排序、插入排序...
8.1）Arrays.sort(arr); //效率高 升序排列
int[] arr = {45,35,7,89,21,39,14,1};
Arrays.sort(arr); //对arr进行升序排列
for(int i=0;i<arr.length;i++){ //遍历arr数组
System.out.println(arr[i]); //输出arr中每个元素的值
}
System.out.println("倒着输出：");
for(int i=arr.length-1;i>=0;i--){ //遍历arr数组
System.out.println(arr[i]); //输出arr中每个元素的值
}
8.2）冒泡排序：
8.2.1）五个数冒4轮
8.2.2）每一轮都是从第1个元素开始冒
每一次都是和它的下一个元素比
8.2.3）冒出来了就不带它玩了
int[ ] arr = {67,23,4,56}; //升序
for(int i=0;i<arr.length-1;i++){ //控制轮
for(int j=0;j<arr.length-1-i;j++){ //控制次
if(arr[j]>arr[j+1]){ //若前数大于后数则交换，保证前数小于后数---升序
//想降序把这里的>改为<
//若前数小于后数则交换，保证前数大于后数---降序
int t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}
System.out.println(“排序后”);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]); //对arr中每个元素输出
}
执行过程：
i=0
j=0 67和23比，换，23,67,4,56
j=1 67和4比，换，23,4,67,56
j=2 67和56比，换，23,4,56,67------------------67出来了
i=1
j=0 23和4比，换，4,23,56,67
j=1 23和56比，不换
i=2
j=0 4和23比，不换
arr.length-1-I 3-i次
i=0(第1轮) 比3次
i=1(第2轮) 比2次
i=2(第3轮) 比1次
第一轮：
67和23比，换，23,67,4,56
67和4比，换，23,4,67,56
67和56比，换，23,4,56,67------------------67冒出来了
第二轮：
23和4比，换，4,23,56,67
23和56比，不换---------------------------56冒出来了
第三轮：
4和23比，不换----------------------------23冒出来了
方法： （C语言将方法称为函数） 标志就是 小括号()
1、
1）封装一段特定的业务逻辑功能
2）尽可能的独立，一个方法只干一件事
3）可以被反复调用多次
4）可以减少代码重复，有利于代码的维护，有利于团队的协作
2、方法的定义：
五个要素：修饰词、返回值类型、方法名、参数列表、方法体
3、方法的调用：
1）无返回值：方法名(有参传参);
2）有返回值：数据类型 变量 = 方法名(有参传参);
4、return:
1）return 值; //1.1)结束方法的执行 1.2）返回结果给调用方
------------用在有返回值的方法中
2）return; //2.1）结束方法的执行
------------用在无返回值的方法中
sayHello(“zhangsan”,55); //55>50,就不会到输出那句了
//有参无返回值
public static void sayHello(String name,int age) {
if(age>50){
return; //结束方法的执行 类似break;
}
System.out.println("大家好，我叫"+name+",今年"+age+"岁了");
}
方法可以有返回值，也可以没有返回值:
1)无返回值-----返回值类型统一写成void public static void
2)有返回值-----返回值类型写成特定数据类型即可 public static int
方法完成后：
1）若需要用到方法中的某个数据---------------有返回值
2）若不需要用到方法中的某个数据-------------无返回值
Java给的方法：(标志性的小括号)
System.out.println(“hello”); //输出一句话并换行
System.arraycopy(a,1,a1,0,4); //数组的复制
Array.sort(arr); //数组的排序 --------------无返回值
int a = scan.nextInt(); //接收一个整数
double b = scan.nextDouble(); //接收一个小数
double c = Math.random(); //生成随机数
int[] a1 = Arrays.copyOf(a,6); //数组的复制 --------------有返回值
方法可以有参也可以无参
---------有参可以使方法更灵活 ， 无参 数据是写死的
System.out. println(“hello”);
System. arraycopy(a,1,a1,0,4);
Array. sort(arr);
int[] a1 = Arrays. copyOf(a,6); -----------------------有参数
int a = scan. nextInt();
double b = scan. nextDouble();
double c = Math. random(); ---------------------------无参数
调用方法时：(5,6)、(m,n) 实参（实际参数） 5、6、m、n都是具体的数
声明方法时：plus(int num1,int num2) 形参（形式参数） 只是在声明变量,没有实际的值
package day06;
//方法的演示
public class MethodDemo {
public static void main(String[] args) {
say(); //方法的调用
//无参无返回值 的say()方法
public static void say(){
System.out.println("大家好，我叫LCX，今年23岁了");
}
-----------------------------------------------------------
public class MethodDemo {
public static void main(String[] args) {
//sayHi(); //编译错误，有参必须传参
//sayHi(250); //编译错误，参数类型必须匹配
sayHi("zhangsan"); // String name="zhangsan" //---------实参(调用方法时 都是具体的值、数)
sayHello("lisi",30); //String name="lisi" int age=30
//有参无返回值
public static void sayHi(String name){ //-------------- 形参(声明方法时 只是在声明变量,没有实际的值)
System.out.println("大家好，我叫"+name+"，今年23岁了");
}
public static void sayHello(String name,int age){
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}
----------------------------------------------------------
public class MethodDemo {
public static void main(String[] args) {
double a = getNum(); //getNum()的值就是return后的那个数
System.out.println(a); //8.88 ----这里只是模拟对返回值的后续操作
// 输出只是其中之一操作
//无参有返回值
public static double getNum(){
//return; //编译错误，return后必须跟一个值
//return "abc"; //编译错误，返回值类型必须匹配
return 8.88; //1)结束方法的执行 2)返回结果给调用方
}
---------------------------------------------------------------
public class MethodDemo {
public static void main(String[] args) {
int b = plus(5,6);
System.out.println(b); //11 ----模拟对返回值的后续操作
int m=5,n=6;
int c = plus(m,n); //传的是m和n里面的数
System.out.println(c); //11 ----模拟对返回值的后续操作
//有参有返回值
public static int plus(int num1,int num2){
int num = num1+num2;
return num; //返回的是num里面的那个数
//return num1+num2; //返回的是num1+num2的和
-----------------------------------------------------------------
public class MethodDemo {
public static void main(String[] args) {
int[] d = testArray();
for(int i=0;i< d.length;i++){ //--模拟对返回值的后续操作(或可排序或可输出长度...)
System.out.println(d[i]);
}
//无参有返回值
public static int[] testArray(){
int[] arr = {23,5,1,46};
return arr;
}
--------------------------------------------------------------------
方法的嵌套调用：
public class MethodDemo {
public static void main(String[] args) {
a(); //111,333,222,444 方法的嵌套调用
System.out.println(444);
}
public static void a(){
System.out.println(111);
b();
System.out.println(222);
}
public static void b(){
System.out.println(333);
}
1696
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
