第二章 JAVA基本语法2

循环结构

for循环

public class Test {
	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			System.out.println ("hello world");
		}//初始化变量i，判断i是否小于等于5，满足则执行代码块，然后在执行更改表达式（i++）
		
	}
}

for语句例题：1. 编写程序FooBizBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。

public class Test {
	public static void main(String[] args) {
	
		for(int i=1;i<=150;i++) {
			String str ="";
			str+=i;
			if (i % 3 == 0) {
				str+=" foo";
			}
			if(i % 5 == 0) {
				str+=" biz";
			}
			if(i % 7 == 0){
				str+=" baz";
			}
			System.out.println(str);
			
		}
	}
}     //不能用if-else，因为要连续判断

2. 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。

public class Test {
	public static void main(String[] args) {
		for(int i=100;i<=999;i++) {
			//例145取出每一位数，百位145/100=1，十位数（145-1*100）/10,个位数145-1*100-4*10
			int m =i / 100;                //取得百位数
			int n =(i -m * 100) / 10;      //取得十位数
			int k =i - m * 100 - n * 10;   //取得个位数
			int res =m*m*m + n*n*n +k*k*k;
					
			if(i==res) {
				System.out.println(i);
			}
			
		}					
	}
}

while循环语句

public class Test {
	public static void main(String[] args) {
		int i =1;
		while(i<=100) { //如果括号是true则执行代码块
			System.out.println(i);
			i++;	
		}
	}
}

**循环语句练习题：**求1到100之间所有偶数的和。用for和while语句分别完成。

public class Test {
	public static void main(String[] args) {
		int res =0;
		for (int i=1;i<=100;i++) {
			if(i%2 ==0) {
			//	System.out.println(i);
				res+=i;
			}
		
			}
		System.out.println(res);//要在for循环外输出结果，因为循环完毕才有1-100之间所有的偶数之和
	}
}

public class Test {
	public static void main(String[] args) {
		int res =0;
		int i=1;
		while(i<=100) {
			if(i%2==0) {
				res+=i;
				
			}
			i++;
			
		}
		System.out.println(res);
	}
}

for的无限循环：for( ; ; ) { }
while的无限循环：while( ture ){ }

嵌套循环（尽量保证外层循环的循环次数小于内层循环）
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次

例题

1. 九九乘法表

public class Test {
	public static void main(String[] args) {
		//1*1=1
		//1*2=2 2*2=4
		//1*3=3 2*3=6 3*3=9
		for(int i=1;i<=9;i++) {
			for(int j=1;j<=i;j++) {
				System.out.print(i + "*"+j + "=" + (i*j)+" ");//不换行
				
			}
			System.out.println();//换行
			
		}
		
	}
}

2. 输出1-100所有的质数。

//7,循环1到7，然后分别取模，看整除的次数，如果次数等于2，那就是质数
//4，1 2 4整除三次不是质数
public class Test {
	public static void main(String[] args) {
		for (int i =1;i<=100;i++) {
			int k =0;
			for(int j=1;j<=i;j++) {//循环1-i，分别取模
				if(i%j==0) {
					k++; 
				}
			}
			if(k==2){//如果循环次数为2就是质数
				System.out.println(i);
				
			}
		}
		
	}
}

特殊流程控制语句
break:终止当前所在的循环

continue:用于跳过某个循环语句块的一次执行

public class Test {
	public static void main(String[] args) {
		for(int i =0; i<=9;i++) {
			if(i%2==0) {
				continue;//当是偶数的时候直接跳过不执行
			}
			System.out.println(i);
			
		}
		
	}
}                      输出结果是1 3 5 7 9 

return:并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束

public class Test {
	public static void main(String[] args) {
		for(int i =0; i<=2;i++) {
			for(int j =0;j<2;j++) {
				if (j==1) {
				//	return;   没有输出结果
					break;     输出结果0 1 2
				}
			}
			System.out.println(i);
		}
			
			
		}
		
	}

数组
一维数组的声明方式看下图

