2.6-Java语言基础(程序流程控制)

最新推荐文章于 2023-12-06 17:18:13 发布

msirene

最新推荐文章于 2023-12-06 17:18:13 发布

阅读量221

点赞数

分类专栏： Java2014

本文链接：https://blog.csdn.net/msirene/article/details/37818237

版权

Java2014 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

判断结构

选择结构

循环结构

2.6.1 判断结构

if语句
三种格式：
1. if(条件表达式)
{
执行语句；
}
2. if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
3. if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}

if语句特点：
a,每一种格式都是单条语句。
b,第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。
c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;

class IfDemo 
{
	public static void main(String[] args) 
	{
//		System.out.println("Hello World!1");
//		System.out.println("Hello World!2");
//		System.out.println("Hello World!3");
//		System.out.println("Hello World!4");

		/*
		if语句的第一种格式：
		1，
		if(条件表达式)
		{
			执行语句；
		}
		*/

		int x = 1;
		if(x>1)
		{
		
			if(x<2)	
			{
			
				System.out.println("yes");	
				
			}
		}
		System.out.println("over");

	}

class IfDemo2 
{
	public static void main(String[] args) 
	{
		/*
		if语句的第二种格式：

		if(条件表达式)
		{
			执行语句；
		}
		else//否则
		{
			执行语句；
		}

		*/
		int x = 1;
		if(x>1)
		{
			System.out.println("yes");
		}
		else
		{
			System.out.println("no");
		}
		System.out.println("Hello World!");


		int a = 3,b;
		/*
		if(a>1)
			b = 100;
		else
			b = 200;
			*/
		b = a>1?100:200;//三元运算符就是if else 语句简写格式。

//		简写格式什么时候用？
//			当ifelse运算后，有一个具体的结果时，可以简化写成三元运算符。
		System.out.println("b="+b);
	}
}

class  IfDemo3
{
	public static void main(String[] args) 
	{
		{//局部代码块可以定义局部变量的生命周期。
		int a = 3;
		//a 的运算。
		System.out.println(a+4);
		}

		/*
		if语句第三种格式：
		if(条件表达式)
		{
			执行语句；
		}
		else if (条件表达式)
		{
			执行语句；
		}
		……
		else
		{
			执行语句；
		}

		*/
		int x = 3;
		if(x>1)
			System.out.println("a");
		else if(x>2)
			System.out.println("b");
		else if(x>3)
			System.out.println("c");
		else
			System.out.println("d");


		int y = 3;
		if(y>1)
			System.out.println("a1");
		if(y>2)
			System.out.println("b1");
		if(y>3)
			System.out.println("c1");
		else
			System.out.println("d1");


		if(x==1)
		
			if(y==1)
			
				System.out.println("a");
			
			else
				System.out.println("b");
			
		
		else
		
			if(y==1)
			
				System.out.println("c");
			
			else
			
				System.out.println("d");
			
		
//		if(false);

		
		{//局部代码块。
			int m = 89;
			System.out.println("Hello World!..."+m);
		}

		System.out.println("over....."+m);
	}
}

class IfTest 
{
	public static void main(String[] args) 
	{

		/*
		需求：根据用户指定的具体数据，判断该数据对应的星期。
		1-星期一Monday

		思路：
		用户输入无法获取但是那只是具体数据的一种获取手段而已。
		而我们要做的功能仅仅是对用户指定的数据进行对应星期的打印而已。

		所以具体的数据不确定，完成可以使用变量来表示。

		我们只对变量进行操作即可。至于变量的值，可以有用户决定。

		因为数据的不确定性，所以要对数据进行判断。
		使用if语句。


		*/

		int week = 10;

		if(week==1)
			System.out.println(week+"对应中文是星期一");
		else if(week==2)
			System.out.println(week+"对应中文是星期二");
		else if(week==3)
			System.out.println(week+"对应中文是星期三");
		else if(week==4)
			System.out.println(week+"对应中文是星期四");
		else if(week==5)
			System.out.println(week+"对应中文是星期五");
		else if(week==6)
			System.out.println(week+"对应中文是星期六");
		else if(week==7)
			System.out.println(week+"对应中文是星期日");
		else
			System.out.println(week+"没有对应的星期");
		
	}
}

class IfTest2 
{
	public static void main(String[] args) 
	{

		/*
		一年有四季。
		春季：3 4 5
		夏季：6 7 8
		秋季：9 10 11
		冬季：12 1 2 
		根据用户输入的月份，给出对应的季节。


		*/
		
		int month = 8;
		
		if(month<1 || month>12)
			System.out.println(month+"月没有对应的季节");
		else if(month>=3 && month<=5)
			System.out.println(month+"月是春季");
		else if(month>=6 && month<=8)
			System.out.println(month+"月是夏季");
		else if(month>=9 && month<=11)
			System.out.println(month+"月是秋季");
		else 
			System.out.println(month+"月是冬季");



		/*
		if(month==3 || month==4 || month==5)
			System.out.println(month+"月是春季");
		else if(month==6 || month==7 || month==8)
			System.out.println(month+"月是夏季");
		else if(month==9 || month==10 || month==11)
			System.out.println(month+"月是秋季");
		else if(month==12 || month==1 || month==2)
			System.out.println(month+"月是冬季");
		else
			System.out.println(month+"月没有对应的季节");
			*/
			
	}
}

2.6.2 选择结构

switch语句
格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}

