Java语法3(程序流程控制与数组)

程序流程控制

程序从上到下逐行地执行，中间没有任何判断和跳转

顺序结构

Java中定义成员变量时采用合法的前向引用

分支结构

根据条件，选择性地执行某段代码。
有if…else和switch两种分支语句

if-else

if语句三种格式：

//第一种
if(true){
	执行代码块;
}
//例子
int i =1;
if(i==1){
	System.out.println("输入正确！");
}

//第二种
if(true){
	执行代码块;
}else{
	执行代码块
}
//例子
int i = 2
if(i!=2){
	System.out.println("今天不是星期二！");
}else{
	System.out.println("今天是星期二");
}

//第三种
if(条件表达式){
	执行代码块;
}else if{ 
	执行代码块;
}
...
else{	
	执行代码块;
}
//例子
int i = 60
if(i<60&&i>=0){
	System.out.println("未及格");
}else if(i<=80){
	System.out.println("良好");
}else if(i<=100){
	System.out.println("优秀");
}else{
	System.out.println("成绩不合法");
}

if-else可以嵌套使用，也就是if-else里面可以有多个if-else

switch

例子结构：

int i = 80;
switch(i/10){
case 1:
case 2:
case 3:
case 4:
case 5:
	System.out.println("未及格");
	break;
case 6:
case 7:
case 8:
	System.out.println("良好");
	break;
case 9：
case 10：
	System.out.println("优秀");
	break;
default:
	System.out.println("成绩不合法");
}

switch有关规则

• switch(表达式)中表达式的返回值必须是：byte，short，char，int，枚举，String
• case子句中的值必须是常量，且所有case子句中的值是不同的
• default子句可要可不要，当没有匹配的case时，执行default
• break语句用来在执行前完成一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾

switch和if语句的对比

• 如果判断的具体数值不多，而且符合byte，short，int，char这四种类型。虽然两个语句都可以使用，switch效率更高
• 其他情况：对区间判断，对结果boolean类型判断，使用if，if的使用范围更广

循环结构

根据循环条件，重复性的执行某段代码。
有while，do…while,for三种循环语句
注： JDK1.5之后提供了foreach循环，方便的遍历集合、数组元素
循环语句四个部分

• 初始化部分
• 循环条件部分
• 循环体部分
• 迭代部分

for循环

语法格式

/*语法格式
for(初始化表达式;布尔值测试表达式;更改表达式){
	执行语句或语句块;
}*/

//例子
for(int i=0; i<5; i++){
	system.out.println("HelloWorld!!!");
}//输出5次HelloWord!!!
//1.初始化变量i,判断i<5,如果是，执行执行代码块，执行更改表达式i++，给i重新赋值，值变为1。
//2.判断变量i<5，当前是i=1,执行代码块，更新更改表达式，值变为2。
//直到i=5判断i<5为false跳出循环

//for的无限循环
for(;;);

例题

//输出所有水仙花数，水仙花数为一个三围是，各个位数上的数字立方等于其本身。如：153=1*1*1+5*5*5+3*3*3
for(int i=100; i<=999; i++){
	int a = i / 100;//取出i的百位数
	int b = i / 10 % 10;//取出i的十位数
	int c = i % 10;//取出i的个位数
	if(i == a*a*a + b*b*b + c*c*c){
		System.out.println(i);	
	}
}

while循环

语法格式

/*语法格式
[初始化语句]
while(布尔值测试表达式){
	执行语句或语句块;
	[更改语句;]
}*/

//例子
int i=1
while(i<=100){
		//获取变量i<=100的结果为true还是false，true执行代码块语句，false跳出循环
	System.out.println(i);
	i++;//不断的改变i的值，让其不为死循环
}

//while的无限循环
while(true){
}

do…while循环

语法格式

/*语法格式
[初始化语句]
while(布尔值测试表达式){
	执行语句或语句块;
	[更改语句;]
}*/
//例子
int i = 1;
do{
	System.out.println(i);
	i++;
}while(i<=100);//do-while循环至少执行一遍

嵌套循环

• 嵌套循环就是循环里面套循环
• 当内存循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
  注意：
  在写嵌套循环时，尽量保证外层循环的循环次数小于内层循环的循环次数

例题

/*九九乘法表*/
for(int i=1; i<=9; i++){
	for(int j=1; j<=i; j++){
		System.out.print(i + "*" + j + "=" + i*j + " ");
	}
	System.out.println();//换行
}

/*1-100的所有质数（质数是大于1的自然数且只能被1和本身整除）*/
for(int i=1; i<=100; i++){
	int k = 0;
	for(int j=1; j<=i; j++){
		if(i % j == 0) {
			k++;
		}
	}
	if(k == 2) {//当k=2时正好只被本身和1整除
		System.out.println(i);
	}
}

特殊流程控制语句

• break语句
  终止某个语句块的执行。
  用在switch语句里，主要用在循环里面终止循环，终止当前所在的循环

• continue语句
  continue语句用于跳过某个循环语句块的一次执行。continue语句多出现在多层嵌套循环语句体重，可以通过标签指明要跳过的是那一层循环

• return：
  并非专门用于结束循环，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束
  与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

例子

for(int i=0; i<9; i++){
	if(i % 2 == 0){
		break;
	}
}//当i能被2整除时就跳出循环，循环结束后i=2
for(int j=0; j<9; j++){
	if(j % 2 == 0){
		continue;
	}
}//当j能被2整除时就跳过此次循环，循环结束后j=9
for(int k=0; k<9; k++){
	if(k % 2 == 0){
		return;
	}
}//当j能被2整除时就终止此方法了