public class Test {
	public static void main(String[] args) {
		String[] strs=new String[] {"a","b","c"};
		System.out.println(strs[0]);
		System.out.println("strs数组的长度是"+strs.length );
			
		}
		
	}  //输出结果是： a
       //            strs数组的长度是3

public class Test {
	public static void main(String[] args) {
		int[][] ii=new int[][] {
			{1,2},
			{4,3}
		};
		int[][] ii0=new int[2][3];//第一维长度是2，第二维长度是3
		int[][] ii1=new int[2][];//只定义第一维，第二维不定义就是空的数组
		System.out.println(ii[1][0]);//取值4
			int[] x,y[];//特殊写法，x是一维数组，y是二维数组
		}
		
	}

练习：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};获取所有元素和。

public class Test {
	public static void main(String[] args) {
		//int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};获取所有元素和。
		int[][] arr = new int[][]{
			{3,8,2},
			{2,7},
			{9,0,1,6}
			};
			int len =arr.length ;//一维数组的长度
			int res =0;
			for (int i=0;i<len;i++) {
				int[] arr0=arr[i];//arr[i]就是{3，8，2}，{2，7}，{9，0，1，6}
				
				int llen=arr0.length ;//二维数组的长度
				for(int j=0;j<llen;j++) {
					System.out.println(arr0[j]);
					res+=arr0[j]; 
				}
				
			}
		System.out.println(res);
		
		}
		
	}

数组中常见的算法

1.求数组元素的最大值、最小值、总和、平均数

public class Test {
	public static void main(String[] args) {
		int[] arr=new int[] {4,2,7,1,3,5};
		//最大值
		int max=arr[0];//假设最大的值是数组中的第一位数
		
		for(int i=0; i<arr.length ;i++) {
			if (max<arr[i]) { //如果算最小值，max>arr[i]
				max=arr[i];
				
				
			}
			
		}
		System.out.println(max);
		}
		
	}

public class Test {
	public static void main(String[] args) {
		int[] arr=new int[] {4,2,7,1,3,5};
		//总和 平均数
		int res =0;
		for(int i=0;i<arr.length ;i++) {
			res+=arr[i];
		}	
		System.out.println("平均数是"+(res/arr.length ));
		System.out.println(res);
		}
		
	}

2.数组的复制、反转

public class Test {
	public static void main(String[] args) {
		int[] arr=new int[] {4,2,7,1,3,5};
		//复制
		int[] copy =new int[arr.length ];//声明一个与arr长度一致的数组
		for(int i=0;i<arr.length ;i++) {
			copy[i]=arr[i];//遍历arr，把arr的每一个元素拿出来给copy的每一个元素赋值
		
			
			
			//反转 （考虑声明一个数组temp，长度一致，倒着循环arr，正着给temp赋值）(一个数组的最后一位应该是arr[长度-1])
			int[] temp=new int[arr.length ];
			int j=0; //temp数组的下标
			for(int k=arr.length-1;k>=0; k--){
				System.out.println(arr[k]);
				temp[j]=arr[k]; //第一次循环，j=0，k=5
				j++;
			}
			arr=temp;
			for(int s =0;s<arr.length ;s++) {
				System.out.println(arr[s]);
			}
			 
		}
		
		}
		
	}

3.数组元素的排序
交换排序中的冒泡排序：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。

public class Test {
	public static void main(String[] args) {
		int temp =0;
		int[] arr=new int[] {4,2,7,1,3,5};
		//冒泡排序 
		//正序，从小到大，相邻比较，大的放后面
		//4，7，3，1
		//4，3，1，7第一轮得到一个最大数字放在最后面，比较了3次
		//3，1，4，7第二轮得到最大放倒数第二位，比较了2次
		//1，3，4，7第三轮得到放倒数第三位，比较了1次
		for(int i = 0;i<arr.length -1;i++){//外层循环是轮次，6个数需要排5轮
			for(int j =0;j<arr.length -1-i;j++) {// 每一轮次的对比排序，每次是3，2，1
				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]);
		}
		
		}
		
	}