Java小白入门总结

1. static final double PI=3.14;//使用常量时记得声明变量类型和变量名大写；

2. 进制 二进制0b 十进制 八进制0 十六进制0x 所有的字符本质还是数字;

   位运算符 & | ^ ~
   * A = 0011 1100
   * B = 0000 1101
   *----------------------------
   * A&B = 0000 1100 & : 都为1才为1，否则为0
   * A|B = 0011 1101 | : 都为0才为0，否则为1
   * A^B = 0011 0001 ^ : 两个相同则为0，否则为1异或运算符
   * ~B =1111 0010 ~ : 与B相反
   *
   * 效率极高！！！！
   * << *2 左移位符 逢二进一
   * >> /2 右移位符

   
   编码 Unicode 表：(97=a  65=A)  2字节   0-65536
   
   
   
   

   •  float 有限  离散  舍入误差  大约  接近但不等于
      *      所以，最好避免使用浮点数进行比较
      */
     float f=0.1f; //0.1
     double d=1.0/10; //0.1
     System.out.println(f==d); //false
     
     float d1=235626532f;
     float d2=d1+1;
     System.out.println(d1==d2);  //true&&&&
     

     char c=‘a’;
     int d=c+1;
     System.out.println(d);// 98
     System.out.println((char)d);// b

   //String字符串在前时，后面的数会当成字符串拼接
   System.out.println(""+a+b); //1020
   System.out.println(a+b+""); //30

3. 养成良好习惯，shift+ctrl+F对eclipse的代码进行格式化，换行用tap健和上下左右键【尽量避免反复空格】，养成建包的好习惯。

4. 笔记本程序开发四步走；(建立工程；手动编写Java文件；javac命令将Java文件编译为.class字节码文件；java命令运行字节码文件)

5. 集成开发环境是指程序开发环境和程序调试环境在一起；main方法不是关键字，main()方法是Java程序的入口点；main()方法的四要素包含public,static ,String[]args,void四要素都是关键字

6. String不是关键字，是个final类。short不常用也是八大基本类型之一，String不在包含内。

7. 变量名不可以用大写字母，数字，开头；可以用$下划线开头；变量名称中不可以包含%#等特殊字符；[Java标识符不一定是变量，可以首字母大写，例如类名，工程名]标识符：

8. Boolean是1位 ，

9. typora位置英文模式下esc键下面 的数字；三个和语言类型可以建立特定语言的代码块；ctrl+w关闭文档 ；ctrl+shift+esc打开任务管理器；ctrl+shift+delete进行电脑强制重启

10. JAVA Error occurred during initialization of VM

在VM初始化期间发生JAVA错误

虚拟机内存不够，可能是因为控制台的小红方格子一直没有关闭，因为手动的所以必须要关闭

11. switch 结构必须要有switch和case；不一定要有default和break，贯穿性！判断条件类型有

    byte，short ,int ,String ,enum ,char,不包含float，double；

12. 随机数强制转换： int discount=(int)(Math.random*9+1); 折扣1-9折； int强制类型转换时应该作为一个整体，否则编译错误

    在Java中，下面代码的输出结果为（ ）
    public static void main(String[] args) {
    		int x=2;
    		double y=2.5;
    		System.out.println(int(x+y));
    }
    //输出语句中int(x+y)应为（int）(x+y)，    输出结果不是4
    

13. for循环 初始化（迭代变量）；循环条件；循环体；迭代部分【后进行判断是否再次进入循环条件，循环体】

14. continue 跳出本次循环；继续下次循环；break结束当前内层循环；return相当于flag=false,不再继续往结构单元代码块下走。flag在判断数组中是否含有某数，或删除某个元素时使用，一组数中是否包含某数；

    package test0909;
    //
    public class DoubleCycle {
    public static void main(String[] args) {
    	int  i,j,x=0;
    	for (i=0;i<2;i++){
    	     x++;              //第一次x=1;
    	     for(j=0;j<=3;j++ ){//内部循环走完之后才走外部， 出现continue当前for循环不往下走，
    	    	 /**j=0,2跳过，j=1,3 时，for循环每次加1；所以此时for内结束循环+2 ，然后x=3;
    			 *
    			 * */
    	           if(j%2 == 0) continue;
    	           x++;
    	        }
    	    x++;//for结束加1，第一次结果 x=4; 因为两次循环所以最终结果为8
    	} 
    	System.out.println(x);
    
    }
    }
    
    

15. 使用数组原因：当用变量存储数据时，存储大量数据不能满足需求，所以需要用到数组，但必须保证变量类型相同；使用循环原因是许多相似代码冗余，；

16. 三个数或两个数要求换位置从小到大顺序，借助中间量temp进行交换；实现数字反转while（while num!=0）{int mod=num%10//个位上的余数；十位到万位的数字依次 num/=10;}顺序输出mod就可以了；

17. continue本次循环跳过，比如求不含七的倍数一定范围的数；

18. 有百分号时求比例必须先乘后除--------------比例为"+count*100/4+"%"

19. 旧数组中剔除元素后获得新数组，先遍历旧数组元素，判断新数组元素个数（新数组长度），剔除元素符合条件的开始计数count；然后声明并给新数组开辟空间，元素个数刚才count已求出，必须是获得个数后才建立数组，否则下标越界， int newArr[]=new int[count];

    package test0909;
    /**
     *现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 
     *要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，
     *生成新的数组为 int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
     * */
    public class DelZero {
    
    	public static void main(String[] args) {
    		int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
    		int count=0;//新数组中的元素个数,旧数组中不为0的个数；新数组长度
    		
    	    int index=0;//新数组的每个元素的下标
    	    //遍历旧数组中所有元素，获得新数组长度，
          for (int i = 0; i < oldArr.length; i++) {
    			
    			if (oldArr[i]!=0) {
    				count++;
    				
    			}
    		}
    	    
    	    int newArr[]=new int[count];//声明并给新数组开辟空间；此时已经获得了新数组的数组长度；
    		for (int i = 0; i < oldArr.length; i++) {
    			
    			if (oldArr[i]!=0) {
    			
    				 newArr[index]=oldArr[i];//旧数组中符合新数组中元素进行赋值
    				 index++;
    			}
    		}
    		for (int i = 0; i < newArr.length; i++) {
    			System.out.print(newArr[i]+"  \t ");
    		}
    	}
    
    }
    

    16.当经过多长时间会超过，连续迭代时用while（变量名<额度）；

    17.代码尽量不要引入过多变量，尽量自增；如

    pay=money*0.75;直接写money*=0.75;
    

    18.注释时斜杠向左；换行符和制表符（可以多出来一个空格）的斜杠向右，也叫反斜杠；

    19.break后不能有任何代码，括号要成对出现，当if后只有一句语句时可以省略大括号，切记代码规范要有缩进

    20。path带有bin;classpath指具体类所在目录；java中环境的配置。classpath和path，从字面上来看，classpath比path多了一个class，即是’类’的意思，所以，classpath配置的是类的路径，path配置的是包或者二进制文件夹的路径。比如配置JDK的时候，classpath配置指向具体的JAR文件(rt.jar\tools.jar)，在path中，指向的是jdk\bin的路径 path环境变量里面记录的是可执行性文件，如.exe文件，对可执行文件先在当前路径去找，如果没找到就去path环境变量中配置的路径去找classpath环境变量里记录的是java类的运行文件所在的目录

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNUh56Tx-1599838307355)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599647036638.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eYfIVyu9-1599838307357)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599646796599.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EfcrCxve-1599838307359)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599625271324.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wkxx3GWU-1599838307360)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1599625682536.png)]