注意：

• break只能用于switch语句和循环语句中
• continue只能用于循环语句中
• 两者功能类似，但continue是终止本次循环，break是终止本层循环
• break、continue之后不能有其他的语句，因为程序永远不会执行其后语句。

数组

一维数组

1.数组的声明：
type var[] 或 type[] var;

int a[];
double[] b;
Mydate[] c;//对象数组

2.数组的初始化：

• 动态初始化
  数组声明且为数组元素分配空间 与 赋值的操作 分开进行

  int[] arr = new int[3];//声明时要定义数组容量
  arr[0] = 3;
  arr[1] = 6;
  arr[2] = 9;
  

• 静态初始化
  在定义数组的同时就为数组元素分配空间并赋值

  int a[] = new int[]={3,6,9};//声明了一个存放3个数的数组
  int[] a = {3,6,9}
  

3.数组元素引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素
• 数组元素的引用方式：数组名[数组元素下标]
  • 数组元素下标可以是整形常量或整形表达式。如a[3],b[i],c[2*i]
  • 数组元素下标从0开始；长度为n的数组合法下标取值范围：0–>n-1；如int a[] = new int[3];可引用的数组元素为a[0],a[1],a[2]
• 每个数组都有一个属性length指明它的长度。

  • a.length指明数组a的长度(元素个数)
    数组一旦初始化，其长度时不可变的

    String strs = new String[]={"a","b","c"};
    System.out.println(strs.length);//3
    

4.数组元素的默认初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化

int[] a = new int[2];//使用动态初始化的时候，数组的元素会有默认值是0，对象的默认类型是null
system.out.println(a[0]);//0

多维数组

二维数组

二维数组[][]:数组中的数组
二维数组可以看做矩阵，[a][b] a代表行数，b代表列数

声明

int[][] y;
int[] y[];
int y[][];

初始化格式：

1. 格式1(动态初始化）

   int[][] arr = new int[3][2];
   /*二维数组名称为arr，其中有3个一维数组，每一个一维数组中有2个元素
   一维数组名称分别为arr[0],arr[1],arr[2]*/
   arr[0][1]=78;//给第一个一维数组1脚标位赋值为78
   

2. 格式2(动态初始化)

   int[][] arr = new int[3][];//非法：int[][] arr = new int[][3];
   //二维数组中有三个一维数组，每个一维数组都是默认初始化值null
   //可以对这三个一维数组分别进行初始化
   arr[0] = new int[3];
   arr[1] = new int[1];
   arr[2] = new int[2];
   

3. 格式3(静态初始化)

   int[][] arr = new int[][]{{3,8,2},{2,2},{9,2,4,6}};
   //二维出租有三个一维数组
   /*每一个一维数组中具体元素都已初始化。
   arr[0]={3,8，2};
   arr[1]={2,2};
   arr[2]={9,2,4,6};
   注意，Java中不必都是规则矩阵形式
   */
   //特殊写法,x是一维数组，y是二维数组
   int[] x,y[];
   
   

例题

/*获取arr中所有元素的和。使用for的嵌套循环*/
int[][] arr = new int[][]{{3,8,2},{2,2},{9,2,4,6}};
int res = 0;
for(int i=0; i<arr.length; i++){
	for(int j=0; j<arr[i].length; j++){
		res += arr[i][j];
	}
}
System.out.println(res);//38

数组中常见的算法

int arr[] = new int[]{2,4,8,5,1,3,5,4,8,9};

/*1.求数组元素的最大值、最小值、总和、平均数*/
//最大值
int max = arr[0];
for(int i=0; i<arr.length; i++){
	if(max < arr[i]){
		max = arr[i];//max一直为较大的那个数，全部比较完之后max即为最大值
	}
}
System.out.println("max=" + max);//9

//最小值
int min = arr[0];
for(int i=0; i<arr.length; i++){
	if(min > arr[i]){
		min = arr[i];//min一直为较小的那个数，全部比较完之后min即为最小值
	}
}
System.out.println("min=" + min);//1

//总和，平均数
int sum =0,avg = 0;
for(int i=0; i<arr.length; i++){
	sum += arr[i];
}
System.out.println("sum=" + sum);//49
System.out.println("avg=" + sum*1.0/arr.length);//4.9，若不*1.0结果为4，由于两个数为整形/为整除
		
/*2.数组的复制、反转*/
//复制不是复制
int[] copy = new int[arr.length];
for(int i=0; i<arr.length; i++){
	copy[i] = arr[i];//遍历arr，把arr中的元素按顺序给copy的每个个元素赋值
}

//反转
int[] temp = new int[arr.length];
for(int i=arr.length-1, k=0; i>=0; i--, k++){
	temp[k] = arr[i];//第一次循环，k=0，i=9，相当于temp[0] = arr[9]
}

/*3.数组元素的排序*/
//冒泡排序
int temp;
for(int i=0; i<arr.length; i++){
	for(int j=0;j<arr.length-i-1;j++){
		if(arr[j]>arr[j+1]){
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}
}
for(int i=0; i<arr.length; i++){
	System.out.println(arr[i]);
}

数组操作常见问题

• 数组下标越界异常(ArrayIndexOutOfBoundsException)

int arr[] = new int[3];
System.out.println(arr[3]);

运行结果：

• 空指针异常(NullPointerException)

int arr[] = null;
System.out.println(arr[0]);

运行结果：