Java编程语言

选择结构

一、选择结构

①简单if选择结构

主要解决只有一种结果的问题，如果(条件),那么(结果)，条件不管它是什么，算出来的结果一定是true/false。

若条件为真，则输出代码块，反之。

语法：if(条件){
//代码块
}

例如:

public class Test{
    public static void main(String [] args){
        int scores = 90;
        if(scores > 85){
            System.out.print("奖励一个Mp3"); //90>85成立,会输出代码块
        }
    }
}

②if-else结构

主要解决只有两种可能结果的问题

语法: if(条件){
//条件成立时语句
}else{
//条件不成立时语句
}

例如:

public class Test{
    public static void main(String [] args){
        int scores =80;
        if(scores>90){
               System.out.print("奖励一个Mp3");
        }else{
               System.out.print("惩罚进行编码!"); //80>90不成立,则输出else括号里的代码块
        }
    }
}

③多重if选择结构

主要解决有多种可能结果的问题，永远只执行其中一个分支。

语法: if(条件1){
//条件1成立时语句
}else if(条件2){
//条件2成立时语句
}else if(条件3){
//条件3成立时语句
}else{
//条件1,2,3都不成立时语句
}

注意:else块最多有一个或没有,else块必须要放在else if块之后！！

例如:

public class Test{
    public static void main(String [] args){
        int scores =85;
        if(scores>98){
             System.out.print("奖励一个Mp3");
        }else if(scores>80){
             System.out.print("奖励本子一个");
        }else if(scores>60){
             System.out.print("惩罚进行编码");
        }else{
             System.out.print("惩罚写检讨书");
        }
    }
}

因为85>98不成立，条件一不满足，但85>80成立,输出条件二下的代码块，即输出“奖励本子一个”,以下的代码不再执行，结束运行。

④嵌套if选择结构

在一个if-else结构中再嵌套一个if-else结构。