1变量、运算符和类型转换

1.1手动输入一个学生的成绩，对这个成绩进行一次加分，加当前成绩的20%，输出加分后成绩

package test0908;
/**手动输入一个学生的成绩，对这个成绩进行一次加分，加当前成绩的20%，输出加分后成绩
 * */
import java.util.Scanner;

public class Score {
    
    
   public static void main(String[] args) {
    
    
	Scanner input=new Scanner(System.in);
	System.out.println("请输入一个整数");
	int score=input.nextInt();
     score+=0.2*score;
	System.out.println(score);
}
}

1.2商场举行店庆，抽几折打几折， 先手动输入消费金额，再输入，抽到的折扣，计算出折后价格

package test0908;
/**
 * 商场举行店庆，抽几折打几折， 先手动输入消费金额，再输入，抽到的折扣，计算出折后价格
 * */
import java.util.Scanner;

public class Price {
    
    
	   public static void main(String[] args) {
    
    
			Scanner input=new Scanner(System.in);
			System.out.println("请输入一个金额");
			double price=input.nextInt();
			//System.out.println("请输入一个折扣");
			//int discount=input.nextInt();
            int discount =(int)(Math.random()*10+1);//随机数生成
			System.out.println(price*discount*0.1);
		}

1.3手动输入一个4位数，求各位数字之和

package test0908;

import java.util.Scanner;
//.手动输入一个4位数，求各位数字之和
public class NumSum {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	System.out.println("输入一个四位数");
	int num=sc.nextInt();
	int ge=num%10;//个位数字
	int shi=num/100%10;//十位数字
	int bai=num/10%10;//百位数字
	int qian=num/1000;//千位
	int sum=ge+shi+bai+qian;
	System.out.println("数字之和为："+sum);
}
}

2分支结构

2.1商场消费返利活动，手动输入顾客消费金额， 如果金额打8折后仍然满1000元，用户就获得200元代金券一张（不考虑多张）

package test0908;

import java.util.Scanner;

//1商场消费返利活动，手动输入顾客消费金额， 如果金额打8折后仍然满1000元，用户就获得200元代金券一张（不考虑多张
public class Voucher {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	System.out.println("输入消费金额");
	double money=sc.nextDouble();
     money*=0.8;
	if (money>1000) {
    
    
        money-=200;
		System.out.print("恭喜获得200代金券");
	}else {
    
    
        
		System.out.print("谢谢惠顾");
	}
   System.out.println(",应支付"+money+"元");
}
}

2.2用户输入一个年份，如果是闰年输出是闰年 （年份能被4整除，且不能被100整除，或者能被400整除的年份）

package test0908;
//用户输入一个年份，如果是闰年输出是闰年 （年份能被4整除，且不能被100整除，或者能被400整除的年份
import java.util.Scanner;

public class LeapYear {
    
    
public static void main(String[] args) {
    
    
	Scanner input=new Scanner(System.in);
	System.out.println("输入年份");
	int year=input.nextInt();
	if ((year%4==0&&year%100!=0)||year%400==0) {
    
    
		System.out.println("该年是闰年");
	}else {
    
    
		System.out.println("平年");
	}
}
}

2.3手动输入一个整型会员号， 如果用户输入的是4位数字， 输出登录成功， 如果用户输入的不是4位数字, 输出“您输入的会员号有误”

package test0908;

import java.util.Scanner;

//2.3手动输入一个整型会员号， 如果用户输入的是4位数字， 输出登录成功， 如果用户输入的不是4位数字, 输出“您输入的会员号有误”
public class CardNum {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	System.out.println("输入卡号");
	String cardnum=sc.next();
	if (cardnum.length()==4) {
    
    
		System.out.println("登录成功");
	}else {
    
    
		System.out.println("您输入的会员号有误");
	}
}
}

2.4手动输入a，b，c三个变量的数值， 要求通过数值交换， 把输入的数值从小到大 排序放入a,b,c中，并输出

ppackage test0908;

import java.util.Scanner;
//2.4手动输入a，b，c三个变量的数值， 要求通过数值交换， 把输入的数值从小到大 排序放入a,b,c中，并输出
public class MaxNum {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	System.out.println("请输入a值");
	int a=sc.nextInt();
	System.out.println("请输入b值");
	int b=sc.nextInt();
	System.out.println("请输入c值");
	int c=sc.nextInt();
	int temp=0;//临时变量交换两数，如果不大于，不用交换；最后a的值确保最小（）
	if(a>b) {
    
    
		temp=b;
		b=a;
		a=temp;
	}
	if(a>c) {
    
    
		temp=c;
		c=a;
		a=temp;
	}
	if(b>c) {
    
    
		temp=c;
		c=b;
		b=temp;
	}
	System.out.println("顺序为"+a+","+b+","+c);
}
}

3多分支结构

3.1商场根据会员积分打折， 2000分以内打9折， 4000分以内打8折 8000分以内打7.5折， 8000分以上打7折， 使用if-else-if结构，实现手动输入购物金额和积分，计算出应缴金额

package test0908;

import java.util.Scanner;

//3.1商场根据会员积分打折， 2000分以内打9折， 4000分以内打8折 8000分以内打7.5折， 8000分以上打7折， 使用if-else-if结构，实现手动输入购物金额和积分，计算出应缴金额
public class RewardPoints {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	System.out.println("输入积分");
	int points=sc.nextInt();//积分
	double pay=0;//实际支出
	System.out.println("输入消费金额");
	double money=sc.nextDouble();
	if (points>8000) {
    
    
		pay=money*0.7;
	}else  if (points>4000) {
    
    
		pay=money*0.75;
	}else  if (points>2000) {
    
    
		pay=money*0.8;
	}else {
    
    
	    pay=money*0.9;
	}
	System.out.println("应缴金额为"+pay+"元");
}
}

3.2机票价格按照淡季旺季、头等舱和经济舱收费、 输入机票原价、月份和头等舱或经济舱， 其中旺季（5-10月）头等舱9折，经济舱85折， 淡季（11月到来年4月）头等舱7折，经济舱65折， 最终输出机票价格

package test0908;

import java.util.Scanner;