switch语句特点：
a,switch语句选择的类型只有四种：byte，short，int ， char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

class SwitchDemo 
{
	public static void main(String[] args) 
	{

		/*
		switch(表达式)
		{
			case 取值1:
				执行语句；
				break；
			case 取值2:
				执行语句；
				break；
			…...
			default:
				执行语句；
				break；
		}

		*/

		int x = 2;
		switch(x)//byte,short,int,char.
		{
			default:
				System.out.println("d");
				//break;
			case 4:
				System.out.println("a");
				//break;
			case 1:
				System.out.println("b");
				break;
			case 3:
				System.out.println("c");
				break;
			
		}

		int a = 4,b =2;
		char opr = '%';

		switch(opr)
		{
			case '+':
				System.out.println(a+b);
				break;
			case '-':
				System.out.println(a-b);
				break;
			case '*':
				System.out.println(a*b);
				break;
			case '/':
				System.out.println(a/b);
				break;
			default:
				System.out.println("无法运算,符号不支持");
				break;
		}


	}
}

class SwitchTest 
{
	public static void main(String[] args) 
	{

		
		/*
		用户输入的数据对应的出星期。
		*/
		int week = 1;
		switch(week)
		{
			default:
				break;
			case 1:
				System.out.println(week+"对应的是星期一");
				break;
			case 2:
				System.out.println(week+"对应的是星期二");
				//break;
				//...以此类推。 
		}

		/*
		季节的示例。 
		*/
		int month = 13;

		switch(month)
		{
			case 3:
			case 4:
			case 5:
				System.out.println(month+"月对应的是春季");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println(month+"月对应的是夏季");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println(month+"月对应的是秋季");
				break;
			case 12:
			case 1:
			case 2:
				System.out.println(month+"月对应的是冬季");
				break;
			default:
				System.out.println(month+"月没有对应的季节");
				//break;
		}

//		System.out.println("Hello World!");
	}
}

if语句和switch语句的区别

class  
{
	public static void main(String[] args) 
	{
		;
		System.out.println("Hello World!");
	}
}
if和switch的应用：

if:
	1,对具体的值进行判断。
	2,对区间判断。
	3,对运算结果是boolean类型的表达式进行判断。

switch:
	1,对具体的值进行判断。
	2,值的个数通常是固定的。
	对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存。
	效率相对高一点。

2.6.3 循环结构

代表语句：while ，do while ，for

while语句格式：
while(条件表达式)
{
执行语句；
}

