java后端怎么限制一个用户短时间重复调用同一个接口

循环结构

一，for循环

/*
for循环的使用：
一，循环结构四个要素
①初始化条件
②循环条件  -->是Boolean类型
③循环体
④迭代条件
二，for循环的结构
for(①;②;④){
	③
}
执行过程：①-->②-->③-->④-->②-->③-->④-。。。->②
*/
class  ForTest
{
	public static void main(String[] args) 
	{
		for (System.out.print('a');num<=3;System.out.print('c'),num++){  
		//System.out.print('c'),num++  是一个整体
			System.out.print('b');
		}
	}
}

例题：
遍历100以内的偶数，输出所有偶数的和，输出偶数的个数。

class  ForTest
{
	public static void main(String[] args) 
	{
		int sum=0; //记录所有偶数之和
		int count=0; //记录偶数的个数
		for (int i=1;i<=100;i++){   //注意i仅在for循环内有效
			if(i%2==0){
				System.out.println(i);
				sum+=i;
				count++;
			}
		}
	System.out.println("总和为"+sum);
	System.out.println("偶数个数为"+count);
	}
}

结果：

例题：

class  ForTest
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=150;i++){
			System.out.print(i+" ");
			if(i%3==0){
				System.out.print("foo ");
			}
			if(i%5==0){
				System.out.print("biz ");
			}
			if(i%7==0){
				System.out.print("baz ");
			}
			//换行
			System.out.println();

		}
	}
}

import java.util.Scanner;
class  ForTest
{
	public static void main(String[] args) 
	{
			
			Scanner scan=new Scanner(System.in);
			System.out.println("请输入一个正整数：");
			int m=scan.nextInt();
			System.out.println("请再次输入一个正整数：");
			int n=scan.nextInt();
			//获取最大公约数
			/*先获取两个数中的较小值，因为两个数的最大公约数一定不超过两个数中的最小值。
			想得到最大公约数，只需从两数最小值开始，逐渐递减，直到遇见第一个公约数，此公约数即为最大公约数。*/
			int min=(m>n)?n:m;
			for(int i=min;i>=1;i--){
				if(m%i==0&&n%i==0){
					System.out.println("最大公约数为："+i);
					break;  //执行到此处，跳出循环
				}
			}
			//获取最小公倍数
			/*先获取两个数中的较大值，因为两个数的最小公倍数一定不小于两个数中的最大值。
			想得到最小公倍数，只需从两数最大值开始，逐渐递增，直到遇见第一个公倍数，此公倍数即为最小公倍数
			*/
			int max=(m>n)?m:n;
			for(int i=max;i<=m*n;i++){
				if(i%m==0&&i%n==0){
					System.out.println("最小公倍数为："+i);
					break;
				}
			}
	}
}

二，while循环

/*
一，循环结构四个要素
①初始化条件
②循环条件  -->是Boolean类型
③循环体
④迭代条件
二，while循环的结构
①
while(②){
	③;
	④;
}
说明：写while循环千万小心不要丢了迭代条件，否则很可能会导致死循环！
for循环和while循环可以相互转换，但与for循环不同的是初始化条件的作用域不同，while循环中的i可以在循环外用。
*/

class WhileTest 
{
	public static void main(String[] args) 
	{
		//遍历100以内所有偶数
		int i=1;
		while(i<=100){
			if(i%2==0){
				System.out.println(i);
			}
			i++;	
		}
		
	}
}

do-while循环(开发中较少用)

/*
一，循环结构四个要素
①初始化条件
②循环条件  -->是Boolean类型
③循环体
④迭代条件
二，do-while循环的结构
①
do{
	③;
	④;
}while(②);
说明：
do-while循环至少执行一次循环体
*/
class DoWhileTest 
{
	public static void main(String[] args) 
	{
		//遍历100以内偶数，并计算所有偶数的和及偶数个数
		int num=1;
		int sum=0,count=0;
		do{
			if(num%2==0){
				System.out.println(num);
				sum+=num;
				count++;
			}
			num++;  //莫忘记
		}while(num<=100);
		System.out.println("偶数和为："+sum);
		System.out.println("偶数个数为："+count);
	}
}

循环结构例题

import java.util.Scanner;
class LiTi
{
	public static void main(String[] args) 
	{
		Scanner scan=new Scanner(System.in);
		int positiveNumber=0; //正数
		int negativeNumber=0; //负数
		while(true){  //注意此处，不在循环条件部分限制次数的结构！！！
			int number=scan.nextInt();  //获取一个整数
			//判正负
			if(number>0){
				positiveNumber++;
			}else if(number<0){
				negativeNumber++;
			}else{
			break; //0
			}
		}
		System.out.println("输入的正数个数为："+positiveNumber);
		System.out.println("输入的负数个数为："+negativeNumber);
	}
}