//3.2机票价格按照淡季旺季、头等舱和经济舱收费、 输入机票原价、月份和头等舱或经济舱， 其中旺季（5-10月）头等舱9折，经济舱85折， 淡季（11月到来年4月）头等舱7折，经济舱65折， 最终输出机票价格
public class TicketPrice {
    
    
public static void main(String[] args) {
    
    
	Scanner input =new Scanner(System.in);
	double ticketPrice;//实付金额，票原价
	System.out.println("输入机票原价");
	ticketPrice=input.nextDouble();
	System.out.println("输入月份");
		int month=input.nextInt();
		System.out.println("输入y请选择确定头等舱");
		String ans=input.next();
		if (ans.equals("y")) {
    
    
			if (5<=month&&month<=10) {
    
    
				ticketPrice*=0.9;
			}else {
    
    
				ticketPrice*=0.7;
			}
		}else {
    
    
			if (5<=month&&month<=10) {
    
    
				ticketPrice*=0.85;
			}else {
    
    
				ticketPrice*=0.65;
			}
		}
	System.out.println("机票价格为"+ticketPrice+"元");
}
}
      

3.3选择一个形状（1长方形、2正方形、3三角形、4圆形） 根据不同的选择让用户输入不同的信息， 长方形有长和宽、 正方形有边长、 三角形有底和高、 圆形有半径， 计算输出指定形状的面积

package test0908;

import java.util.Scanner;

//3.3选择一个形状（1长方形、2正方形、3三角形、4圆形） 根据不同的选择让用户输入不同的信息， 长方形有长和宽、 正方形有边长、 三角形有底和高、 圆形有半径， 计算输出指定形状的面积
public class FigureArea {
    
    
	
public static void main(String[] args) {
    
    
	int a,b,c,l,h,r;//长方形的长；宽；正方形边长；三角形底；高；圆形半径；
	double PI=3.14;
	double squre=0;
	Scanner input=new Scanner(System.in);
 System.out.println("根据序号选择图形形状1长方形、2正方形、3三角形、4圆形，");
	int choice=input.nextInt();
 switch(choice) {
    
    
 case 1:
	 System.out.println("请输入长");
	 a=input.nextInt();
	 System.out.println("请输入宽");
	 b=input.nextInt();
	 squre=a*b;
	 break;
 case 2:
	 System.out.println("请输入边长");
	 c=input.nextInt();
	
	 squre=c*c;
	 break;
 case 3:
	 System.out.println("请输入底");
	 l=input.nextInt();
	 System.out.println("请输入高");
	 h=input.nextInt();
	 squre=l*h/2;
	 break;
 case 4:
	 System.out.println("请输入半径");
	 r=input.nextInt();
	 squre=r*r*PI;
	 break;
 }
 
 System.out.println("输出指定形状的面积"+squre);
}
}

3.4输入年份和月份，输出这个月应该有多少天（使用switch结构）

package test0908;

import java.util.Scanner;

//3.4输入年份和月份，输出这个月应该有多少天（使用switch结构）
public class FigureDays {
    
    
public static void main(String[] args) {
    
    
	Scanner input=new Scanner(System.in);
	int days=0;
	System.out.println("输入年份");
	int year=input.nextInt();
	System.out.println("输入月份");
	int month=input.nextInt();
	switch(month) {
    
    
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12:
		days=31;
		break;
	case 4:
	case 6:
	case 9:
	case 11:
		days=30;
		break;
	case 2:
		if ((year%4==0&&year%100!=0)||year%400==0) {
    
    
			System.out.println("该年是闰年,");
			days=29;
		}else {
    
    
			System.out.println("平年,");
			days=28;
		}
		break;
	

	}
	System.out.println("这个月应有的天数是："+days);
}
}

4循环结构（上）

死循环，无限for循环

 for(;;){
            System.out.println("我就是这么帅，不服不行***");
        }

4.1随机生成一个1-100之间的数字num，循环让用户输入猜这个数， 如果用户输入的数字大于num提示输入的数字比较大， 如果用户输入的数字小于num提示输入的数字比较小， 直到用户输入的数字和num相等为止，然后输出用户猜数的总次数

package test0908;

import java.util.Scanner;

public class GuessNums {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	int num=(int)(Math.random()*100+1);//随机数
	int guess=0;//猜的数字
	int count=0;//猜的次数
	System.out.println("系统生成的随机数是"+num);//外挂显示随机数
			do {
    
    
				System.out.println("输入你猜的数");
				 guess=sc.nextInt();
				 if (guess>num) {
    
    
					System.out.println("输入的数字比较大");
				}else if(guess<num) {
    
    
					System.out.println("输入的数字比较小");
				}
				 count++;
			}while(guess!=num);
			System.out.println(count);
}
}

4.2打印出1-100之间所有不是7的倍数和不包含7的数字，并求和

package test0908;
//4.2打印出1-100之间所有不是7的倍数和不包含7的数字，并求和
public class NumberMultiples {
    
    
public static void main(String[] args) {
    
    
 int sum = 0;
      for (int i = 1; i <= 100; i++) {
    
    
          if(i%7 ==0 || i%10 == 7 || i/10 == 7){
    
    //注意：70-79容易漏掉，跳出xunhuan
              continue;
          }
          sum += i;
      }
      System.out.println(sum);
}
}

4.3***循环输入5个数，输完后显示这些数中有没有负数***

package test0908;

import java.util.Scanner;

//4.3循环输入5个数，输完后显示这些数中有没有负数
public class ConfirmNegative {
    
    
public static void main(String[] args) {
    
    
	Scanner sc=new Scanner(System.in);
	
	int i=1;//循环次数
	int flag=0;//标记符号,负数的个数
	while (i<=5) {
    
    
		System.out.println("请输入1个数字");
		int num=sc.nextInt();
		if(num<0) {
    
    
			flag=1;
		}
		i++;
		++flag;
		
	}
  //System.out.println(flag);
if (flag>0) {
    
    
	System.out.println("这些数中有负数");
}else {
    
    
	System.out.println("这些数中没有负数");
}
}

package test0908;
//boolean 类型和布尔一起判断
import java.util.Scanner;

//4.3循环输入5个数，输完后显示这些数中有没有负数
public class ConfirmNegative {
public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	
	int i=1;//循环次数
	boolean flag=false;//假设不含有负数；
	while (i<=5) {
		System.out.println("请输入1个数字");
		int num=sc.nextInt();
		if(num<0) {
			flag=true;
		}
		i++;
		}
  //System.out.println(flag);
if (flag) {
	System.out.println("这些数中有负数");
}else {
	System.out.println("这些数中没有负数");
}
}
}

5循环结构（下）

5.1有一个有钱的神经病，他往银行里存钱， 第一天存1元,以后每天比前一天多存50%，完成下列计算任务

1)他存到第几天，当天存的钱会超过10元

package test0908;

import java.util.Iterator;
import java.util.Scanner;

/**有一个有钱的神经病，他往银行里存钱， 第一天存1元,以后每天比前一天多存50%，完成下列计算任务 
1)他存到第几天，当天存的钱会超过10元个月（30天）后，他总共存了多少钱
 *
 * */
public class SaveMoney {
    
    
   public static void main(String[] args) {
    
    
	Scanner input = new Scanner(System.in);
	double money=1;
	int day=1;
	double sum=0;
	
       while(money<10) {
    
    
         sum+=money;
           money*=1.5;
           day++;
           System.out.println("day:"+day+",money:"+money);
       }
         System.out.println(sum+money);//最后一天已经超过10，不在sum中相加
}
}

2)一个月（30天）后，他总共存了多少钱