class  WhileDemo
{
	public static void main(String[] args) 
	{

		/*
		while(条件表达式)
		{
			执行语句；
		}

		*/
		int x = 1;
		while(x<3);
		{
			System.out.println("x="+x);

			x++;
		}

		
	}
}

class WhileTest 
{
	public static void main(String[] args) 
	{

		/*
		
		练习：
		获取1到10 10个数字的和。

		0 + 1
		1 + 2
		   3 + 3
			 6 + 4
			    10 + 5
		思路：
		1，每次参与加法的数值不确定。
		2，每次的出现的和数据也不确定。
		3，发现参与加法运算的数值有递增规律。
		4，每一次都是加法运算在重复，并且都是和再加上下一个数值。

		步骤：
		1，定义一个变量，记录住参与加法运算的数据。
		2，定义一个变量，记录中每一次的出现的和。
		3，对于记录参与加法运算的数据进行自增。
		4，因为加法运算需要重复，就要想到循环结构。
		*/


		//累加思想。

		int x = 1;//记录参与加法的数据。
		int sum = 0;//记录住每一次的和。
		while(x<=100)
		{
			sum = sum + x;
			
			x++;
		}

		System.out.println("sum="+sum);
	  
	}
}

class  WhileTest2
{
	public static void main(String[] args) 
	{

		/*
		练习：
		1~100之间 6的倍数出现的次数。
		要求：自己独立完成思想的书写。和步骤的文字描述。


		*/

//		计数器思想
		int x = 1;
		int count = 0;
		while(x<=100)
		{
			if(x%6==0)
				count++;
//				System.out.println("x="+x);
			x++;
		}

		System.out.println("count="+count);
	}
}

do while语句格式：
do
{
执行语句；
}while(条件表达式);

do while特点是条件无论是否满足，循环体至少被执行一次。

class DoWhileDemo 
{
	public static void main(String[] args) 
	{

		/*
		do
		{
			执行语句；
		}while(条件表达式);

		*/
		int x = 1;
		do
		{
			System.out.println("x="+x);
			x++;
		}
		while (x<1);

		/*
		do while语句的特点：无论条件是否满足，循环体至少执行一次。 

		*/

		int y = 1;
		while(y<1)
		{
			System.out.println("y="+y);
			y++;
		}
	}
}

for语句格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
注：
a,for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
c,最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

class ForDemo 
{
	public static void main(String[] args) 
	{
		/*
		
		for(初始化表达式；循环条件表达式；循环后的操作表达式)
		{
			执行语句；(循环体)
		}

		

		for(int x = 1; x<3; x++)
		{

			System.out.println("x="+x);

		}
		*/
		int x = 1;
		for(System.out.println("a");x<3; System.out.println("c"))
		{
			System.out.println("d");
			x++;
		}

//		for(int a=0,b=0; a<3; a++,b--)

		//a d c d c
	}
}

for和while的区别

class ForTest 
{
	public static void main(String[] args) 
	{
		/*
		用for完成累加。
		*/
		int sum = 0;
		for(int x=1; x<=10; x++)
		{
			sum = sum + x;	
		}

		System.out.println("sum="+sum);

		/*
		for和while的特点：
		1,for和while可以互换。
		2,格式上的不同，在使用上有点小区别。
			如果需要通过变量来对循环进行控制，该变量只作为循环增量存在时，区别就体现出来了。
		*/

		//打印1~10十个数字
		int x = 1;
		while(x<5)
		{
			System.out.println("x="+x);
			x++;
		}
		System.out.println("x===="+x);

		for(int y=1; y<5; y++)
		{
			System.out.println("y="+y);
		}
		System.out.println("y====="+y);


		//无限循环最简单的形式。
//		while(true){}

//		for(;;){}

		什么时候使用循环结构呢？
		当对某些代码执行很多次时，使用循环结构完成。
		
		当对一个条件进行一次判断时，可以使用if语句。
		当对一个条件进行多次判断时，可以使用while语句。 

		注意：
			在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。
			循环通常情况下，需要定义条件，需要控制次数。

		

	}
}