语法: if(条件一){
if(条件二){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}

注意:只有当满足外层if选择结构的条件时，才会判断内层if的条件!！

例如:

public class Test{
    public static void main(String [] args){
        int scores =98;
        char sex ='女';
        if(scores>90){
            if(sex.equals('女')){
                System.out.print("奖励少女心本子一个");
            }else{
                 System.out.print("奖励英雄钢笔一支");
            }
        }else{
                 System.out.print("进行惩罚!!");
       	}
    }
}

因为98>90,满足外层if的条件，则可以进入内层if，并且内层if的条件也满足，则可以输出"奖励少女心本子一个"

⑤switch选择结构

适用范围:在多分支结构下且是等值条件判断的情况下用switch更简便.

语法:

switch(值:int,char){
case 值1:
	语句块1;
	break;//中断，跳出switch
case 值2:
	语句块2;
	break;//中断，跳出switch
case 值3:
	语句块3;
	break;//中断，跳出switch
default:
	其它语句;
	break;//可省
}

注意:switch(“你好”){ } jdk6.0以下是错误，所以要使用String类型必须以Jdk1.7为前提。

1.switch里面的break和default是可以省略的，但会影响结果，switch中的case也可以打乱顺序；

2.当switch匹配到一个case分支，执行完相应语句之后没有遇到break,那么后面的语句要依次执行，遇到break就出来，没遇到就一直执行到最后出来；

3.case的值不可以重复；

4.多个case块可以执行同一语句。

例如：

import java.util.*;
Scanner input = new Scanner(System.in);
String str = input.next();
switch(str){
    case "1":
    case "2":     //多个case块执行同一语句
        System.out.print("敲代码");
        break;
    case "3":
    case "4":
         System.out.print("玩游戏");
        break;
    default:
         System.out.print("睡觉");
        break;
}

因为是从键盘输入的，所以当输入1和2时则会匹配相应的case块，然后输出case块里面的内容，又因为有break，则刹车跳出当前结构，以此类推；当输入的值既不是1和2也不是3和4，则会输出default里面的内容，default为“默认”，也可以省略 。

二、“==”和“equals”的区别：

”==“：判断值，还要比较栈里面保存的堆地址

“equals”：比较内容

equals的语法：变量名1.equals（变量名2）

变量名1和变量名2可以颠倒顺序。

三、逻辑运算符

运算符	汉语名称	表达式	说明
&&	短路与、并且	条件1&&条件2	两个条件必须同时为真，则结果才为真；两个条件有一个为假，则结果为假
||	短路或、或者	条件1||条件2	两个条件有一个为真，则结果为真；两个条件同时为假，则结果为假
！	非	！条件	条件为真，结果为假；条件为假，结果为真

短路：遇上&&，只要前面出现一个false，后面统统不执行
遇上||，只要前面出现一个true，后面也统统不执行

&：非短路逻辑与
| : 非短路的逻辑或

非短路：不管前面是什么样的结果后面统统会执行

例如：

int scores =90;
int num=103;
if(scores>90&&scores>100){
    System.out.print("好好学习");
}else if(scores>90||scores>100){
     System.out.print("天天向上");
}

因为if括号里面的是两个条件用“&&”表示的，所以两件必须同时满足，但是90>90不成立，所以不执行下面的代码块；那么进入else if，该两个条件是用“||”表示的，所以满足其中一个条件即可，103>100成立满足其中一个条件，那么输出“天天向上”。

循坏结构

一、循坏结构

1.什么是循坏？

循环就是重复做（相同）的或（相似）的事情；例如在操场上进行800米的赛跑，汽车的轮子等等。

2.循坏的三要素：
①循环条件判断 （ 跑多少圈停下来 ）
②循环变量初始化 （ 记分牌要初始化 ）
③循环体内要改变循环变量 （ 每跑一圈加1 ）

3.循环的分类
a.确定次数的循环

b.不确定次数的循环

4.怎么写循坏？

第一步:打框架
while(){

}
第二步:找出三要素，放入对应位置
循环变量初始化; //通常以第一件事做参考
while(循环条件判断){ //通常以最后一件事做参考
//循环体
循环体内改变循环变量; //通常以相邻两件事之差做参考
}

第三步:写循环体
①如果是重复做相同的事情，只需把其中一件直接当循环体

②如果是重复做相似的事情，那么首先把其中一件事当循环体，然后
找出规律，把不同的部份用变量(循环变量)代替

例如：

int i =1;	//初始化
while(i<=100){   //循坏条件判断
    System.out.println("第"+i+"遍:好好学习,天天向上");  //循坏体
    i++;    //迭代体
}

二、三大循坏结构

1.while循坏结构（当型循坏）

语法：

//循环变量初始化;
while(循环条件判断){
//循环体
//循环体内改变循环变量;
}

//例子
int i =1;
while(i<=100){
    System.out.println("天天向上");
    i++;
}

执行顺序：先判断循坏条件是否满足，若第一次判断循坏条件就不满足，则会直接跳出循坏，循坏操作一次都不会执行。若满足则执行循坏操作，然后进行迭代部分，再次判断循坏条件，决定继续执行或退出循坏。

特点:先判断，后执行

2.do-while循坏（直到型循坏）

语法:

//循环变量初始化;
do{
//循环体
//循环体内改变循环变量;
}while(循环条件判断);

//例子
int i =1;
do{
    System.out.println("我希望你快乐");
    i++;
}while(i<=10);

注意：在do-while循坏中，while括号后面是分号，并不是大括号！！！

执行顺序:先执行一遍循坏体，再去判断循坏条件，若满足条件则循坏继续执行，否则退出循坏。

特点：先执行，后判断

3.while循坏和do-while循坏最大的区别：

do-while循坏结构不管在什么情况都至少执行一次；而while循坏若第一次不满足条件，则会退出循坏，什么也不会执行。

4.for循坏

语法：

for(循环变量初始化;循环条件判断;循环体内改循环变量){
//循环体

}

//例子
import java.util.*;
Scanner input =new Scanner(System.in);
int scores =0;
for(int i = 0;i<5;i++){
	System.out.println("请输入第"+(i+1)+"门课的成绩:");
   	scores =input.nextInt();
}

注意：for后面的括号中的三个表达式必须用分号隔开，并且这三个表达式可以省略；

但是当省略表达式时，则需要在for语句前给循坏变量赋值。

执行顺序：先执行初始部分，再进行循坏条件判断，若满足判断结果，则执行循坏体；若不满足则退出循坏。再执行迭代部分，改变循坏变量值，然后再次进行循坏条件判断，直到退出for循坏结构。

注意：初始部分仅仅执行了一次！！

适用范围：对于循坏次数确定的情况下，使用for循坏结构。

死循环

1.定义：永远不会退出的循坏称为死循环

2.三种循坏的死循环表示：

①for(;?{}

②while(true){}

③do{}while(true);

continue与break：

break:用在switch中，用来跳出switch;
用在循环中:结束(当前)循环，跳到当前循环之后执行

continue:结束本次循环，直接进入下一次循环

//例子
int sum =0;
for(int i = 0;i<10;i++){
    if(i%2==0){
        continue;
    }
    sum=sum+i;  //进行累加
}
System.out.println("它们的和为:"+sum);

首先进入for循环结构，如果满足条件再进入if选择结构，如果i对2取余等于0，则说明i不是所需要的数，不进行累加，直接进入下一次循环。

//例子
for(int i =o;i<10;i++){
	if(i%2!=0){
        break;
    }
    System.out.println(i);
}

首先进入for循环结构，如果满足条件再进入if选择结构，如果i对2取余不等于0，则终止循坏。

数组

一、什么是数组？

数组就是在内存空间划出一串连续的空间，也是一种引用数据类型,存同种类型的大量数据。

二、数组的基本要素

①标识符(数组名称)

②数组元素

一些数组元素的初始值：

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false
String

③数组下标

注意:每个元素都有固定对应的一个下标，并且下标是从0开始的，最大下标数则为数组长度－1

因此数组下标的范围则为（0~数组长度-1）

数组长度：数组可容纳元素的最大数量

④元素类型

三、使用数组的步骤

1.声明数组

语法：数据类型 [ ] 数组名；

或者 数据类型 数组名 [ ];

例如：int [ ] scores;

或者int [ ] scores; //数组名遵循变量名的命名规则

2.分配空间

语法：数组名 =new 数据类型[数组长度]；

注意：数组长度是固定的！！！

例如：scores =new int [31]； //存储30个学员成绩

3.赋值

①语法：数组名[下标值]；

例如：scores[0] =89；

scores[1] =90；

scores[2] =80；

②语法：数据类型 [ ]数组名 ={值1，值2，值3，…，值n}；

例如：int [ ]scores ={60,70,80,90,100}；//创建一个长度为5的数组scores

或者int [ ]scores =new int [ ]{60,70,80,90,100};

4.对数据进行处理

四、数组的基本语法：

​ 数据类型[ ] 数组名 = new 数据类型[长度];
​ 数据类型[ ] 数组名 = new 数据类型[ ]{值};
​ 数据类型 数组名[ ] = new 数据类型[ ]{值};

五、数组越界

定义：如果数组已经满但是继续向数组中存储数据的话，程序就会报错，称为数组越界

[外链图片转存失败(img-9wXPLveJ-1567226105099)(C:\Users\联想\AppData\Roaming\Typora\typora-user-images\1567128201697.png)]

运行程序发现编译报错，控制台打出了“java.lang.ArrayIndexOutOfBoundsException”,意思就是数组下标超过范围，定义了一个数组长度为2，而却赋了三个值，超过长度定会报错！！

数组常见错误：①数组下标从零开始

②数组访问越界

六、数组应用

1.数组排序

语法：Arrays.sort(数组名);

说明：Arrays是Java中提供的一个类，而sort（）是该类的一个方法。

例如 ：

import java.util.Arrays;//排序包
int [] num =new int []{80,98,60,77,90}
Arrays.sort(num);
System.out.println("按升序排列:");
	for(int i =0;i<num.length;i++){
    	System.out.println(num[i]+" ");
	}
System.out.print("\n降序输出为:");
	for (int j =num.length-1; j >=0; j--) {
		System.out.print(num[j]+"\t");
	}

2.数组求最大小值

Scanner input =new 	Scanner(System.in);
		int [] money=new int[]{60,70,80,90,100};
//求最小值
		int min =0;
		min=money[0];
		for (int i = 0; i < money.length; i++) {
			if(money[i]<min){
				min=money[i];
			}
		}
//求最大值
		int max =0;
		max=money[0];
		for (int i = 0; i < money.length; i++) {
			if(money[i]>max){
				max=money[i];
			}
		}
		System.out.println("最小值是:"+min);
		System.out.println("最大值是:"+max);

				

3.插入元素(难点)

(我也不怎么会，不好意思!）

循坏进阶

一、二重循环结构

1.定义：一个循坏体内又包含另一个完整的循坏结构

2.语法：//while与while嵌套

while（循坏条件1）{

​ //循坏操作1；

​ while（循坏条件2）{

​ //循坏操作2；

​ }

}

//for与for循坏嵌套

for（循坏条件1）{

​ //循坏操作1；

​ for（循坏条件2）{

​ //循坏操作2；

​ }

}

//while与for循坏嵌套

while（循坏条件1）{

​ //循坏操作1；

​ for（循坏条件2）{

​ //循坏操作2；

​ }

}

//do-while与do-while循坏嵌套

do{

​ //循坏操作1

​ do{

​ //循坏操作2

​ }while（循坏条件2）；

}while（循坏条件1）；

二、应用(打印图形)

注意：外层循坏控制行数！！！

//打印等腰三角形
Scanner input =new Scanner(System.in);
System.out.println("请输入等腰三角形的行数:");
		int hang =input.nextInt();
		for (int i = 1; i <=hang; i++) {  //外层循坏控制行数
			for (int j = 1; j <=hang-i; j++) {
				System.out.print(" ");    //控制空格
			}# 选择结构

## **一、选择结构** 

①简单if选择结构

主要解决只有一种结果的问题，如果(条件),那么(结果)，条件不管它是什么，算出来的结果一定是true/false。

若条件为真，则输出代码块，反之。

语法：if(条件){
    				//代码块 
			}

例如:

```java
public class Test{
    public static void main(String [] args){
        int scores = 90;
        if(scores > 85){
            System.out.print("奖励一个Mp3"); //90>85成立,会输出代码块
        }
    }
}

②if-else结构

主要解决只有两种可能结果的问题

语法: if(条件){
//条件成立时语句
}else{
//条件不成立时语句
}

例如:

public class Test{
    public static void main(String [] args){
        int scores =80;
        if(scores>90){
               System.out.print("奖励一个Mp3");
        }else{
               System.out.print("惩罚进行编码!"); //80>90不成立,则输出else括号里的代码块
        }
    }
}

③多重if选择结构

主要解决有多种可能结果的问题，永远只执行其中一个分支。

语法: if(条件1){
//条件1成立时语句
}else if(条件2){
//条件2成立时语句
}else if(条件3){
//条件3成立时语句
}else{
//条件1,2,3都不成立时语句
}

注意:else块最多有一个或没有,else块必须要放在else if块之后！！

例如:

public class Test{
    public static void main(String [] args){
        int scores =85;
        if(scores>98){
             System.out.print("奖励一个Mp3");
        }else if(scores>80){
             System.out.print("奖励本子一个");
        }else if(scores>60){
             System.out.print("惩罚进行编码");
        }else{
             System.out.print("惩罚写检讨书");
        }
    }
}

因为85>98不成立，条件一不满足，但85>80成立,输出条件二下的代码块，即输出“奖励本子一个”,以下的代码不再执行，结束运行。

④嵌套if选择结构

在一个if-else结构中再嵌套一个if-else结构。

语法: if(条件一){
if(条件二){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}

注意:只有当满足外层if选择结构的条件时，才会判断内层if的条件!！

例如:

public class Test{
    public static void main(String [] args){
        int scores =98;
        char sex ='女';
        if(scores>90){
            if(sex.equals('女')){
                System.out.print("奖励少女心本子一个");
            }else{
                 System.out.print("奖励英雄钢笔一支");
            }
        }else{
                 System.out.print("进行惩罚!!");
       	}
    }
}

因为98>90,满足外层if的条件，则可以进入内层if，并且内层if的条件也满足，则可以输出"奖励少女心本子一个"

⑤switch选择结构

适用范围:在多分支结构下且是等值条件判断的情况下用switch更简便.

语法:

switch(值:int,char){
case 值1:
	语句块1;
	break;//中断，跳出switch
case 值2:
	语句块2;
	break;//中断，跳出switch
case 值3:
	语句块3;
	break;//中断，跳出switch
default:
	其它语句;
	break;//可省
}

注意:switch(“你好”){ } jdk6.0以下是错误，所以要使用String类型必须以Jdk1.7为前提。

1.switch里面的break和default是可以省略的，但会影响结果，switch中的case也可以打乱顺序；

2.当switch匹配到一个case分支，执行完相应语句之后没有遇到break,那么后面的语句要依次执行，遇到break就出来，没遇到就一直执行到最后出来；

3.case的值不可以重复；

4.多个case块可以执行同一语句。

例如：

import java.util.*;
Scanner input = new Scanner(System.in);
String str = input.next();
switch(str){
    case "1":
    case "2":     //多个case块执行同一语句
        System.out.print("敲代码");
        break;
    case "3":
    case "4":
         System.out.print("玩游戏");
        break;
    default:
         System.out.print("睡觉");
        break;
}

因为是从键盘输入的，所以当输入1和2时则会匹配相应的case块，然后输出case块里面的内容，又因为有break，则刹车跳出当前结构，以此类推；当输入的值既不是1和2也不是3和4，则会输出default里面的内容，default为“默认”，也可以省略 。

二、“==”和“equals”的区别：

”==“：判断值，还要比较栈里面保存的堆地址

“equals”：比较内容

equals的语法：变量名1.equals（变量名2）

变量名1和变量名2可以颠倒顺序。

三、逻辑运算符

运算符	汉语名称	表达式	说明
&&	短路与、并且	条件1&&条件2	两个条件必须同时为真，则结果才为真；两个条件有一个为假，则结果为假
||	短路或、或者	条件1||条件2	两个条件有一个为真，则结果为真；两个条件同时为假，则结果为假
！	非	！条件	条件为真，结果为假；条件为假，结果为真

短路：遇上&&，只要前面出现一个false，后面统统不执行
遇上||，只要前面出现一个true，后面也统统不执行

&：非短路逻辑与
| : 非短路的逻辑或

非短路：不管前面是什么样的结果后面统统会执行

例如：

int scores =90;
int num=103;
if(scores>90&&scores>100){
    System.out.print("好好学习");
}else if(scores>90||scores>100){
     System.out.print("天天向上");
}

因为if括号里面的是两个条件用“&&”表示的，所以两件必须同时满足，但是90>90不成立，所以不执行下面的代码块；那么进入else if，该两个条件是用“||”表示的，所以满足其中一个条件即可，103>100成立满足其中一个条件，那么输出“天天向上”。

循坏结构

一、循坏结构

1.什么是循坏？

循环就是重复做（相同）的或（相似）的事情；例如在操场上进行800米的赛跑，汽车的轮子等等。

2.循坏的三要素：
①循环条件判断 （ 跑多少圈停下来 ）
②循环变量初始化 （ 记分牌要初始化 ）
③循环体内要改变循环变量 （ 每跑一圈加1 ）

3.循环的分类
a.确定次数的循环

b.不确定次数的循环

4.怎么写循坏？

第一步:打框架
while(){

}
第二步:找出三要素，放入对应位置
循环变量初始化; //通常以第一件事做参考
while(循环条件判断){ //通常以最后一件事做参考
//循环体
循环体内改变循环变量; //通常以相邻两件事之差做参考
}

第三步:写循环体
①如果是重复做相同的事情，只需把其中一件直接当循环体

②如果是重复做相似的事情，那么首先把其中一件事当循环体，然后
找出规律，把不同的部份用变量(循环变量)代替

例如：

int i =1;	//初始化
while(i<=100){   //循坏条件判断
    System.out.println("第"+i+"遍:好好学习,天天向上");  //循坏体
    i++;    //迭代体
}

二、三大循坏结构

1.while循坏结构（当型循坏）

语法：

//循环变量初始化;
while(循环条件判断){
//循环体
//循环体内改变循环变量;
}

//例子
int i =1;
while(i<=100){
    System.out.println("天天向上");
    i++;
}

执行顺序：先判断循坏条件是否满足，若第一次判断循坏条件就不满足，则会直接跳出循坏，循坏操作一次都不会执行。若满足则执行循坏操作，然后进行迭代部分，再次判断循坏条件，决定继续执行或退出循坏。

特点:先判断，后执行

2.do-while循坏（直到型循坏）

语法:

//循环变量初始化;
do{
//循环体
//循环体内改变循环变量;
}while(循环条件判断);

//例子
int i =1;
do{
    System.out.println("我希望你快乐");
    i++;
}while(i<=10);

注意：在do-while循坏中，while括号后面是分号，并不是大括号！！！

执行顺序:先执行一遍循坏体，再去判断循坏条件，若满足条件则循坏继续执行，否则退出循坏。

特点：先执行，后判断

3.while循坏和do-while循坏最大的区别：

do-while循坏结构不管在什么情况都至少执行一次；而while循坏若第一次不满足条件，则会退出循坏，什么也不会执行。

4.for循坏

语法：

for(循环变量初始化;循环条件判断;循环体内改循环变量){
//循环体

}

//例子
import java.util.*;
Scanner input =new Scanner(System.in);
int scores =0;
for(int i = 0;i<5;i++){
	System.out.println("请输入第"+(i+1)+"门课的成绩:");
   	scores =input.nextInt();
}

注意：for后面的括号中的三个表达式必须用分号隔开，并且这三个表达式可以省略；

但是当省略表达式时，则需要在for语句前给循坏变量赋值。

执行顺序：先执行初始部分，再进行循坏条件判断，若满足判断结果，则执行循坏体；若不满足则退出循坏。再执行迭代部分，改变循坏变量值，然后再次进行循坏条件判断，直到退出for循坏结构。

注意：初始部分仅仅执行了一次！！

适用范围：对于循坏次数确定的情况下，使用for循坏结构。

死循环

1.定义：永远不会退出的循坏称为死循环

2.三种循坏的死循环表示：

①for(;; ){}

②while(true){}

③do{}while(true);

continue与break：

break:用在switch中，用来跳出switch;
用在循环中:结束(当前)循环，跳到当前循环之后执行

continue:结束本次循环，直接进入下一次循环

//例子
int sum =0;
for(int i = 0;i<10;i++){
    if(i%2==0){
        continue;
    }
    sum=sum+i;  //进行累加
}
System.out.println("它们的和为:"+sum);

首先进入for循环结构，如果满足条件再进入if选择结构，如果i对2取余等于0，则说明i不是所需要的数，不进行累加，直接进入下一次循环。

//例子
for(int i =o;i<10;i++){
	if(i%2!=0){
        break;
    }
    System.out.println(i);
}

首先进入for循环结构，如果满足条件再进入if选择结构，如果i对2取余不等于0，则终止循坏。

数组

一、什么是数组？

数组就是在内存空间划出一串连续的空间，也是一种引用数据类型,存同种类型的大量数据。

二、数组的基本要素

①标识符(数组名称)

②数组元素

一些数组元素的初始值：

数据类型	初始值
int	0
double	0.0
char	‘\u0000’
boolean	false
String	“null”

③数组下标

注意:每个元素都有固定对应的一个下标，并且下标是从0开始的，最大下标数则为数组长度－1

因此数组下标的范围则为（0~数组长度-1）

数组长度：数组可容纳元素的最大数量

④元素类型

三、使用数组的步骤

1.声明数组

语法：数据类型 [ ] 数组名；

或者 数据类型 数组名 [ ];

例如：int [ ] scores;

或者int [ ] scores; //数组名遵循变量名的命名规则

2.分配空间

语法：数组名 =new 数据类型[数组长度]；

注意：数组长度是固定的！！！

例如：scores =new int [31]； //存储30个学员成绩

3.赋值

①语法：数组名[下标值]；

例如：scores[0] =89；

scores[1] =90；

scores[2] =80；

②语法：数据类型 [ ]数组名 ={值1，值2，值3，…，值n}；

例如：int [ ]scores ={60,70,80,90,100}；//创建一个长度为5的数组scores

或者int [ ]scores =new int [ ]{60,70,80,90,100};

4.对数据进行处理

四、数组的基本语法：

​ 数据类型[ ] 数组名 = new 数据类型[长度];
​ 数据类型[ ] 数组名 = new 数据类型[ ]{值};
​ 数据类型 数组名[ ] = new 数据类型[ ]{值};

五、数组越界

定义：如果数组已经满但是继续向数组中存储数据的话，程序就会报错，称为数组越界

运行程序发现编译报错，控制台打出了“java.lang.ArrayIndexOutOfBoundsException”,意思就是数组下标超过范围，定义了一个数组长度为2，而却赋了三个值，超过长度定会报错！！

数组常见错误：①数组下标从零开始

②数组访问越界

六、数组应用

1.数组排序

语法：Arrays.sort(数组名);

说明：Arrays是Java中提供的一个类，而sort（）是该类的一个方法。

例如 ：

import java.util.Arrays;//排序包
int [] num =new int []{80,98,60,77,90}
Arrays.sort(num);
System.out.println("按升序排列:");
	for(int i =0;i<num.length;i++){
    	System.out.println(num[i]+" ");
	}
System.out.print("\n降序输出为:");
	for (int j =num.length-1; j >=0; j--) {
		System.out.print(num[j]+"\t");
	}

2.数组求最大小值

Scanner input =new 	Scanner(System.in);
		int [] money=new int[]{60,70,80,90,100};
//求最小值
		int min =0;
		min=money[0];
		for (int i = 0; i < money.length; i++) {
			if(money[i]<min){
				min=money[i];
			}
		}
//求最大值
		int max =0;
		max=money[0];
		for (int i = 0; i < money.length; i++) {
			if(money[i]>max){
				max=money[i];
			}
		}
		System.out.println("最小值是:"+min);
		System.out.println("最大值是:"+max);

				

3.插入元素(难点)

(我也不怎么会，不好意思!）

循坏进阶

一、二重循环结构

1.定义：一个循坏体内又包含另一个完整的循坏结构

2.语法：//while与while嵌套

while（循坏条件1）{

​ //循坏操作1；

​ while（循坏条件2）{

​ //循坏操作2；

​ }

}

//for与for循坏嵌套

for（循坏条件1）{

​ //循坏操作1；

​ for（循坏条件2）{

​ //循坏操作2；

​ }

}

//while与for循坏嵌套

while（循坏条件1）{

​ //循坏操作1；

​ for（循坏条件2）{

​ //循坏操作2；

​ }

}

//do-while与do-while循坏嵌套

do{

​ //循坏操作1

​ do{

​ //循坏操作2

​ }while（循坏条件2）；

}while（循坏条件1）；

二、应用(打印图形)

注意：外层循坏控制行数！！！

//打印等腰三角形
Scanner input =new Scanner(System.in);
System.out.println("请输入等腰三角形的行数:");
		int hang =input.nextInt();
		for (int i = 1; i <=hang; i++) {  //外层循坏控制行数
			for (int j = 1; j <=hang-i; j++) {
				System.out.print(" ");    //控制空格
			}
			for (int j2 = 1; j2 <=2*i-1; j2++) {
					System.out.print("*");   //控制星星数
			}
			System.out.print("\n");     //换行

打印九九乘法表

三、continue和break

注意：continue和break在二重循坏中的用法与在循坏中的用法一致！！！而且只会影响内层循坏的执行，对外层循坏没有影响，continue语句是跳出本次循坏，进入下一次循坏，而break是跳出本层循坏