Java小白入门总结
-
static final double PI=3.14;//使用常量时记得声明变量类型和变量名大写；
-
进制 二进制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 -
-
养成良好习惯，shift+ctrl+F对eclipse的代码进行格式化，换行用tap健和上下左右键【尽量避免反复空格】，养成建包的好习惯。
-
笔记本程序开发四步走；(建立工程；手动编写Java文件；javac命令将Java文件编译为.class字节码文件；java命令运行字节码文件)
-
集成开发环境是指程序开发环境和程序调试环境在一起；main方法不是关键字，main()方法是Java程序的入口点；main()方法的四要素包含public,static ,String[]args,void四要素都是关键字
-
String不是关键字，是个final类。short不常用也是八大基本类型之一，String不在包含内。
-
变量名不可以用大写字母，数字，开头；可以用$下划线开头；变量名称中不可以包含%#等特殊字符；[Java标识符不一定是变量，可以首字母大写，例如类名，工程名]标识符：
-
Boolean是1位 ，
-
typora
位置英文模式下esc键下面 的数字；三个和语言类型可以建立特定语言的代码块；ctrl+w关闭文档 ；ctrl+shift+esc打开任务管理器；ctrl+shift+delete进行电脑强制重启 -
JAVA Error occurred during initialization of VM
在VM初始化期间发生JAVA错误
虚拟机内存不够，可能是因为控制台的小红方格子一直没有关闭，因为手动的所以必须要关闭
-
switch 结构必须要有switch和case；不一定要有default和break，贯穿性！判断条件类型有
byte，short ,int ,String ,enum ,char,不包含float，double；
-
随机数强制转换： 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 -
for循环 初始化（迭代变量）；循环条件；循环体；迭代部分【后进行判断是否再次进入循环条件，循环体】
-
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); } } -
使用数组原因：当用变量存储数据时，存储大量数据不能满足需求，所以需要用到数组，但必须保证变量类型相同；使用循环原因是许多相似代码冗余，；
-
三个数或两个数要求换位置从小到大顺序，借助中间量temp进行交换；实现数字反转while（while num!=0）{int mod=num%10//个位上的余数；十位到万位的数字依次 num/=10;}顺序输出mod就可以了；
-
continue本次循环跳过，比如求不含七的倍数一定范围的数；
-
有百分号时求比例必须先乘后除--------------比例为"+count*100/4+"%"
-
旧数组中剔除元素后获得新数组，先遍历旧数组元素，判断新数组元素个数（新数组长度），剔除元素符合条件的开始计数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();
}
}
}
用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] 需要用到break；for循环中i>=index,否则输入相同数值时会出现覆盖情况 1给插入值下标初始化等于数组长度； 2获得index//升序时nums[i]>input;降序时nums[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;
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");
}
}
}
插入值（升序，降序）到数组中
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]判断是否包含某数
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]//求最大值及下标
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]平均值
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数组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 循环。