For循环嵌套

class  ForForDemo
{
	public static void main(String[] args) 
	{
		//大圈套小圈思想。
		/*
		for(int x=0; x<3; x++)
		{
			for(int y=0; y<4; y++)
			{
				System.out.println("ok");
			}
		}
		*/

		/*
		
		*****
		*****
		*****
		*****
		
		*/
		for(int x=0; x<4; x++)//外循环控制的是行数
		{
			for(int y=0; y<5; y++)//内循环控制的是每一行的个数 
			{
				System.out.print("*");
			}
			System.out.println();
		}
	
		
		
	}
}

class ForForTest 
{
	public static void main(String[] args) 
	{

		/*
		
		*****
		****
		***
		**
		*


		*/

		/*
		int z = 5;
		for (int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
		{
			for (int y=1; y<=z ; y++ )
			{
				System.out.print("*");
			}
			System.out.println();
			z--;
		}
		*/
		/*

		int z = 1;
		for (int x = 1; x<=5 ;x++ )//1-5 1-4 1-3//1-5 2-5 3-5
		{
			for (int y=z; y<=5 ; y++ )
			{
				System.out.print("$");
			}
			System.out.println();
			z++;
		}
		*/
		for(int x=1; x<=5; x++)
		{
			for(int y=x; y<=5; y++)
			{
				System.out.print("*");
			}
			System.out.println();
		}






		/*

		*
		**
		***
		****
		*****
		*/
		System.out.println("----------");
		for (int x=1; x<=5 ;x++ )
		{
			for (int y=1;y<=x ;y++ )
			{
				System.out.print("*");
			}
			System.out.println();
		}



		System.out.println("----------");
		/*

		54321
		5432
		543
		54
		5


		*/
		for (int x=1; x<=5; x++ )
		{
			for (int y=5; y>=x ;y-- )
			{
				System.out.print(y);
			}
			System.out.println();
		}


		System.out.println("----------");
		/*
		1
		22
		333
		4444
		55555
		
		*/

		for (int x=1; x<=5 ; x++)
		{
			for (int y=1;y<=x ;y++ )
			{
				System.out.print(x);
			}
			System.out.println();
		}
	}
}

class ForForTest2 
{
	public static void main(String[] args) 
	{

		/*
		
		* * * * * 
		-* * * *
		--* * * 
		---* * 
		----*

		*/
		for(int x=1; x<=5; x++)
		{
			for(int y=1; y<x; y++)
			{
				System.out.print(" ");
			}
			
			for(int z=x; z<=5; z++)
			{
				System.out.print("* ");
			}

			System.out.println();
		}


		/*
		
		      *
			 * *
			* * *
		   * * * * 
		  * * * * *

		*/
	}
}

class ForFor99 
{
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 x=1; x<=9 ;x++ )
{
for (int y=1; y<=x ;y++ )
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}




/*
\n:回车：
\t:制表符。
\b:退格。
\r: 按下回车键。


windows系统中回车符其实是由两个符号组成的 \r\n.
linux中回车符是 \n.



System.out.println("\\hello world\\");
*/

}
}

2.6.4 其他流程控制语句
break( 跳出) ，continue( 继续)
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。

class BreakContinueDemo 
{
	public static void main(String[] args) 
	{

		/*
		break:跳出。
		break作用的范围：要么是switch语句，要么是循环语句。
		记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。
			break跳出所在的当前循环。
			如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。

		
		for(int x=0; x<3; x++)
		{
			if(x==1)
				break;
			System.out.println("x="+x);
		}
		

		xiaoqiang:for (int x=0; x<3 ;x++ )
		{
			wangcai:for (int y=0; y<4 ; y++)
			{
				System.out.println("x="+x);
				break xiaoqiang;
			}
			
		}*/

		/*
		continue:继续。
		作用的范围：循环结构。
		continue：结束本次循环，继续下次循环。
		如果continue单独存在时，下面不要有任何语句，因为执行不到。



		

		for (int x=0; x<11 ;x++ )
		{
			if(x%2==0)
				continue;
			System.out.println("x="+x);
		}
		*/
		xiaoqiang:for (int x=0; x<3 ;x++ )
		{
			wangcai:for (int y=0; y<4 ; y++)
			{
				System.out.println("x="+x);
				continue xiaoqiang;
			}
			
		}
	
	}
}

