Java的语法结构和数组
在此之前我们学习了Java的开发，了解了Java的一些基础知识，现在让我们一起来探讨一下Java语言的选择结构、循环结构、数组以及二重循环。
一、选择结构
选择结构就是根据判断结果决定是否做一件事情。为了更方便看懂程序的执行顺序、解决问题的步骤和方法，我们通常会利用画流程图来表示程序。如：圆角矩形表示程序的开始和结束；长方形表示计算步骤和处理符号；平行四边形表示输入、输出指令；菱形表示判断和分支；直线表示流程线，也就是程序的执行方向。在下文将会有实图进行展示。
if选择结构
if选择结构的分类：
1、基本if选择结构
基本if选择结构可以处理单一或组合条件的情况。语法：
if（条件）{ //判断if后面小括号里的条件是否成立
//代码块 （条件成立后执行的代码，可以是一条语句，也可以是一组语句）
}
流程图为：
如图所示，程序执行时，先判断条件，如果条件为真，就执行大括号里的代码块，如果为假，就执行if结构后面的代码。当if关键字后面的一对大括号里只有一个语句时，可以省略大括号，但是为了避免有多个语句时遗忘大括号，建议还是不要省略if结构块的大括号。现在我们就来编写一下代码，例如：我们从键盘上输入张浩的成绩后，通过判断得知是否大于98分，若大于98，则会输出：老师说：“不错，奖励一个MP4！”，否则什么也不输出。
import java.util.Scanner; //导包
public class Get{ //定义一个class类，文件名为Get的Java文件
public static void main(String[] args){
Scanner in = new Scanner(System.in);
//设置从控制台输入
System.out.print("输入张浩的Java成绩：");
//输出提示信息，提醒用户输入成绩
int score = in.nextInt();
//输入成绩保存到int型的变量score中
if(score > 98){
//判断score变量的成绩是否大于98
System.out.println("老师说：不错，奖励一个MP4！");
//如果条件成立，执行大括号里的代码块，否则，无输出
}
}
}
运行结果为：
从上图我们可以知道，当我们输入100时，成绩大于98，所以有输出，但是当我们输入69时，小于98，所以无输出 。
当我们需要同时满足多个条件时，怎么表示呢？对的，就是应用我们的逻辑运算符：与（&&）、或（||）、非（！）。逻辑与表示两个条件需要同时满足，逻辑或表示多个条件只需要满足一个就可以了。逻辑非就是取反，当值为真时，取反后就为假，当值为假时，取反后就为真。例如：张浩的成绩要大于60分并且小于100分，可以写成：if （ (score > 60) && (score < 100) ） 当运算符较多，无法确定运算符执行的顺序时，可以使用小括号控制。
2、if—else选择结构
if—else选择结构与上面的if选择结构不同的是，除了要实现条件成立执行的操作以外，还要实现条件不成立时执行的操作。它可以处理简单的条件分支情况，这种形式结构简单，但在实际开发中使用非常频繁。语法为：
if（条件）{ //判断条件是否成立
//代码块1 （如果条件成立，就执行此行代码块）
}else{ //否则，是if的反例
//代码块2 （如果条件不成立，就执行此代码块）
}
它所表示的意思是：如果XX，就XX，否则，就XX。我们还是利用上面的那个示例，如果张浩的成绩大于98分，就输出：老师说：“不错，奖励一个MP4！”，否则就输出：老师说：”惩罚进行编码！“ 代码程序如下：
public class SimpleIf2{ //创建一个名为SimpleIf2的Java文件
public static void main(String[] args){
int score = 91;
//声明一个int型变量score保存张浩的成绩
if(score > 98){
//判断score变量的数值是否大于98
System.out.println("老师说：不错，奖励一个MP4！");
//如果条件成立，就输出：老师说：不错，奖励一个MP4！
}else{
System.out.println("老师说：惩罚进行编码！");
//否则，如果条件不成立，就输出：老师说：惩罚进行编码！
}
}
}
运行结果为：
因为在代码程序中我们已经定义了张浩的成绩为91分，所以运行时就直接输出else语句的代码块了。此代码的流程图如下所示：
下面我们来读一下流程图：开始执行程序，然后定义一个inn类型的变量score并把91赋给它，用if判断score的值是否大于98，91不大于98，条件不成立为假，所以不执行if后面大括号里的代码块，直接执行else语句后面的代码，输出：老师说：”惩罚进行编码！“ 然后结束程序。记住if—else选择结构和if选择结构最大的区别就是：基本的if选择结构，只有一个if块；if—else选择结构，有if块和else块。
3、多重if选择结构
多重if选择结构可以处理复杂的条件分支情况，它在解决需要判断的条件是连续的区间时有很大的优势。多重if选择结构不是多个基本if选择结构简单的排列在一起，它的具体语法如下：
if（条件1）{ //判断条件1是否为true
//代码块1 （如果条件1为真，就执行代码块1，以下代码块不执行）
}else if（条件2）{ //否则，如果条件1不成立，就判断条件2是否满足
//代码块2 （如果条件1为false，条件2为true，就执行代码块2，代码块1和代码块3都不执行）
}else{
//代码块3 （否则，如果条件1和条件2都为false，就执行代码块3）
}
流程图为：
多重if选择结构到底如何执行呢？如图所示，首先，程序判断条件1，如果成立，则执行代码块1，然后直接跳出这个多重if选择结构，执行它后面的代码。这种情况下，代码块2和代码块3都不会被执行。如果条件1不成立，则判断条件2。如果条件2成立，则执行代码块2，然后跳出这个多重if选择结构，执行它后面的代码。这种情况下，代码块1和代码块3都不会被执行。如果条件2也不成立，则代码块1和代码块2都不执行，直接执行代码块3。其中，else if块可以有多个或没有，需要几个else if块完全取决于需要；else块最多有一个或没有，且必须要放在else if块之后。
如果条件之间存在连续关系，则else if块的顺序不是随意排列的，要么从小到大，要么从大到小，总之要有顺序的排列。如果所有条件之间只是简单的互斥，不存在连续的关系，则条件没有顺序要求。
例如：输出考试成绩的等级，代码如下所示：
public class ScoreAssess{ //创建一个名为ScoreAssess的Java文件
public static void main(String[] args){
int score=70;
//声明一个int型变量score保存要判断的成绩的分数
if(score>=80){
//判断条件1是否成立，即变量score是否大于等于80
System.out.println("良好"); //如果score大于或等于80，就输出：良好
}else if(score>=60){
//否则，如果条件1不成立，就判断条件2，即score是否大于等于60
System.out.println("中等"); //如果score大于等于60，就输出：中等
}else{
System.out.println("差");
//否则，如果条件都不成立执行上一行代码块，输出“差”
}
}
}
运行结果为：
4、嵌套if选择结构
嵌套if选择结构就是在if选择结构里面再包含一个或多个if选择结构的情况，这种结构一般用于较为复杂的流程控制中，if选择结构嵌套的形式很多，以下形式是它的基本结构：
if（条件1）{ //判断条件1是否满足
if（条件2）{ //如果条件1满足，就判断条件2是否为true
// 代码块1 （如果条件1和条件2都为true，执行代码块1）
}else{ //否则，如果条件1满足，但是条件2不成立，就输出代码块2
// 代码块2
}
}else{ //否则，如果条件1不成立，就进入这里
if（条件3）{ //如果条件1不成立，判断条件3是否成立
//代码块3 （如果条件3成立就输出代码块3）
}else{ //否则，如果条件3也不成立，就执行代码块4
//代码块4
}
}
它的流程图为：
注意只有当满足外层if选择结构的条件时，才会判断内层的循环条件。例如：学校举行运动会，百米赛跑成绩在10秒以内的学生有资格进决赛，根据性别分为男子组和女子组。代码示例如下：
import java.util.*; //导包
public class RunningMatch{ //创建一个名为RunningMatch的Java文件
public static void main(String[] args){
Scanner input = ew Scanner(System.in); //设置从控制台输入
System.out.println("请输入比赛成绩(s)："); //输出提示语句，提示用户输入成绩
double score = input.nextDouble(); //从键盘输入比赛成绩保存在double型变量score中
System.out.println("请输入性别："); //输出提示语句，提醒用户输入性别
String sex = input.next(); //从键盘输入性别保存在变量sex中
if(score <= 10){ //判断比赛成绩是否小于等于10秒
if(sex.equals("男")){ //如果成绩小于等于10秒，就判断是否是男生
System.out.println("进入男子组决赛！"); //如果是男生，就输出此代码块内容
}else if(sex.equals("女")){ //如果成绩小于等于10秒，但不是男生，就判断是否是女生
System.out.println("进入女子组决赛！"); //如果是女生，就输出：进入女子组决赛！
}
}else{ //如果成绩大于10秒就输出淘汰
System.out.println("淘汰！");
}
}
}
运行结果为：
5、switch选择结构
switch选择结构可以更好的解决多重分支并且条件判断是等值判断的问题，也就是说，switch选择结构只能用于判断一个整型变量或表达式是否等于某个整数值的情况，或者一个字符型变量或表达式是否等于某个字符的情况，并且每一个case后面的常量值都不同。而前面说到的多重if选择结构既可以用于判断条件是等值的情况，也可以用于判断条件是区间的情况。语法如下：
switch（表达式）{ //先计算出switch后面小括号里表达式的值，然后和每个case后面的常量做比较
case 常量1： //如果表达式的值等于常量1，就执行代码块1
//代码块1；
break； //执行完代码块1后就停止switch程序的执行，跳到switch {}后面的程序
case 常量2： //如果表达式的值等于常量2，就执行代码块2
//代码块2；
break； //执行完代码块2后就停止switch程序的执行，跳到switch {}后面的程序
case 常量3： //如果表达式的值等于常量3，就执行代码块3
//代码块3；
break； //执行完代码块3后就停止switch程序的执行，跳到switch {}后面的程序
……
default： //如果已经和所有case后面的常量作比较，并且没有找到相匹配的，就执行default语句
//代码块n； //输出代码块n
break； //结束switch
}
switch选择结构关键字：switch、case、default、break
（1）switch表示”开关“，这个开关就是switch关键字后面小括号里表达式的值。switch小括号里可以是int、short、byte、char、枚举类型、String类型表达式。
（2）case后面可以是int、short、byte、char、枚举类型、String类型，通常是一个固定值，case块可以有多个，且不需要用”{}“括起来，顺序可以改变，但是每个case块后的常量必须各不相同。
（3）default表示”默认“，当其他情况都不满足时执行，它可以和case块交换顺序，也可以省略。
（4）break表示”停止“，即跳出当前结构，也可以省略，但是省略后可能会带来一些问题；因为当某个case后的常量值与switch的表达式的值相等时，执行该case块的代码，后面的case就不再进行条件判断，而直接执行后面所有case块中的代码，直到遇到break结束。
例如：在下面的代码中，当变量day的值为1、3、5时，都将输出”奇数！“；当变量day的值为2、4、6时，都将输出”偶数！“。
int num = 3; //定义一个int型的变量num，并赋初值3
switch(num){ //将3与所有case后面的常量作比较
case 1: //3不等于1，不执行
case 3: //3等于3，执行
case 5: //由于case 3 没有break停止语句，所以继续执行下去
System.out.println("奇数！");
//当num等于1、3、5时都会执行到这里，因为case 1和case 3没有break语句，输出：奇数
break; //停止switch
case 2:
case 4:
case 6:
System.out.println("偶数！");
//当num等于2、4、6时都会执行到这里，因为case 2和case 4没有break语句，输出：偶数
break; //停止switch
}
知道了switch选择结构的语法，那么我们来说说它的执行顺序。首先计算并获得switch后面小括号里的表达式或变量的值，然后将计算结果顺序与某每个case后的常量比较，当二者相等时，执行这个case块中的代码；当遇到break时，就跳出switch选择结构，执行switch选择结构之后的代码。如果没有任何一个case后面的常量与switch后的小括号中的值相等，则执行switch末尾部分的default块中的代码。
到此，大家会发现多重if选择结构和switch选择结构很相似，它们都是用来处理多分支条件的结构，但是switch选择结构只能用于等值条件判断的情况下。例如：小明同学参加计算机编程比赛，如果获得第一名，将参加麻省理工大学组织的一个月夏令；如果获得第二名，将奖励惠普笔记本电脑一部：如果获得第三名，将奖励移动硬盘一个；否则，没有任何奖励。代码如下：
public class Compete2 { //创建一个名为Compete2的Java文件
public static void main(String[] args) {
int mingCi = 1; //声明了一个int型变量mingCi保存小明同学的名次，我们给定他的成绩为第一名
switch(mingCi) { 把1放到表达式里，与所有case后的常量作比较
case 1: //1等于1，变量mingci成功与case 1匹配，执行后续代码块
System.out.println("参加麻省理工大学组织的1个月夏令营");
//输出"参加麻省理工大学组织的1个月夏令营"
break; //遇到break结束，执行switch的{}后面的代码
case 2: //如果mingCi等于2，就执行下一行代码块
System.out.println("奖励惠普笔记本电脑一部");
break;
case 3: //如果mingCi等于3，就执行下一行代码块
System.out.println("奖励移动硬盘一个");
break;
default: //如果名次不是第一、第二，也不是第三，就执行这里的代码块
System.out.println("没有任何奖励");
}
}
}
以上代码块输出结果是：参加麻省理工大学组织的1个月夏令营
二、循环结构
条件只需要问一次的是选择结构，条件反反复复的问是否满足的是循环结构。说白了，循环结构就是重复的做，比如打印50份试卷、做100道编程题、滚动的车轮等。其实，循环并不是无休止进行的，满足一定条件时循环才会继续，称为”循环条件“；循环条件不满足的时候，循环退出；其次，循环结构是反复进行相同的或类似的一系列操作，称为”循环操作“。循环结构又分为三类：while循环结构、do—while循环结构和for循环结构，接下来，让我们一起来了解一下它们吧！
while循环结构
while循环结构和基本的if选择结构相似，只不过一个是选择结构，一个是循环结构。它的语法是：
while(循环条件){ //判断循环条件是否为真
//循环操作 如果循环条件为真，就执行循环操作，否则无执行
}
流程图为：
关键字后面小括号中的内容是循环条件，循环条件是一个表达式，它的值为Boolean类型，即true或false，如：i< 100;{}中的语句统称为循环操作，又称为循环体。执行顺序为：
（1）声明并初始化变量；
（2）判断循环条件是否满足，满足则执行循环操作，否则退出循环；
（3）执行完操作后，再次判断循环条件，决定是否继续循环。
实际上，while循环结构如果第一次判断循环结构就不满足，则会直接跳出循环，循环操作一遍都不会执行。这是while循环结构的一个特点：先判断，后执行。
下面使用while循环结构实现打印50份试卷。代码块为：
public class Print {
public static void main(String[] args) {
int count = 1; //声明一个int型变量count保存试卷的开始份数，从第一份开始，所以赋初值1
while(count <= 50) { //判断count是否小于等于50
System.out.println("打印第"+count+"份试卷"); //输出打印试卷的份数
count++; // 迭代部分，打印完这份，就跳到下一份试卷
}
}
}
运行后，控制台会输出50次：打印第" ？"份试卷；每次份数都会加1。
使用while循环结构解决问题时，一定要注意检查循环能否退出，避免出现”死循环“的现象。
do—while循环结构
do—while循环结构和while循环结构最大的区别就是：do—while循环结构无论如何都会执行一次，再判断条件，决定是否继续执行。它的语法为：
do{
//循环操作 （无论如何，循环操作都会执行一次）
}while(循环条件); //判断条件是否为真，为真就继续执行循环操作，否则结束循环
它的流程图为：
使用do—while循环结构解决问题的步骤是：
（1）分析循环条件和循环操作；
（2）套用do—while语法写出代码；
（3）检查循环能否退出。
记住，while后面的分号是必须要的，千万不能忘记，否则程序就会出错。下面我们就来使用do—while循环结构编写一个程序，例如：从键盘输入上机是否合格，如果合格就通过测试，否则继续写编程。代码如下：
import java.util.Scanner; //导包
public class DoWhileDemo { //创建一个名为DoWhileDemo的Java文件
public static void main(String[] args) {
Scanner input = new Scanner(System.in); //设置从控制台输入
String answer = ""; //声明一个String类型的变量answer
do {
System.out.println("上机编写程序！"); //输出语句
System.out.print("合格了吗？（y/n）"); //提示用户输入字符
answer = input.next(); //从键盘输入是否合格，输入 y 或 n，保存在变量answer中
System.out.println(""); //输出空格
}while(!"y".equals(answer)); //判断answer是否等于字符 y ，决定循环是否继续
System.out.println("恭喜你通过了测试！"); //当循环结束时，输出此语句
}
}
学习了while和do—while两种循环结构，那么它们到底有什么不同呢？
（1）语法不同；
（2）执行顺序不同；
（3）在一开始条件就不满足的情况下，while循环结构一次都不会执行，do—while循环结构则会执行一次。
for循环结构
在解决有固定循环次数的问题时，可以首选for循环结构。它的语法是：
for(初始值部分；条件判断部分；迭代部分){ //先执行初始值部分，然后判断条件，如果条件为true，就执行循环体，再到迭代部分，然后继续判断条件，如果条件为假，就结束循环
//循环体
}
for循环结构的初始值部分，主要是设置循环的初始状态；条件判断部分就是判断循环是否继续的条件；循环体是满足条件后重复执行的代码块，可以是多条语句也可以是一条；迭代部分是下一次循环开始前要执行的部分。for关键字后面括号中的三个表达式必须用”；“隔开；它的执行顺序为：
（1）初始值部分；
（2）判断条件；
（3）如果条件为真，就执行循环体，如果为假，就退出循环，后面的步骤不执行；
（4）迭代部分；
（5）依次重复（2）~（4）的操作，直到退出for循环。
可见，初始值部分是只执行一次的；并且for关键字的三个表达式都是可以省略的，但是分号不能省，如：for（ ；；）；虽然这个语句在语法上没有错误，但是逻辑上是错误的；所以为了提高代码的可读性，尽量不要省略各个表达式，如果需要省略，可以考虑是否改用while或do—while循环结构。
例如：输入一个任意数，根据这个值输出加法表。代码如下：
import java.util.Scanner; //导包
public class SumTable { //创建一个名为SumTable的Java文件，编写代码
public static void main(String[] args) {
int i,j; //定义两个int型变量i和j，用来保存两个加数
Scanner in = new Scanner(System.in); //设置从控制台输入
System.out.print("请输入一个值："); //输出提示语句
int val = in.nextInt(); //从键盘输入一个数
System.out.println("根据这个值可以输出以下加法表：");
for(i = 0,j = val;i <= val;i++,j--) { //利用循环，实现我们想要的效果
System.out.println(i + "+" + j + "=" + (i+j)); //输出 加数+加数=和（键盘输入的数）
}
}
}
假设我们从键盘输入6，则得到以下内容：
跳转语句
通过对循环结构的学习，我们已经了解到在执行循环时需要判断条件，但是有时我们需要停止整个循环或者跳到下一次循环，有时需要从程序的一部分跳到程序的其他部分，这些都可以用跳转语句来完成。Java支持三种形式的跳转：break、continue和return；下面我们来了解一下前两种。
break语句
在switch选择结构中，我们已经了解了一些关于break语句的知识，break语句用于终止switch语句中的某个分支，使程序跳到switch选择结构的下一条语句。那么在循环结构中，break又有什么作用呢？
break语句用于终止某个循环，使程序跳到循环体外的下一条语句，在循环 中位于break后的语句将不再执行，循环也停止执行。break语句不仅可以用在for循环结构中，也可以用在while和do—while循环结构中，break语句通常与if条件语句一起使用。如：
for(int i = 0;i < 10;i++){ //定义一个int型变量i，并赋初值0，判断i是否小于10，执行完循环体后，i加1
//跑400米
if(不能坚持){ //如果不能坚持，就执行if小括号后面大括号里的代码块
break; //退出比赛
}
}
这个代码的意思是：假设某个同学参加4000米长跑比赛，每圈400米，每跑一圈，他都在心里问自己：”我还有力气坚持到最后吗？“如果回答”是“就继续下一圈，如果回答”否“，就退出。
continue语句
当我们想要在某次循环中，不执行完所有的循环体，就跳出本次循环，开始执行下一次循环时，我们可以借助continue语句实现。
如：求1~100之间个位数字不是2、3、4、7，并且不能被3整除的整数之和。代码如下所示：
public class ContinueDemo2 { //创建一个名为ContinueDemo2 的Java文件
public static void main(String[] args) {
int sum = 0; //声明一个int型保存整数和的变量sum并赋初值0
for(int i = 1;i <= 100;i++) { //声明变量i并定义了i的范围为1~100，执行完循环体后，i加1
if(i % 10 == 2 || i % 10 == 3 || i % 10 == 4 || i % 10 == 7 || i % 10 == 0) {
continue;
//如果满足if里的任何一个条件，就执行continue语句，跳过后面累加的语句，进入下一循环
}
sum = sum + i; //如果i的值不满足上述if里的任何一个条件，就执行累加的操作
}
System.out.println("1~100之间个位数不是2、3、4、7，" + "并且不能被3整除的整数和是：" + sum); //输出1~100之间个位数不是2、3、4、7，并且不能被3整除的整数和
}
}
运行结果为：1~100之间个位数不是2、3、4、7，" + "并且不能被3整除的整数和是：2540
continue语句可以用在for循环结构中，也可以用在while和do—while循环结构中，简单来说，它主要用于跳出本次循环，进入下一循环。
现在我们已经学习了选择结构和循环结构，下面让我们来练习一下吧！例题：给定录入用户的数量，循环录入用户的信息，包括用户编号、年龄、积分，要求用户必须满10周岁以上，若年龄合法则显示录入信息，否则显示录入信息失败。代码块如下:
import java.util.Scanner; //导包
public class Inform {
public static void main(String[] args) {
Scanner in = new Scanner(System.in); //设置从控制台输入
System.out.println("青鸟迷你游戏平台 > 添加用户信息 \n"); //输出
System.out.println("请输入要录入的用户数量："); //输出
int num = in.nextInt(); //从键盘输入一个整数
for(int i = 0;i < num;i++) { //循环输入num位用户的信息
System.out.print("请输入用户编号(<4位整数>)："); //输出提示语
int name = in.nextInt(); //输入用户的编号
System.out.print("请输入用户年龄："); //输出提示语
int age = in.nextInt(); //输入用户年龄
if(age >= 10) { //判断年龄是否大于等于10
System.out.print("请输入会员积分："); //如果年龄大于等于10，就输出此提示语
int score = in.nextInt(); //输入积分
System.out.println("您录入的会员信息是：");
System.out.println("用户编号：" + name + "\t 年龄：" + age + "\t 积分：" + score +"\n"); // 输出录入的用户信息
}else {
System.out.println("很抱歉，您的年龄不适宜玩游戏"); ///年龄小于10时，输出
System.out.println("录入信息失败！\n");
}
}
System.out.println("录入完成！"); //循环结束时，输出
}
}
下面我们就来运行一下：
三、数组
在Java中，数组就是一个变量，用于将相同数据类型的数据存储在内存中，所以数组中的每一个数据元素都属于同一数据类型。
数组的基本要素：
（1）标识符；就是数组的名称，用于区分不同的数组；
（2）数组元素；当给出了数组名称，要向数组中存放数据，这些数据就称为数组元素；
（3）数组下标；在数组中，为了正确得到数组的元素，需要对它们进行编号，这样才能更方便存取，这个编号就是数组下标，数组下标从0开始，数组长度减1，就是数组最大的下标；
（4）元素类型；相当于数据类型。
数组的大小是数组可容纳元素的最大数量，如果数组已满但是还继续向数组中存储数据的话，程序就会出错，这称为数组越界。
使用数组的步骤：
（1）声明数组
数据类型[] 数组名； 如：int[] num;
或： 数据类型 数组名[]； 如：int num[];
数组名可以是任意合法的变量名，声明数组就是定义数组的数据类型。
（2）分配空间
数组名 = new 数据类型[数组长度]； 如：score = new int[10];
或： 数据类型[] 数组名 = new 数据类型[数组长度]； 如： int[] score = new int[10];
其中，数组长度就是数组中能存放的元素个数，显然应该为大于0的整数;一旦声明了数组的大小就不能再修改，即数组的长度是固定的。
（3）赋值
数组名[下标值]； 如： score[3] = 10;
分配空间后，就可以向数组里存放数据了，数组中的每一个元素都是通过下标来访问的。不过，为了更节省时间，也为了代码更简洁，我们也可以将声明数组、分配空间和赋值合并完成，如：
数据类型[] 数组名 = {值1，值2，值3，……，值n}； 如：int[] score = {10,20,30,40};
当数组的元素比较多而我们又想知道它的长度时，可以用 数组名.length 求出数组的长度，如：a = num.length,表示将数组num的长度赋给a。
接下来我们就来了解一下数组的代码，例如：从键盘输入5位学员的成绩，计算他们的平均分并输出。代码如下：
import java.util.Scanner; //导包
public class ArrayDemo { //创建一个名为ArrayDemo的Java文件
public static void main(String[] args) {
Scanner in = new Scanner(System.in); //设置从控制台输入
int[] scores = new int[5]; //声明一个长度为5的int类型的数组scores
int sum = 0; //定义一个int型的变量sum，并赋初值0
System.out.println("请输入5位学员的成绩："); //输出提示语
for(int i = 0;i < scores.length;i++) { //循环输入数组里的每个值
scores[i] = in.nextInt();
sum = sum + scores[i]; //累加5位学员的成绩
}
System.out.println("学员的平均分是：" + (double) sum / scores.length);
// 计算5位学员的平均分并输出
}
}
数组排序
有时候我们保存在数组中的数据是无序的，这时候我们就需要排序，让我们的数组里的数据看起来更美观，也让我们更容易了解这组数据的范围、最大值、最小值等。
排序的语法是：Arrays.sort（数组名）；
只要我们把数组名放在sort方法的括号里，该方法执行后，数组中的数据就会按升序排好。如果我们要使用arrays排序，我们就需要先导包；如：
import java.util.Arrays; //导包
import java.util.Scanner;
public class ScoreSort {
public static void main(String[] args) {
int[] scores = new int[5]; //声明一个长度为5的int型数组scores
Scanner in = new Scanner(System.in); //设置从控制台输入
System.out.println("请输入5位学员的成绩："); //输出提示语
for(int i = 0;i < scores.length;i++) { //循环输入数组里的值
scores[i] = in.nextInt();
}
Arrays.sort(scores); //数据按升序排序
System.out.println("学员成绩按升序排列：");
for(int i = 0;i < scores.length;i++) { //循环逆序输出数组
System.out.print(scores[i] + " "); //按降序输出数组
}
}
}
现在来运行一把：
求数组最大值、最小值
像上面所说，当我们录入学员成绩时，老师都会想看看最高分和最低分，所以我们就需要求最大值和最小值。如：
max = scores[0]; //定义一个max变量保存最大值，并把数组中任一值赋给它
for(int i = 1;i < scores.length;i++) {
if(scores[i] > max) { //循环比较两个变量的值，确保max的值是最大值
max = scores[i]; //如果max的值比scores[i]里的值小，就把scores[i]的值赋给max
}
}
System.out.println("考试成绩最高分为：" + max); //输出
上面的是求最大值，下面就看看求最小值：
min = scores[0]; //定义一个min变量保存最小值，并把数组中任一值赋给它
for(int i = 1;i < scores.length;i++) {
if(scores[i] < min) { //循环比较两个变量的值，确保min的值是最小值
min = scores[i]; //如果min的值比scores[i]里的值大，就把scores[i]的值赋给min
}
}
System.out.println("考试成绩最高分为：" + min); //输出
向数组插入元素
当我们想要增加一个学员的成绩怎么办呢？对的，就是利用插空法，先输入要插入的数据，然后从数组的第一个元素开始与新增的成绩进行比较，直到找到要插入的位置，找到要插入的位置后，将该位置后的元素后移一个位置，最后将新增的成绩信息插入该位置即可。如：
int[] list = new int[6]; // 定义一个长度为6的int类型数组list
list[0] = 99;
list[1] = 85;
list[2] = 82;
list[3] = 63;
list[4] = 60;
// 给数组赋初值
int index = list.length; //将数组长度赋给index
System.out.println("请输入新增成绩："); //输出提示语
int num = in.nextInt(); //输入新增成绩
for(int i = 0;i < list.length;i++) { //循环比较
if(num > list[i]) { //找到要插入的位置
index = i; //将要插入的位置的下标赋给index
break; //结束循环
}
}
for(int j = list.length-1;j > index;j--) { //循环将下标之后的数值往后移一位
list[j] = list[j-1]; //将要插入的位置后面的元素后移一个
}
list[index] = num; //将数据插入到数组中
四、二重循环结构
二重循环结构就是一个循环体内又包含另一个完整的循环结构，前面我们所学习到的while、do—while和for三种循环结构，都是可以互相嵌套的。在二重循环中，外层循环变量变化一次，内层循环变量要从初始值到结束值变化一遍。
while与while循环嵌套
前面我们了解了while循环结构，这里的while与while循环嵌套的大致与它相同，语法是：
while（循环条件1）{ //判断循环条件1是否满足
//循环操作1 //如果条件1成立，执行循环操作1
while（循环条件2）{ //如果循环条件1成立，就执行循环条件2
//循环操作2 //如果条件2也成立，就执行循环条件2
}
}
当循环条件1满足时，执行循环操作1，并判断循环条件2是否满足，如果条件2满足执行循环操作2，然后到循环条件2，决定是否继续循环内层循环，否则返回到条件1 决定是否继续循环。
do—while与do—while循环嵌套
do—while也是可以循环嵌套的，语法是：
do{
//循环操作1 （无论如何都执行一次循环操作1）
do{
//循环操作2 （无论如何都执行一次循环操作2）
}while（循环条件2）； //判断循环条件2是否满足，决定是否继续循环
}while（循环条件1）； //判断循环条件1是否满足，决定是否继续循环
前面我们学习了do—while循环结构，它是无论如何都会至少执行一次循环操作，而这里就是无论条件值为多少都会执行两次循环体。
for与for循环嵌套
for与for循环嵌套的语法是：
for（循环条件1）{ //执行循环条件1的初始值部分，判断条件是否成立
//循环操作1 //如果条件成立执行循环操作1，否则结束循环
for（循环条件2）{ //执行循环条件2的初始值部分，判断条件是否成立
//循环操作2 //如果成立执行循环操作2，否则跳到循环条件1的迭代部分
}
}
for与for的循环嵌套，执行过程和for循环差不多，只不过外层执行一次，内层要执行一轮。
while与for循环嵌套
前面说的循环嵌套都是本家嵌套，现在要说一下while与for循环嵌套，语法是：
while（循环条件1）{ //判断循环条件1是否满足
//循环操作1 （如果循环条件1满足，就执行循环操作1）
for（循环条件2）{ //执行循环条件2的初始值部分，判断条件是否满足
//循环操作2 （如果条件满足就执行循环操作2，否则返回到循环条件1，判断真假）
}
}
学习到这里，大家应该也都知道循环结构的执行套路了，基本上是要判断条件，条件为true就执行后面的循环操作，否则就退出循环。
前面我们学习了break语句和continue语句，在二重循环中也是可以运用这两个语句来帮助我们实现一些功能，但是在二重循环中，它们只对所在循环起作用，只会影响内存循环的执行，对外层循环没有影响。当break、continue语句在内层循环时，它只会退出、跳过内层循环，却不会影响外层循环。
环体。
for与for循环嵌套
for与for循环嵌套的语法是：
for（循环条件1）{ //执行循环条件1的初始值部分，判断条件是否成立
//循环操作1 //如果条件成立执行循环操作1，否则结束循环
for（循环条件2）{ //执行循环条件2的初始值部分，判断条件是否成立
//循环操作2 //如果成立执行循环操作2，否则跳到循环条件1的迭代部分
}
}
for与for的循环嵌套，执行过程和for循环差不多，只不过外层执行一次，内层要执行一轮。
while与for循环嵌套
前面说的循环嵌套都是本家嵌套，现在要说一下while与for循环嵌套，语法是：
while（循环条件1）{ //判断循环条件1是否满足
//循环操作1 （如果循环条件1满足，就执行循环操作1）
for（循环条件2）{ //执行循环条件2的初始值部分，判断条件是否满足
//循环操作2 （如果条件满足就执行循环操作2，否则返回到循环条件1，判断真假）
}
}
学习到这里，大家应该也都知道循环结构的执行套路了，基本上是要判断条件，条件为true就执行后面的循环操作，否则就退出循环。
前面我们学习了break语句和continue语句，在二重循环中也是可以运用这两个语句来帮助我们实现一些功能，但是在二重循环中，它们只对所在循环起作用，只会影响内存循环的执行，对外层循环没有影响。当break、continue语句在内层循环时，它只会退出、跳过内层循环，却不会影响外层循环。
Java世界多姿多彩，虽然代码块有点枯燥，但是仔细品尝它的奥妙，却又是如此甜美！
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