public class SaveMoney2 {
    
    
   public static void main(String[] args) {
    
    
	Scanner input = new Scanner(System.in);
	double money=1;
	int day=1;
	double sum=0;

	for (int i = 1; i <=30; i++) {
    
    
		sum+=money;
		money*=1.5;
		
	}
	System.out.println(sum);
}
}

5.2有一个400米一圈的操场，一个人要跑10000米， 第一圈50秒，其后每一圈都比前一圈慢1秒， 按照这个规则计算跑完10000米需要多少秒

package test0908;

import java.util.Scanner;

//#### 5.2有一个400米一圈的操场，一个人要跑10000米， 第一圈50秒，其后每一圈都比前一圈慢1秒， 按照这个规则计算跑完10000米需要多少秒

public class RunCircle {
    
    
public static void main(String[] args) {
    
    
	Scanner input = new Scanner(System.in);
	int count=10000/400;//圈数
	int time=50;
	int sum=0;
	for (int i = 1; i < count; i++) {
    
    //剩余跑49圈的时间
		time+=1;
		sum+=time;
	}
	sum+=50;//第一圈时间
	System.out.println(sum);
}
}

5.3用户输入任意一个整数，求各位数字之和

package test0908;

import java.util.Scanner;

/**
 *户输入任意一个整数，求各位数字之和
 * */
public class NumSum2 {
    
    
public static void main(String[] args) {
    
    
	Scanner input = new Scanner(System.in);
	System.out.println("请输入一个整数 ");
    int num=input.nextInt();
    int sum=0;
while(num>0) {
    
    
	int mod=num%10;//10的余数，各位上数字累加
	sum+=mod;
	num/=10;//循环后余数分别获得十位，百位的数字，
}
System.out.println(sum);
}
}

5.4井里有一只蜗牛，他白天往上爬5米，晚上掉3.5米，井深56.7米 计算蜗牛需要多少天才能从井底到爬出来

package test0908;
/**
 *5.4井里有一只蜗牛，他白天往上爬5米，晚上掉3.5米，井深56.7米
计算蜗牛需要多少天才能从井底到爬出来
 * */
public class ClimbWell {
    
    
public static void main(String[] args) {
    
    
	int day=1;
	double sum=0;//爬过距离
	while (true) {
    
    
		sum+=5;//白天上
		System.out.print(day+"白天结束时上升了"+sum+"米   ");
		if (sum>56.7) {
    
    
			break;
		}
		sum-=3.5;//晚上下
		day++;
	}
	System.out.println();
	System.out.println(day);
}
}

6循环嵌套

乘法表

package test0909;

public class MultiyTable {
                 public static void main(String[] args) {
                         for (int i = 1; i < 10; i++) {//外层圈数
							for (int j = 1; j <=i; j++) {
								System.out.print(j+"*"+i+"="+(i*j)+"\t");
							}
							System.out.println();
						}
				}
}

用while和for循环输出1-1000之间能被7整除的数，且每行输出五个。

• public class Test6 {
  public static void main(String[] args) {
   
   	for (int i = 1; i <1000; i++) {
     		if (i%7==0) {
    				System.out.print(i+"\t");
  		}//获得符合七倍数的条件；
        		if (i%(5*7)==0) {//五个数一换行
        			System.out.println();
    			}
    			
    		}
      }
      }
  

6.1求1~1000以内质数列表 PS：质数是只能被1和自身整除的整数

package test0908;

public class Prime {
    
    
public static void main(String[] args) {
    
    
int i,j;
for (i = 1; i <=1000; i++) {
    
    //数值范围
	for ( j= 2; j<i; j++) {
    
    //质数范围
		if (i%j==0) {
    
    //排除多余因子，fei质数
			break;
			}
	};
	if (i==j) {
    
    
		System.out.print(j+"  ");
	}
}
}
}

循环组合练习

package test0909;

import java.util.Scanner;