算法设计

//1.分支语句if...    if...else...
//2.循环语句for      while
//3.异或运算符
//4.数组
class Demo{
	public static void main(String[] args){
		//异或运算符 ^
		//System.out.println(1^2);
		//System.out.println(34^17^17);
		//System.out.println(15^1^2^3^3^2^1);
			
		//算法
		//计算的方法：在进行某种运算时所使用的方法/方式
		//计算机的算法：在计算机中进行运算时为计算机提前设定的运算方式
		//关键指标
		//1.运行时间
		//2.内存消耗
		/*
		最终结论：牺牲内存，换取时间
								牺牲时间，换取内存
		拿时间换空间，拿空间换时间						
		*/
				
		/*
		题设：现有0到99，共计100个整数，各不相同，将所有数放入一个
					数组，随机排布。数组长度101,多余的数字是0到99其中任
					意一个数(唯一重复的数字)
		问题：将这个重复的数字找出来
		*/
		//创建了一个101个整数的空间
		//初始化了一个空间为101的数组，并对其进行了数据初始化
		/*
		int[] arr = new int[101];
		for(int i = 0;i<=99;i++){
			arr[i] = i;
		}
		arr[100] = 69;
		
		for(int x = 1;x<=10000;x++){
			//随机排列
			int num1 = (int)(Math.random()*101);
			int num2 = (int)(Math.random()*101);
			//arr[num1]		arr[num2] 两个数据互换位置
			int temp = arr[num1];
			arr[num1] = arr[num2];
			arr[num2] = temp;
		}
		*/
		//--------------以上将题目设定出来------------------
		//问题：将这个重复的数字找出来
		//解决方案一：
		/*
		itcast:
		for(int i = 0;i<arr.length;i++){
			//取出第一个数字，然后与后面的所有数字比对
			//arr[i]与后面所有的数字比  arr[i+1]向后的数字
			for(int j =i+1;j<arr.length;j++){
				if(arr[i]==arr[j]){
					System.out.println("找到了重复的数字"+arr[i]);
					break itcast;
				}
			}
		}
		*/
		
		
		//解决方案二：
		//0到99 ，其中有一个重复的数字
		//将数组中所有的数字加一起0到99的和+重复的那个数字
		//将上述结果减去0到99的和  就可以得到重复的数字了
		/*
		int sum = 0;
		//将数组中所有的数字都加一起
		for(int i = 0;i<arr.length;i++){
			sum+=arr[i];
		}
		//使用上面的结果减0到99
		for(int i = 0;i<=99;i++){
			sum-=i;
		}
		System.out.println(sum);
		//方案二如果计算的数字特别多，比如有3万亿个数据，超出了数据类型
		*/
		
		/*
		//解决方案三：
		//0^1^2^3..^m...^99^m  ^0^1^2^3.....^99 = x
		//使用数组中的第一个数据，异或后面的所有数据
		for(int i = 1;i<arr.length;i++){
			arr[0]=arr[0]^arr[i];
		}
		for(int i = 0;i<=99;i++){
			arr[0]=arr[0]^i;
		}
		System.out.println(arr[0]);
		*/
		
		//0-99里面有一个数字是重复的，一共101个数字
		//0-99里面去掉一个，随机去掉一个，替换成另一个0-99的数字
		
		/*
		题设：现有0到99，共计100个整数，各不相同，将所有数放入一
					个数组，随机排布。数组长度100，将其中任意一个数替换
					成0到99另一个数(唯一重复的数字)
		问题：将这个重复的数字找出来
		*/
		/*
		int[] arr = new int[100];
		for(int i =0;i<arr.length;i++){
			arr[i] = i;
		}
		//打乱数组的排列顺序
		for(int x = 1;x<=10000;x++){
			//随机排列
			int num1 = (int)(Math.random()*100);
			int num2 = (int)(Math.random()*100);
			//arr[num1]		arr[num2] 两个数据互换位置
			int temp = arr[num1];
			arr[num1] = arr[num2];
			arr[num2] = temp;
		}
		//将其中一个替换成另一个
		int n1 = (int)(Math.random()*100);
		int n2 = (int)(Math.random()*100);
		if(n1 == n2){
			n1 = (int)(Math.random()*100);
		}
		//将随机的n2位置的值换成n1位置的值
		//System.out.println(n1+"位置的值换成了"+n2+"位置的值");
		arr[n1] = arr[n2];
		
		
		for(int i = 0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
		System.out.println("--------------");
		//---------------题目构造完成------------------
		//使用上面的方案一可以解决这个问题
		//算法：
		//1.创建一个辅助的数组空间,里面的数据元素全是0
		//*****在解决方案中使用了全新的数组，用于赋值解决问题
		//*****这个数组是需要消耗内存空间的，但是由于它的出现
		//*****加速了重复数据的查找速度，因此速度提高了，但是
		//*****内存被浪费了一些
		int[] newArr = new int[100];
		
		//2.循环原始数组，使用里面的数据做为新数组的下标，进行自加
		for(int i = 0;i<arr.length;i++){
			newArr[arr[i]]++;
			if(newArr[arr[i]] == 2){
				//当前下标对应的数据就是你要找的数据
				System.out.println(arr[i]);
				break;
			}
		}
		*/
		
		
		
		
		
		//题设：某门户网站，具有如下业务功能
		//			客户输入个人信息时，当输入年龄，会根据输入的年龄值
		//			显示其所属年龄段
		/*			 0 ～  9	儿童
						10 ～ 19	少年
						20 ～ 29	青年
						30 ～ 39	青壮年
						40 ～ 49	壮年
						50 ～ 59	中年
						60 ～ 69	中老年
						70 ～ 79	老年
						80 ～ 89	老老年
						90 ～ 99	老老老年									*/
		//问题：上述业务日均访问量超百万次，设计完成上述功能的程序
		//百万次访问次数多，要求速度最快，一定是速度优先，时间尽量少
		/*
		int age = 37;
		if(0-9){
			System.out.println(.....);
		}else if(10-19){
			System.out.println(.....);
		}else if(age.....20  29){
			System.out.println(.....);
		}else if(age.....30  39 ）{
			System.out.println(.....);
		}else if(age.....40  49){
			System.out.println(.....);
		}else if(age.....){
			System.out.println(.....);
		}else if(age.....){
			System.out.println(.....);
		}else if(age.....){
			System.out.println(.....);
		}else if(age.....90 99){
			System.out.println(.....);
		}
		
		0-39  40-99
		
		switch
		*/
		
		/*
		int age = 17;
		//题目的要求，按照年龄段来进行划分
		//age/10 ->得到这个人是哪个年龄段的
		String[] ages = {"儿童","少年","青少年","青年","青壮年","壮年","aaa","bbb","ccc","ddd"};
		System.out.println(ages[age/10]);
		//一次判断都没有，做了一次除法，还有一次获取数组元素的计算
		//声明了一个数组，数组要占用空间，辅助解决当前问题
		//拿空间换时间
		*/
		
		
		//问题：计算求出1到100的所有质数
		//质数：只能被1和其本身整除的数字叫做质数
		//质数：从2开始到n-1都不能整除这个数字n
		/*
		itcast:
		for(int i = 2;i<=100000000;i++){
			//如果判断了这个数字是质数，打印这个数字，否则不打印
			//构造反复进行整除判定的循环
			
			//第一次优化：j值不需要进行到i-1
			//第二次优化：j值比需要进行到i/2，进行到i的平方根就OK了
			for(int j = 2;j<Math.sqrt(i);j++){
				//System.out.println("验证数字"+i+"是否能被"+j+"整除");
				if(i % j == 0){
					//整除了，不需要继续计算了，也不需要打印了，进行下一个数字
					continue itcast;
				}
			}
			System.out.print(i+"\t");
		}
		*/
		
		
		//问题：计算求出1到10000的所有质数
		//问题：计算求出1到100000000的所有质数	
		//思路：
		//1.每次计算出一个质数后，将这个质数保存起来，存到数组中
		//2.每次验证都从保存的地方获取数据
		//用于保存所有的质数的数组
		/*
		int[] nums = new int[16];
		//声明一个变量，记录当前数组中已经有几个质数了
		int num = 0;
		
		
		//计算当前的时间
		long start = System.currentTimeMillis();
		itcast:
		for(int i = 2;i<=1000000;i++){
			
			for(int j = 2;j<=Math.sqrt(i);j++){
				if(i%j == 0){
					continue itcast;
				}
			}
			
			
			//从数组中第一个数据开始使用
			for(int j = 0;j < num;j++){
				//验证的时候，很多数字是不需要验证的，4,6,8,9,10,12,14
				//验证的时候只验证质数
				//目前没有质数，最好计算的质数保存起来
				if( nums[j] < Math.sqrt(i)){
					if(i % nums[j] == 0){
						continue itcast;
					}
				}
			}
			
			//将计算的数据放入数组nums中
			//先检测num的值是否超过了nums的索引范围
			//如果不超过
			if(num == nums.length){
				//如果超过
				//必须将原始数组的空间加大
				int[] temp = new int[nums.length*2];
				//将原始数组的数据拷贝过来
				for(int j = 0;j<nums.length;j++){
					temp[j] = nums[j];
				}
				//保存数据的数组指向新数组
				nums = temp;
			}
			nums[num] = i;
			num++;
		}
		long end = System.currentTimeMillis();
		System.out.println((end-start)+"ms");
		*/
		/*
		for(int i = 0;i<num;i++){
			System.out.print(nums[i]+"\t");
		}
		*/
		
		//使用数组保存质数16511ms
		//使用原始方式839ms
		//算法的设计不要按照自己大脑中的想法来进行估算
		
		//总结：
		//1.预先设计的算法在实际执行时未必像想想的那么速度快
		//一定要进行实际的测试
		//2.在算法设计时，不要忽略了一些简单的行为++ [] ==
		//这些操作需要开销时间的
		
		int a = 0;
		int[] arr = new int[4];
		long start = System.currentTimeMillis();
		for(int i =1;i<=1000000000;i++){
			a=a+2;
		}
		
		long end = System.currentTimeMillis();
		System.out.println((end-start)+"ms");
		
				
		
		//问题：计算100！计算结果末尾有多少个0
		运算结果末尾的0，全部都是由5和2相乘或者由10得到的
		//问题：计算1000！计算结果末尾有多少个0
		运算结果末尾的0，全部都是由5和2相乘或者由10得到的
		
		//问题：计算100！计算结果中有多少个0
		//问题：计算1000！计算结果中有多少个0
		100的阶乘是无法使用int,long描述的
		double描述是可以的，但是无法获取结果最后的0的个数

		//问题：计算1234！计算结果中有多少个0
		Java提供的大整数类型也保存不了1234！
		构造一种模型
		String s = "123456";
		1234567890
		"12" "3456" "7890"
		1234567890000
		"1" "2345"  "6789" "0000"
											 "0"
		String[]									
	}
}

msirene

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2.6-Java语言基础(程序流程控制)

判断结构选择结构循环结构2.6.1 判断结构if语句三种格式：1. if(条件表达式){执行语句；}2. if(条件表达式){执行语句；}else{执行语句；}3. if(条件表达式){执行语句；}else if (条件表达式){执行语句；}……else{执行语句；
复制链接

扫一扫

专栏目录