总结：

①不在循环条件部分限制次数的结构：while(true) 或for( ; ; )

②结束循环的方式：循环条件部分返回false、循环体中执行break。

嵌套循环

/*
情形一：
实现输出：
          ******
		  ******
		  ******
		  ******
*/

class ForForTest 
{
	public static void main(String[] args) 
	{
		//内层循环结构遍历一遍，只相当于外层循环循环体执行一次。
		//假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体共执行m*n次。
		for(int i=1;i<=4;i++){
			for(int j=1;j<=6;j++){
				System.out.print("*");
			}
			System.out.println();
		}
		
	}
}

技巧：外层循环控制行数；内层循环控制列数

/*
情形二：
实现输出：         i(行号)      j(*的个数)
		  *           1             1
		  **          2             2
		  ***         3             3
		  ****        4             4
		  *****       5             5
*/

class ForForTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=5;i++){ //控制行数
			for(int j=1;j<=i;j++){ //控制列数(巧妙之处)
				System.out.print("*");
			}
			System.out.println();
		}
		
	}
}

/*
情形三：
实现输出：         i(行号)      j(*的个数)    规律：i+j=6
		  *****      1             5
		  ****       2             4
		  ***        3             3
		  **         4             2
		  *          5             1
*/

class ForForTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=5;i++){ //控制行数
			for(int j=1;j<=6-i;j++){ //控制列数(巧妙之处)
				System.out.print("*");
			}
			System.out.println();
		}
		
	}
}

/*
情形四：
实现输出：
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 

*/

class ForForTest 
{
	public static void main(String[] args) 
	{
		//上半部分
		for(int i=1;i<=5;i++){
			for(int j=1;j<=5-i;j++){
				System.out.print(" ");
			}
			for(int k=1;k<=i;k++){ 
				System.out.print("* ");  //*后面有个空格
			}
			System.out.println();
		}
		//下半部分
		for(int i=1;i<=4;i++){ 
			for(int j=1;j<=i;j++){
				System.out.print(" ");
			}
			for(int k=1;k<=5-i;k++){ 
				System.out.print("* "); //*后面有个空格
			}
			System.out.println();
		}
	}
}

嵌套循环的应用：

九九乘法表

/*
九九乘法表
1*1=1
2*1=2 2*2=4
....
9*1=9 9*2=18 ... 9*9=81
*/

class NineNineTable 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=9;i++){
			for(int j=1;j<=i;j++){
				System.out.print(i+"*"+j+"="+(i*j)+"  ");  //此处是核心
			}
			System.out.println(); //换行
		}
	}
}

特殊关键字的使用break和continue

/*
break和continue关键字的使用：
不同点：
使用范围：break用于switch-case或循环结构；continue只用域循环结构中
循环中使用的作用：break结束当前循环；continue结束当次循环。
相同点：
两个关键字后面都不能声明执行语句。
*/
class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=10;i++){
			if(i%4==0){	
				break;
			}
			System.out.print(i);
		}
	}
}

class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=10;i++){
			if(i%4==0){	
				continue;
			}
			System.out.print(i);
		}
	}
}

理解区别：

class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=4;i++){
			for(int j=1;j<=10;j++){
				if(j%4==0){	
					break;  //默认跳出包裹此关键字最近的一层循环
				}
			System.out.print(j);
		}
		System.out.println();  //换行
	} 

  }
}

---

class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		for(int i=1;i<=4;i++){
			for(int j=1;j<=10;j++){
				if(j%4==0){	
					continue;
				}
			System.out.print(j);
		}
		System.out.println();  //换行
	} 

  }
}

break默认跳出包裹此关键字最近的一层循环结构。
continue默认跳出包裹此关键字最近的一层循环结构的当次循环。

怎样实现跳出外层循环（结束指定标签处的循环）。

实现方式：

class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		label:for(int i=1;i<=4;i++){ //加一个标志
			for(int j=1;j<=10;j++){
				if(j%4==0){	
					break label;   //结束指定标志处的循环
				}
			System.out.print(j);
		}
		System.out.println();  //换行
	} 

  }
}

---

class BreakContinueTest 
{
	public static void main(String[] args) 
	{
		label:for(int i=1;i<=4;i++){ //加一个标志
			for(int j=1;j<=10;j++){
				if(j%4==0){	
					continue label;   //结束指定标志处的循环结构的当次循环
				}
			System.out.print(j);
		}
		System.out.println();  //换行
	} 

  }
}

return语句: