day05循环结构（下）数组（上）

回顾:
1.分支结构:
3)if…else if结构:多条路
4)switch…case结构:多条路
优点:效率高、结构清晰
缺点:只能对整数来判断相等
break:跳出switch
2.循环:反复执行一段相同或相似的代码
3.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在整个循环过程中所反复改变的那个数
4.循环结构:
1)while:先判断后执行，有可能一次不执行
2)do…while:先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while

正课:
1.循环结构:
3)for结构:应用率最高，与次数相关的循环
2.三种循环结构如何选择?
1)先看循环是否与次数相关:
1.1)若相关--------------直接上for
1.2)若不相关，再判断要素1与要素3是否相同:
1.2.1)若相同--------直接上do…while
1.2.2)若不同--------直接上while
3.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
4.嵌套循环:
1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行规则: 外层循环走一次，内层循环走所有次
3)建议:嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
若业务必须通过三层以上的循环才能解决，说明设计有问题
4)break只能跳出当前层循环
5.数组:
1)是一种数据类型(引用类型)
2)相同数据类型元素的集合
3)数组的定义:
int[] arr = new int[10];
4)数组的初始化:----初始化的是数组中的元素
int[] arr = new int[3]; //0,0,0
int[] arr = {2,5,8}; //2,5,8
int[] arr = new int[]{2,5,8}; //2,5,8
int[] arr;
arr = {2,5,8}; //编译错误，此方式只能声明同时初始化
arr = new int[]{2,5,8}; //正确
5)数组的访问:----访问的是数组中的元素
5.1)通过(数组名.length)来获取数组的长度(元素的个数)
int[] arr = new int[10];
System.out.println(arr.length); //10
5.2)通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3];
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
arr[3] = 400; //运行时会发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出arr中最后一个元素的值
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = 100; //给每个元素都赋值为100
System.out.println(arr[i]); //输出每个元素的值
}

int[] arr = new int[10];
for(int i=0;i<10;i++){ //遍历arr数组
arr[i] = 100; //给每个元素都赋值为100
System.out.println(arr[i]); //输出每个元素的值
}

arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;
arr[5] = 100;
arr[6] = 100;
arr[7] = 100;
arr[8] = 100;
arr[9] = 100;

int[] arr = new int[10];
for(int i=0;i<10;i++){ //遍历arr数组
//arr[i]-------代表arr中的每一个元素
}

编译错误------------只检查语法

int[] arr = new int[3]; //0,0,0
//给第2个元素赋值为100
arr[1] = 100;

arr[0]---------代表arr中的第1个元素(int类型)
arr[1]---------代表arr中的第2个元素(int类型)
arr[2]---------代表arr中的第3个元素(int类型)

int a = 0;
int b = 0;
int c = 0;
//给第2个数赋值为100
b = 100;

//声明整型数组a，包含5个元素，每个元素都是int类型，默认值为0
int[] a = new int[5]; //0,0,0,0,0

//声明整型数组a，包含5个元素，每个元素都是int类型，默认值为0
int[] a = new int[5];

//声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
double[] d = new double[10];

//声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false
boolean[] b = new boolean[26];

byte,short,int,long,char----------0
float,double----------------------0.0
boolean---------------------------false

int和int[]是两种完全不同的数据类型

int[] a; //声明整型数组变量a
double[] d; //声明浮点型数组变量d
boolean[] b; //声明布尔型数组变量b

1.循环结构:
3)for结构:应用率最高，与次数相关的循环

• 1)语法:

  • //序号    1    2     3
    

  •   for(要素1;要素2;要素3){
    

  •     语句块/循环体   //4
    

  •   }
    

  • 2)执行过程:

  •   12432432432432432432
    

  */
  }
  }
  例1：
  //注意:for中声明的循环变量的作用域—仅在当前for中
  当作用域重叠时，变量不能同名
  for(int num=1;num<=9;num++) {
  System.out.println(num+"9="+num9);
  }
  for(int num=1;num<=9;num+=2) {
  System.out.println(num+"9="+num9);
  }
  for(int num=9;num>=1;num–) {
  System.out.println(num+"9="+num9);
  }
  for(int times=10;times<20;times++) {
  System.out.println(“行动是成功的阶梯”);
  }
  /
  /
  • 执行过程:
  • times=0 true 输出
  • times=1 true 输出
  • times=2 true 输出
  • times=3 true 输出
  • …times=4/5/6/7/8
  • times=9 true 输出
  • times=10 false for循环结束
    */