public class GameMenu {
public static void main(String[] args) {
	int choice=0;
	do {
	System.out.println(" 欢迎进入青鸟游戏迷你平台");
	
	Scanner input = new Scanner(System.in);
	System.out.println("请选择您喜欢的游戏：\n ");
	System.out.println(" *******************************************************");
    System.out.println("                      1.斗地主                          ");
    System.out.println("                      2.斗牛                            ");
    System.out.println("                      3.泡泡龙                          ");
    System.out.println("                      4.连连看                          ");
	System.out.println(" *******************************************************");
	 choice =input.nextInt();
    switch (choice) {
	case 1:
		System.out.println("您已进入斗地主房间！");
		return;
	case 2:
		System.out.println("您已进入斗牛 房间！");
		return;
	case 3:
		System.out.println("您已进入泡泡龙  房间！");
		return;
	case 4:
		System.out.println("您已进入连连看房间！");
		return;
	case 0: exit();
        return;
	default:
		System.out.println("请选择正确的功能编号 ");
		break;
	}
	}while(choice!=0);
	
}

private static void exit() {
	System.out.println("您已选择退出游戏，欢迎下次再来 ");

---

package test0909;

import java.util.Scanner;

public class GameCoins {
public static void main(String[] args) {
	int money;
System.out.println(" 青鸟游戏迷你平台>游戏币支付");
Scanner input = new Scanner(System.in);
System.out.println("请选择游戏类型\n1.牌类\n2.休闲竞技类 ");
int choice=input.nextInt();
System.out.println("请输入游戏时长 ");
int hours=input.nextInt();
switch (choice) {
case 1:
	if (hours>10) {
		money=hours*10*5/10;
		System.out.println(" 您玩的是牌类游戏，时长是"+hours+"小时,可以享受五折优惠，总共需要"+money+"个游戏币");
	}else {
		money=hours*10*8/10;
		System.out.println(" 您玩的是牌类游戏，时长是"+hours+"小时,可以享受八折优惠，总共需要"+money+"个游戏币");
		
	}
	break;

case 2:
	if (hours>10) {
		money=hours*20*5/10;
		System.out.println(" 您玩的是竞技类游戏，时长是"+hours+"小时,可以享受五折优惠，总共需要"+money+"个游戏币");
		
	}else {
		money=hours*20*8/10;
		System.out.println(" 您玩的是竞技类游戏，时长是"+hours+"小时,可以享受八折优惠，总共需要"+money+"个游戏币");
		
	}
	break;
}

}
}

————————————————————————————————————————————————————————————

package test0909;

import java.util.Scanner;

public class GamePoints {
	public static void main(String[] args) {
		int money;
	System.out.println(" 青鸟游戏迷你平台>游戏点击率");
	Scanner input = new Scanner(System.in);
	int count=0;//点击率大于100的数目；
	for (int i =1; i <=4; i++) {
		System.out.println("请输入第 "+i+"个游戏的点击率");
	int points=input.nextInt();
	if (points>100) {
		count++;
	}else {
		continue;
	}
	}
	System.out.println("点击率大于100 的游戏数是"+count+"\n比例为"+count*100/4+"%");
	}
	
}

————————————————————————————————————————————————————————————

package test0909;

import java.util.Scanner;

public class GameRank {

	public static void main(String[] args) {
		System.out.println(" 青鸟游戏迷你平台>游戏晋级");
		Scanner input = new Scanner(System.in);
		String ans="";
		int count=1;//游戏局数
		int score=0;//游戏得分
		//boolean flag=true;//假设能晋级
		for (int i = 1; i <=5; i++) {
			System.out.println("您正在玩第 "+i+"局，成绩为");
			score=input.nextInt();
			if (score>=80) {
				count++;
			}
			if (count<4) {
				System.out.println("继续玩下一局yes,no");
				ans=input.next();
				if (ans.equals("no")) {
					System.out.println("您已中途推出游戏\n对不起，您未能晋级，继续加油啊");
					//flag=false;//相当于return；
					return;
				}
			}
		}
		
		
	if (count>=4) {
		System.out.println(" 恭喜您晋级一级");
	}else if (count==3) {
		System.out.println(" 恭喜您晋级二级");
	}else {
		System.out.println(" 很遗憾，out！");
	}

	}

}

——————————————————————————————————————————————————————————

package test0909;

import java.util.Scanner;

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

		System.out.println(" 青鸟游戏迷你平台>添加用户信息");
		Scanner input = new Scanner(System.in);
		System.out.println(" 请输入用户的数量");
		int count = input.nextInt();
		String num = "";//会员卡号不一定为数字可以为字母组合
		int scores = 0, age = 0;// 用户编号，年龄，积分
		for (int i = 1; i <= count; i++) {
			System.out.println("请输入第 " + i + "个用户的信息");
			System.out.println("用户编号四位数 ");
			num = input.next();
			while (num.length() != 4) {
				System.out.println("用户编号必须是四位数，请重输 ");
				num = input.next();
			}
			System.out.println(" 用户年龄：");
			while (input.hasNextInt()) {//排除不合适的数据类型，利用scanner进行过滤判断
            
				age=input.nextInt();
			};
			

			if (age < 18) {
				System.out.println("很抱歉，您的年龄不适合玩游戏");
				continue;
			}
			System.out.println(" 积分");
			scores = input.nextInt();
			System.out.println("用户编号 " + num + "\t年龄" + age + "\t积分" + scores);

		}

冒泡，求最值不用break，一直进行比较；数组中是否包含此数，插入到有序数组中时用break，找到最接近值，就停止比较

冒泡排序（从小到大）

冒泡排序双重for循环，借用temp做量值交换

int temp=arr[j]; //升序时 arr[j]>arr[j+1]才比较、

int temp=arr[j]; //降序时 arr[j]<arr[j+1]才比较、

package test0909;

public class BubbleSort {
public static void main(String[] args) {
 int []arr= {6,3,8,2,9,1};
 System.out.println("排列前顺序为： ");
 for (int i : arr) {
	System.out.print(i+"\t");
}
 for (int i = 0; i < arr.length-1; i++) {//外层循环比的次数是数组长度-1，因为最后一个元素就是最大值，自己不哟个和自己比比较
	for (int j = 0; j < arr.length-1-i; j++) {//内层是控制每一圈排序多少次
		if (arr[j]>arr[j+1]) {
			int temp=arr[j];
			arr[j]=arr[j+1];
			arr[j+1]=temp;
		}
	}
}
 System.out.println("\n排列后升序为： ");
 for (int i : arr) {
	System.out.print(i+"\t");
 }
}
}

package test0909;

public class BubbleSort {
    
    
public static void main(String[] args) {
    
    
 int []arr= {
    
    6,3,8,2,9,1};
 System.out.println("排列前顺序为： ");
 for (int i : arr) {
    
    
	System.out.print(i+"\t");
}
 for (int i = 0; i < arr.length-1; i++) {
    
    //外层循环比的次数是数组长度-1，因为最后一个元素就是最大值，自己不哟个和自己比比较
	for (int j = 0; j < arr.length-1-i; j++) {
    
    //内层是控制每一圈排序多少次
		if (arr[j]<arr[j+1]) {
    
    
			int temp=arr[j];
			arr[j]=arr[j+1];
			arr[j+1]=temp;
		}
	}
}
 System.out.println("\n排列后降序为： ");
 for (int i : arr) {
    
    
	System.out.print(i+"\t");
 }
}
}

插入值（升序，降序）到数组中

需要用到break；for循环中i>=index,否则输入相同数值时会出现覆盖情况

1给插入值下标初始化等于数组长度；

2获得index//升序时nums[i]>input;降序时nums[i]<input.获得index=i;

3循环顺次移位 //升序时arr.length -2开头，arr[i+1]=arr[i];//降序时arr.length -1开头，arr[i]=arr[i-1];

4 将输入值input赋值到nums[index ] 然后进行foreach循环输出

package test0909;

import java.util.Arrays;
import java.util.Scanner;

//一组有序的字符序列a、b、c、e、f、p、u、z，向次字符序列中插入一个新的字符，要求插入之后字符序列仍保持有序
//,'b','c','e','f','p','u','z'
public class InserCharAsc {
    
    
public static void main(String[] args) {
    
    
	 char[]arr= new char[9];
	 arr[0]= 'a' ;
	 arr[1]=  'b';
	 arr[2]= 'c' ;
	 arr[3]= 'e' ;
	 arr[4]= 'f' ;
	 arr[5]= 'p' ;
	 arr[6]=  'u';
	 arr[7]=  'z';

	 
	 System.out.print("原序列：");
	 for (char ch : arr) {
    
    
			System.out.print(ch+"\t");

		}
		 int index=arr.length-1;//首先给它赋值把它放入最后一个位置  8 
		 System.out.println("\n待插入的字符是：");
		 Scanner input = new Scanner(System.in);
		String c=input.next();//
		
		//升序插入数值1，找到下标；2，循环移位，3把输入的结果赋值给该数组的下标
		for (int i = 0; i < arr.length; i++) {
    
    
			if (arr[i]>c.charAt(0)) {
    
    
				index=i;
				System.out.println("插入的下标为"+index);
				break;
			}
		}
		//循环yi位  8  7
		for (int i = arr.length -2; i >= index; i--) {
    
    //与index比较，前面的东西不用动，i+1=数组长度=arr.length-1,所以cong
			//要移动的话，从第八位可以移动到第九位，arr.lenght-1是第九位不能往后移了
			arr[i+1]=arr[i];//
		}
		//输入的数赋值给数组元素
		arr[index]=c.charAt(0);
	
		System.out.print("\n插入后字符序列：");
		
		 for (char ch : arr) {
    
    
			System.out.print(ch+"\t");

		}
		 

}
}

package test0909;

import java.util.Arrays;
import java.util.Scanner;

/**
 *有一组学员的成绩{99，85，82，63， 60}，将它们按升序排列
 。
 *要增加一个学员的成绩，将它插入成绩序列，并仍保持降序
 *
将成绩序列保存在长度为6的数组中
通过比较找到插入位置
将该位置后的元素后移一个位置
将增加的学员成绩插入到该位置 
//Arrays.sort()方法只是显示，实际上数组位置并没有移动
 * */
public class InsertElementDesc {

	public static void main(String[] args) {
	int[] scores=new int[6];//数组长度扩容
	scores[0]=99;
	scores[1]=85;
	scores[2]=82;
	scores[3]=63;
	scores[4]=60;
	
     int index=scores.length-1;//把插入的数字放在最后一位；插入的坐标初始化为数组的长度减1
	//接收值因为有默认值0存在，所以插入数值后可能会把其中元素给占据掉，题目要求的是插入后排序；所以首先把他插入到第一位。保证数组元素不丢失，把他放在元素首位
	Scanner input = new Scanner(System.in);
	System.out.println(" \n输入的成绩为");
	int newscore=input.nextInt();
//不能用arrays排序 

	//找到坐标插入的位置
 
	for (int i = 0; i < scores.length; i++) {
		if (scores[i]<newscore) {//因为降序，让数组中元素小于输入的新元素
			index=i;
			break;//找到位置后必须停止，否则没有结果
		}
	}
	//位置整体后移一位
	for (int i =scores.length-1; i>=0; i--) {
		scores[i]=scores[i-1];
		
	}
	//给新输入的元素赋值到需要插入的数组下标的元素；
	scores[index]=newscore;
   
	//插入的下标位置是
    System.out.println(index);
	

	//插入后数序为：
    System.out.println("插入后成绩降序序为");
	for (int i : scores) {
		System.out.print(i + "\t");
		
	}
}
}

判断是否包含某数

package test0909;
//判断一个输入的数值是否在此数列中
import java.util.Scanner;

public class BooleanInclued {
    
    
 public static void main(String[] args) {
    
    
 int [] arr= {
    
    8,4,2,1,23,344,12};
System.out.println("输入一个成绩");
 Scanner input = new Scanner(System.in);
 int num=input.nextInt();
 boolean flag=false;//不在数列中
 for (int i = 0; i < arr.length; i++) {
    
    
	 
	 if (num==arr[i]) {
    
    
		 flag=true;
		break;
	}
}
 if (flag) {
    
    
	System.out.println("数列中包含此数");
}else {
    
    
	System.out.println(" 不包含");
}
}
}

 System.out.print(Arrays.asList(目标数组).contains("检查的元素") );

删除数组中的特定值

int[] intArray = { 1, 2, 3, 4, 5 };  
    int[] removed = ArrayUtils.removeElement(intArray, 3);//创建新的数组  
    System.out.println(Arrays.toString(removed));

package test0909;
/**
 *现在有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 
 *要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，
 *生成新的数组为 int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
 * */
public class DelZero {
    
    

	public static void main(String[] args) {
    
    
		int oldArr[]={
    
    1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
		int count=0;//新数组中的元素个数,旧数组中不为0的个数；新数组长度
		
	    int index=0;//新数组的每个元素的下标
	    //遍历旧数组中所有元素，获得新数组长度，
      for (int i = 0; i < oldArr.length; i++) {
    
    
			
			if (oldArr[i]!=0) {
    
    
				count++;
				
			}
		}
	    
	    int newArr[]=new int[count];//声明并给新数组开辟空间；此时已经获得了新数组的数组长度；
		for (int i = 0; i < oldArr.length; i++) {
    
    
			
			if (oldArr[i]!=0) {
    
    
			
				 newArr[index]=oldArr[i];//旧数组中符合新数组中元素进行赋值
				 index++;//切记不可忘记
			}
		}
		for (int i = 0; i < newArr.length; i++) {
    
    
			System.out.print(newArr[i]+"  \t ");
		}
	}

}

最大值和最小值

package test0909;

import java.util.Scanner;

public class MinPrice {
public static void main(String[] args) {
     double[]prices=new double[4];
     Scanner input = new Scanner(System.in);
     for (int i = 0; i < prices.length; i++) {
		System.out.println("请输入第"+(i+1)+"家超市的商品价格");
		prices[i]=input.nextDouble();
	}
     double min=100000000;//不能初始化为0,否则就一直为0
    for (int i = 0; i < prices.length; i++) {
		if (prices[i]<min) {
			min=prices[i];
			
		}
	}
    System.out.print("商品的最低价格为"+min+"元\t");

}
}

******************************************************************************************

package test0909;

import java.util.Arrays;
import java.util.Scanner;

public class MinPrice2 {
public static void main(String[] args) {
     double[]prices=new double[4];
     Scanner input = new Scanner(System.in);
     for (int i = 0; i < prices.length; i++) {
		System.out.println("请输入第"+(i+1)+"家超市的商品价格");
		prices[i]=input.nextDouble();
	}
     Arrays.sort(prices);
     
     double min=prices[0];
  
    System.out.print("商品的最低价格为"+min+"元\t");

}
}

//求最大值及下标
package homework0911;

import java.util.Arrays;

public class MaxAndIndex2{
	public static void main(String[] args) {
 int []arr1= {18,25,7,36,13,2,89,63};
	Arrays.sort(arr1);//只显示排序，不改变数组元素本身的位置；
	//升序后获得最大值；
		 System.out.println(arr1[arr1.length-1]);
	//通过数组方法获得下标
	
	System.out.println(Arrays.binarySearch(arr1,arr1[arr1.length-1])); 
	}
	
***************************************************************************************************
package test0909;

import java.util.Arrays;

//4有8个整数（18，25，7，36，13，2，89，63）的数组中找出其中最大的数及其下标
public class MaxAndIndex {
public static void main(String[] args) {
	int []arr= {18,25,7,36,13,2,89,63};
	int max=0;
	for (int i = 0; i < arr.length; i++) {
		if (arr[max]<arr[i]) {
			max=i;
		}
	}
	System.out.println("数组中最大值为"+arr[max]+"\t索引为"+max);

平均值

package homework0911;

public class Test7 {
  public static void main(String[] args) {
	  int []arr1= { -10,2,3,246,-100,0,5};
	  int max=0;int  min=0;int sum=0;
	  for (int i = 0; i < arr1.length; i++) {
		  System.out.println(arr1[i]);
		  sum+=arr1[i];//平均值
		if (max<arr1[i]) {
			max=arr1[i];//最大值
		}
		if (min>arr1[i]) {
			min=arr1[i];//最小值
		}
	}
	  System.out.println(max+"\t"+min+"\t"+sum/arr1.length);
}
}

数组vs数字逆序反转

//一个数组中的元素逆序存放
public class ConverseArray {
	public static void main(String[] args) {
		int []arr= {6,3,8,2,9,1};
		int temp;
		for (int i = 0; i < arr.length/2; i++) {
			temp=arr[i];
			arr[i]=arr[arr.length-1-i];//数组长度分为两个数
			arr[arr.length-1-i]=temp;
		
		}
		System.out.println("排列的顺序为");
		for (int i : arr) {
			System.out.print(i+"\t");

		}
	}
}

package test0908;
//一个变量的逆序输出
public class Converse {
public static void main(String[] args) {
	int val=54321;
	System.out.println("数字反转后为");
	
	while(val!=0) {
		int mod=val%10;
		
		System.out.print(mod);
		val/=10;
		
	}

}
}

数组反转

    int[] intArray = {
    
     1, 2, 3, 4, 5 };  
    ArrayUtils.reverse(intArray);  
    //[5, 4, 3, 2, 1]  
    System.out.println(Arrays.toString(intArray));  

合并数组

  int[] intArray = { 1, 2, 3, 4, 5 };  
    int[] intArray2 = { 6, 7, 8, 9, 10 };  
    // Apache Commons Lang 库  
    int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2); 

package homework0911;

import java.util.Arrays;

public class Test8 {
    public static void main(String[] args) {
    	int []a={7,12,4,9,6,3,9};
    	int[] b={2,6,3,54,2,56,21,33};
    	 int[]c= new int[a.length+b.length];
    	 /**
		 *c=Arrays.copyOf(a, a.length);//只能保存赋值数组的长度，否则数据丢失；
    	c=Arrays.copyOfRange(b, a.length, a.length+b.length );
    	System.out.println(Arrays.toString(c));
		 * */
    	 System.arraycopy(a, 0, c, 0, a.length);
    	 System.arraycopy(b, 0, c, a.length, b.length);
    	 //截取合并后记得输出
    	 System.out.println(Arrays.toString(c));
    	

	}
}

打印数组

 int[] intArray = { 1, 2, 3, 4, 5 };  
     
       
    // 直接打印,则会打印出引用对象的Hash值  
    // [I@7150bd4d  
    
    System.out.println( Arrays.toString(intArray));  

数组复制

System.arraycopy(a ,0 ,b ,0 ,8)这句话可以翻译为：把数组a从下标为0的位置依次开始复制到数组b下标为0的位置，复制长度为8。
使用时需要用CTRL+shift+O进行导包import java.util.Arrays;

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
函数原型：arraycopy（Object src, int srcPos, Object dest, int destPos, int length）

src: 原数组   srcPos:原数组起始的位置dest:目的数组 destPos:目的数组的起始位置

length：所需复制数组的长度

需要注意的是要重新声明一个同类型且长度足够的数组，否则会出现异常。

		int[] a= {3,456,4,3,2,45,5,65,35,6,5,5,43};
		int[] b=new int[8];
		b=Arrays.copyOf(a, 8);
		System.out.println(Arrays.toString(b));
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&


函数原型：copyOf(oringinal, int newlength)

oringinal:原数组      newlength:复制数组的长度

这个方法是从原数组的起始位置开始复制，复制的长度是newlength。相比较于前一种，这种相当于特殊的情况，只能从原数组的起始位置开始复制。

函数原型：copyOfRange(oringinal,int from, int to)

该方法是从original数组的下标from开始复制，到下标to结束

数组填充

array = new int[5];
Arrays.fill(array, 2);//填充相同的数
out.println(Arrays.toString(array)); //[2, 2, 2, 2, 2]
***************************************************
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
array = new int[5];
Arrays.fill(array, 1, 4, 2); //部分填充
out.println(Arrays.toString(array));//[0, 2, 2, 2, 0]

equals 与deepEuqals（或者toString/deepToString）

int[] array = new int[]{1, 2, 3};
out.println(Arrays.toString(array)); //[1, 2, 3]
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
*****************************************
//deep方法主要用于二位数组及以上，判断的是deepArray
int[][] deepArray = new int[][]{
   
   {1, 3},{2, 4}};
out.println(Arrays.toString(deepArray)); //[[I@1540e19d, [I@677327b6]
out.println(Arrays.deepToString(deepArray)); //[[1, 3], [2, 4]]

break和continue；一维二维数组的应用

package test0909;
/**
 *需求说明
有3名顾客去商场购物，每人买3件商品
商品单价300元以上的商品享受8折优惠
请统计每人享受打折优惠的商品的数量

 * */
import java.util.Scanner;
//有5家衣服专卖店，每家最多购买3件。用户可以选择离开，可以买衣服
//最后打印总共买了几件衣服
public class BreakAndDimensionalArrays {
    
    
   public static void main(String[] args) {
    
    
	   Scanner input = new Scanner(System.in);
		 String ans="";
		 int count=0;//全局变量购买衣服数
		 for (int i = 0; i < 5; i++) {
    
    
			 System.out.println("欢迎进入第"+(i+1)+"店购买物品");
			 int count2=0;//局部变量控制购买衣服的个数（单家店最多买三个）
			 
			 do {
    
    
	    	 System.out.println("要离开吗n/y");
	    	 ans=input.next();
	    	 if (!ans.equals("n")) {
    
    
				System.out.println("离店结账");
				break;//break跳出当前循环，进入下次循环的首句，不能用return，否则结束整个方法块，直接结束两个循环；
			}
	    	 if (ans.equals("n")) {
    
    
				count2++;
				count++;
				if (count2==3) {
    
    
					System.out.println("离店结账");
					break;
				}
			}
			
		} while (ans.equals("n"));
		}
	    System.out.println("您一共购买了"+count+"件商品");
}
}

package test0909;

import java.util.Scanner;

/**
 * 若有3个班级各4名学员参赛，计算每个班级参赛学员平均分，统计成绩大于85分学员数 使用continue统计大于85分的学员人数
 *
 */
public class ContinueAndTwoDimensionalArrays {
    
    
	public static void main(String[] args) {
    
    

		Scanner input = new Scanner(System.in);
		int[][] scores = new int[5][5];// 1.建立数组
		// 二维数组必须分配空间，子元素可选择输入或不输入
		// 第一个【】必须给数组长度，否则报错，第二个可以不给长度，因为，scoers[i]的子元素不一定一致，可以不一致；
		// 如果数组元素soces[i]子元素个数也相同,那样就可以给第二个括号也赋值；

		// 2.分析局部变量和全局变量；每个班平均分sum/5定性分析为局部；总人数全局；
		int count = 0;// 高于85分的全班人数；for循环内部声明每个班级的总分；

		for (int i = 0; i < scores.length; i++) {
    
    
			int sum = 0;// 每个班的平均成绩之和；
			System.out.println("请输入第" + (i + 1) + "个班同学的成绩");
			for (int j = 0; j < scores[i].length; j++) {
    
    
				System.out.println("请输入第" + (i + 1) + "个班第" + (j + 1) + "个同学的成绩");
				scores[i][j] = input.nextInt();
				sum += scores[i][j];
				if (scores[i][j] < 85) {
    
    

					continue;

				}
				count++;// 跳出内部循环，加速循环；
			}
			System.out.println("请输入第" + (i + 1) + "个班同学的平均成绩是" + sum / 5);
		}
		System.out.print(count);

	}
}

ArrayUtils工具类

// 1.打印数组
ArrayUtils.toString(newint[] { 1, 4, 2, 3 });// {1,4,2,3}
ArrayUtils.toString(new Integer[] { 1, 4, 2, 3 });// {1,4,2,3}
ArrayUtils.toString(null, "I'm nothing!");// I'm nothing!

// 2.判断两个数组是否相等,采用EqualsBuilder进行判断
// 只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True
// 2.1 两个数组完全相同
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newint[] { 1, 2, 3 });// true
// 2.2 数据类型以及长度相同,但各个Index上的数据不是一一对应
ArrayUtils.isEquals(newint[] { 1, 3, 2 }, newint[] { 1, 2, 3 });//true
// 2.3 数组的长度不一致
ArrayUtils.isEquals(newint[] { 1, 2, 3, 3 }, newint[] { 1, 2, 3 });//false
// 2.4 不同的数据类型
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, newlong[] { 1, 2, 3 });// false
ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false
// 2.5 Null处理,如果输入的两个数组都为null时候则返回true
ArrayUtils.isEquals(newint[] { 1, 2, 3 }, null);// false
ArrayUtils.isEquals(null, null);// true

// 3.将一个数组转换成Map
// 如果数组里是Entry则其Key与Value就是新Map的Key和Value,如果是Object[]则Object[0]为KeyObject[1]为Value
// 对于Object[]数组里的元素必须是instanceof Object[]或者Entry,即不支持基本数据类型数组
// 如:ArrayUtils.toMap(new Object[]{new int[]{1,2},new int[]{3,4}})会出异常
ArrayUtils.toMap(new Object[] { new Object[] { 1, 2 }, new Object[] { 3, 4 } });// {1=2,
// 3=4}
ArrayUtils.toMap(new Integer[][] { new Integer[] { 1, 2 }, new Integer[] { 3, 4 } });// {1=2,
// 3=4}

// 4.拷贝数组
ArrayUtils.clone(newint[] { 3, 2, 4 });// {3,2,4}

// 5.截取数组
ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5}
// 起始index为2(即第三个数据)结束index为4的数组
ArrayUtils.subarray(newint[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6}
// 如果endIndex大于数组的长度,则取beginIndex之后的所有数据

// 6.判断两个数组的长度是否相等
ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true

// 7.获得数组的长度
ArrayUtils.getLength(newlong[] { 1, 23, 3 });// 3

// 8.判段两个数组的类型是否相同
ArrayUtils.isSameType(newlong[] { 1, 3 }, newlong[] { 8, 5, 6 });// true
ArrayUtils.isSameType(newint[] { 1, 3 }, newlong[] { 8, 5, 6 });// false

// 9.数组反转
int[] array =newint[] { 1, 2, 5 };
ArrayUtils.reverse(array);// {5,2,1}

// 10.查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1
// 10.1 从正序开始搜索,搜到就返回当前的index否则返回-1
ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 6);// 2
ArrayUtils.indexOf(newint[] { 1, 3, 6 }, 2);// -1
// 10.2 从逆序开始搜索,搜到就返回当前的index否则返回-1
ArrayUtils.lastIndexOf(newint[] { 1, 3, 6 }, 6);// 2

// 11.查询某个Object是否在数组中
ArrayUtils.contains(newint[] { 3, 1, 2 }, 1);// true
// 对于Object数据是调用该Object.equals方法进行判断
ArrayUtils.contains(new Object[] { 3, 1, 2 }, 1L);// false

// 12.基本数据类型数组与外包型数据类型数组互转
ArrayUtils.toObject(newint[] { 1, 2 });// new Integer[]{Integer,Integer}
ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2}

// 13.判断数组是否为空(null和length=0的时候都为空)
ArrayUtils.isEmpty(newint[0]);// true
ArrayUtils.isEmpty(new Object[] { null });// false

// 14.合并两个数组
ArrayUtils.addAll(newint[] { 1, 3, 5 }, newint[] { 2, 4 });// {1,3,5,2,4}

// 15.添加一个数据到数组
ArrayUtils.add(newint[] { 1, 3, 5 }, 4);// {1,3,5,4}

// 16.删除数组中某个位置上的数据
ArrayUtils.remove(newint[] { 1, 3, 5 }, 1);// {1,5}

// 17.删除数组中某个对象(从正序开始搜索,删除第一个)
ArrayUtils.removeElement(newint[] { 1, 3, 5 }, 3);// {1,5}

附录Java关键字

关键字属于保留字，在 Java 中具有特殊的含义，比如说 public、final、static、new 等等，它们不能用来作为变量名。为了便于你作为参照，我列举了 48 个常用的关键字，你可以瞅一瞅。

1. **abstract：** abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。

2. **boolean：** boolean 关键字用于将变量声明为布尔值类型，它只有 true 和 false 两个值。

3. **break：** break 关键字用于中断循环或 switch 语句。

4. **byte：** byte 关键字用于声明一个可以容纳 8 个比特的变量。

5. **case：** case 关键字用于在 switch 语句中标记条件的值。

6. **catch：** catch 关键字用于捕获 try 语句中的异常。

7. **char：** char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。

8. **class：** class 关键字用于声明一个类。

9. **continue：** continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。

10. **default：** default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。

11. **do：** do 关键字通常和 while 关键字配合使用，do 后紧跟循环体。

12. **double：** double 关键字用于声明一个可以容纳 64 位浮点数的变量。

13. **else：** else 关键字用于指示 if 语句中的备用分支。

14. **enum：** enum（枚举）关键字用于定义一组固定的常量。

15. **extends：** extends 关键字用于指示一个类是从另一个类或接口继承的。

16. **final：** final 关键字用于指示该变量是不可更改的。

17. **finally：** finally 关键字和 `try-catch` 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。

18. **float：** float 关键字用于声明一个可以容纳 32 位浮点数的变量。

19. **for：** for 关键字用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。

20. **if：** if 关键字用于指定条件，如果条件为真，则执行对应代码。

21. **implements：** implements 关键字用于实现接口。

22. **import：** import 关键字用于导入对应的类或者接口。

23. **instanceof：** instanceof 关键字用于判断对象是否属于某个类型（class）。

24. **int：** int 关键字用于声明一个可以容纳 32 位带符号的整数变量。

25. **interface：** interface 关键字用于声明接口——只能具有抽象方法。

26. **long：** long 关键字用于声明一个可以容纳 64 位整数的变量。

27. **native：** native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。

28. **new：** new 关键字用于创建一个新的对象。

29. **null：** 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。

30. **package：** package 关键字用于声明类所在的包。

31. **private：** private 关键字是一个访问修饰符，表示方法或变量只对当前类可见。

32. **protected：** protected 关键字也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。

33. **public：** public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。`main()` 方法必须声明为 public。

34. **return：** return 关键字用于在代码执行完成后返回（一个值）。

35. **short：** short 关键字用于声明一个可以容纳 16 位整数的变量。

36. **static：** static 关键字表示该变量或方法是静态变量或静态方法。

37. ###### **strictfp：** strictfp 关键字并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。

38. **super：** super 关键字可用于调用父类的方法或者变量。

39. **switch：** switch 关键字通常用于三个（以上）的条件判断。

40. **synchronized：** synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。

41. **this：** this 关键字可用于在方法或构造函数中引用当前对象。

42. **throw：** throw 关键字主动抛出异常。

43. **throws：** throws 关键字用于声明异常。

44. **transient：** transient 关键字在序列化的使用用到，它修饰的字段不会被序列化。

45. **try：** try 关键字用于包裹要捕获异常的代码块。

46. **void：** void 关键字用于指定方法没有返回值。

47. **volatile：** volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

48. **while：** 如果循环次数不固定，建议使用 while 循环。