例2：

	/*要素一外置
	int num=1;
	for(;num<=9;num++) {
		System.out.println(num+"*9="+num*9);
	}
	*/
	要素三内置
	/*
	for(int num=1;num<=9;) {
		System.out.println(num+"*9="+num*9);
		num++;
	}
	*/
	要素二必须放小括号里边且两个分号不能少
	/*
	for(;;) { //没有条件的循环就是个死循环
		System.out.println("我要学习...");
	}
	*/
	
	/*
	for(int i=1,j=6;i<=5;i+=2,j-=2) {
	
	}
	*/
	/*
	 * i=1,j=6
	 * i=3,j=4
	 * i=5,j=2
	 * i=7,j=0
	 * 

for到whlie
*/
// 1 2 3
for(int times=0 ; times<10 ; times++){
System.out.println(“行动是成功的阶梯”); //4
}

12432432432432432432432
12432432432432432432432

int times=0; //1
while(times<10) { //2
System.out.println(“行动是成功的阶梯”); //4
times++; //3
}

跳出和进入下一循环

	/*
	for(int num=1;num<=9;num++) {
		if(num==5) { //在某种特定条件下，提前跳出循环
			break;
		}
		System.out.println(num+"*9="+num*9);
	}
	*/
		//输出9的乘法表，跳过取余3得0的
	for(int num=1;num<=9;num++) {
		if(num%3==0) {
			continue; //跳过循环体中剩余语句而进入下一次循环(直接去到num++)
		}
		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
	 */
	 continue比较鸡肋，用其他方法代替

	//输出9的乘法表，只要取余3不得0的
	for(int num=1;num<=9;num++) {
		if(num%3!=0) {
			System.out.println(num+"*9="+num*9);
		}
	}
	两者的比喻为苹果
	共9个苹果，其中3/6/9号的为坏苹果

if(num%3==0) {-------取苹果的时候，看到坏苹果没拿，给它跳过去了
continue;
}

if(num%3!=0) {-------取苹果的时候，只拿没坏的苹果
System.out.println(num+“9=”+num9);
}
for的嵌套
6000000=（i）100*（j）200*（k）300

for(int i=1;i<=100;i++){
for(int j=1;j<=200;j++){
for(int k=1;k<=300;k++){
if(???){
break; //跳出k层循环（当前层）
}
System.out.println(“aaa”);
}
}
}

i=1
j=1 k走30次
j=2 k走30次
…
j=20 k走30次

i=1 j走20次
i=2 j走20次
…
i=10 j走20次

例：九九乘法表
\t:水平制表位，固定占8位
for(int num=1;num<=9;num++) { //控制行
for(int i=1;i<=num;i++) { //控制列
System.out.print(i+""+num+"="+inum+"\t");
}
System.out.println(); //换行
}
/*
* num=3
* i=1 13=3
* i=2 23=6
* i=3 33=9
* i=4
* 换行
* num=2
* i=1 12=2
* i=2 22=4
* i=3
* 换行
* num=1
* i=1 11=1
* i=2
* 换行
*/

例：
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次
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(“算吧!”);
int answer = scan.nextInt(); //2.答题
if(answer==-1) { //3.判题
break;
}
if(answer==result) {
score += 10; //答对1题加10分
System.out.println(“答对了”);
}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);

0到99
Math.random()---------------0.0到0.99999999999999…
*100------------------------0.0到99.9999999999999…
(int)-----------------------0到99

(1)25+36=?
算吧!
61
答对了

(2)59+67=?
算吧!
111
答错了
(3)25+36=?
算吧!
61
答对了
(4)59+67=?
算吧!
111
答错了
(5)25+36=?
算吧!
61
答对了
(6)59+67=?
算吧!
111
答错了
(7)25+36=?
算吧!
61
答对了
(8)59+67=?
算吧!
111
答错了
(9)25+36=?
算吧!
61
答对了
(10)59+67=?
算吧!
111
答错了
总分为:50

//1)数组的定义:
//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
int[] arr = new int[10];

//2)数组的初始化:
int[] arr1 = new int[3]; //0,0,0
int[] arr2 = {4,6,8}; //4,6,8
int[] arr3 = new int[] {4,6,8}; //4,6,8
int[] arr4;
//arr4 = {4,6,8}; //编译错误，此方式只能声明同时初始化
arr4 = new int[] {4,6,8}; //正确
*/

//3)数组的访问
int[] arr = new int[3];
System.out.println(arr.length); //3
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; // 2 200
arr[2] = 300; // 3 300
//arr[3] = 400; //运行时----会发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
*/
//4)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++) { //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
System.out.println(arr[i]); //输出每个元素的值
}