java循环及数组_java 数组循环

##1 、 程序的流程控制
1996年，计算机科学家Bohm和Jacopini证明了：任何简单或复杂的算法都可以由顺序结构、分支结构
和循环结构这三种基本结构组合而成。
它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环。
1.1顺序结构
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作

1.2分支结构
分支结构又被称为选择结构，根据条件成立与否来执行操作。
1.2.1 基本选择结构 if
`/*语法：
if(条件){
条件成立执行的内容
}

/*语法：
if(条件){
条件成立执行的内容
}
*/
1
2
3
4
5

1.2.2 if-else选择结构

/*语法：
if(条件){
条件成立执行的内容
}else{
条件不成立执行的内容
}
*/
1
2
3
4
5
6
7

1.2.3 多重选择结构
用处：适合解决连续区间问题。
1.2.3.1 语法结构

if(条件1){
//条件1成立的时候执行的条件
}else if(条件2){
//条件1不成立，条件2成立的时候执行的条件
}else if(条件3){
//条件1、2不成立，条件3成立的时候执行的条件
}......
else if(条件n){
//条件1到n-1不成立，条件n成立的时候执行的条件
}else{
//当以上的所有条件都不成立的时候执行的代码
}
/*
整个结构是一个整体，当一个条件成立并执行之后，整个结构就已经执行完毕；
if块必须有；
else if块可以有一个，也可以有多个；
else 可以有一个，也可以没有。
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.2.3.2 示例
如果高考成绩过700 清华 ， 600-700:重点本科 500-600：普通本科 300-500：专科 其他：其他出路。

public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入你的分数：");
int score=input.nextInt();
if(score>700) {
System.out.println("去清华");
} else if (score >= 600/* &&score<=700 */) {
System.out.println("重点本科");
}else if (score >= 500/* &&score<=600 */) {
System.out.println("普通本科");
} else if(score>=300) {
System.out.println("专科");
}else {
System.out.println("其他出路！");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

switch选择结构
替换等值判定的多重选择结构
语法

switch(表达式){
case 值1://相当于if(){}
//满足表达式的结果==值1的时候执行的代码
break;//退出当前的switch选择结构
case 值2://相当于else if(){}
//满足表达式的结果==值2的时候执行的代码
break;
......
case 值n:
//满足表达式的结果==值n的时候执行的代码
break;
default://相当于else
//以上的匹配都失败的时候执行的内容
break;
}
/*
表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
case子句中的取值必须是常量，且所有case子句中的取值应是不同的；
default子句是可选的；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果case后面没有写break则直
接往下面执行！
Case后面的执行体可写{ }也可以不写{ }
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

示例

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 基金经理的业绩排名：1、欧洲游 2、东南亚游 3、国内游 其他：再接再厉！
System.out.println("请输入你的排名：");
int num = input.nextInt();
// 方式2：
switch (num) {// 小括号中的表达式或者变量结果类型可以是：int char String
byte short
case 1:// 相当于if(num==1){}//case 后面的值必须是常量 'A' "星期一"
System.out.println("奖励是：欧洲游");
break;// 执行完毕一个case分支后跳出switch语句块
case 2:// 相当于if(num==2)
System.out.println("奖励是：东南亚游");
break;
case 3:// 相当于if(num==3)
System.out.println("奖励是：国内游");
break;
default:// 相当于else ,是可选的
System.out.println("再接再厉");
break;
}
// 方式1：
/*
if (num == 1) {
System.out.println("奖励是：欧洲游");
} else if (num == 2) {
System.out.println("奖励是：东南亚游");
} else if (num == 3) {
System.out.println("奖励是：国内游");
} else {
System.out.println("再接再厉");
}
}*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

巧用break的省略
多分支月份输出天数

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 根据用户输入的月份，输出当月的天数，不考虑平年闰年
System.out.println("请输入月份：");
int month = input.nextInt();
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有31天！");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有30天！");
break;
case 2:
System.out.println(month + "月共有28天！");
break;
default:
System.out.println("您输入的月份有误！");
break;
}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

嵌套选择结构
以上的所有的选择结构都相互嵌套

示例1
运动会百米赛跑项目： 16秒之内才能进入决赛，根据性别分男女组

package lina;
import java.util.Scanner;
/**
* 嵌套的选择结构
* @author Administrator
*
*/
public class Demo09_ifif {
public static void main(String[] args) {
//运动会百米赛跑项目： 16秒之内才能进入决赛，根据性别分男女组
Scanner input = new Scanner(System.in);
System.out.println("请输入跑步时间秒：");
float time=input.nextFloat();
if(time<=16) {
//进入决赛
System.out.println("请输入性别：");
String gender=input.next();
if("男".equals(gender)) {//字符串比较内容是否相等，不能使用== 使
用.equlas()
System.out.println("进入男子组决赛！");
}else {
System.out.println("进入女子组决赛！");
}
}else {
System.out.println("很遗憾，没能进入决赛！下次努力！");
}}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

字符串比较相等
==比较内存地址
equlas比较内容

String str1="abc";
String str2=input.next();
System.out.println(str1==str2);
System.out.println(str1.equlas(str2));
1
2
3
4

循环结构
循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
循环两个点：1、循环操作 2、循环条件
while循环
语法

while(循环条件){
//循环操作
}
1
2
3

流程图

解决循环题目的步骤
1、分析循环条件和循环操作
2、套用到循环语法中
3、检查循环能否退出（循环条件是否会发生变化）
案例1
用while循环描述：万米赛跑项目（操场400米一圈，共跑25圈）
步骤1：编写伪代码
步骤2：转换为java代码

public static void main(String[] args) {
// 用while循环描述刚刚的万米赛跑，操场400米一圈，共跑25圈
//1、分析循环条件和操作
//循环操作：跑圈，现在第圈
//循环条件：不够25圈
//2、套用循环语法
int num=1;//圈数
while(num<=25) {
//跑圈，现在第圈
System.out.println("跑圈，现在第"+num+"圈");
//跑完一圈圈数+1
num++;
}
System.out.println("完成了万米赛跑项目！");
//3、检查循环能否退出--循环条件是否发生变化
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

案例2
打印1-100之间的所有数字

public static void main(String[] args) {
//1、分析循环条件和操作
//循环操作：打印数字
//循环条件：不够100
int i=1;
while(i<=100) {
System.out.println(i);
i++;
}
}
1
2
3
4
5
6
7
8
9
10

while循环的特征
1、先判断后执行
2、如果初始条件不满足，循环一次都不执行
do-while循环
语法

do{
//循环操作
}while(循环条件);
//PS:特别注意最后的分号不能丢掉
1
2
3
4

do-while循环的特征
1、先执行后判断
2、如果初始条件不满足，循环至少执行一次
案例1
用户登录：用户输入用户名和密码，用户名是admin 密码是123才能登录成功，其余都失败！

package lina;
import java.util.Scanner;
/*
* do-while
* 特征：先执行一次，再判定 初始条件不满足，循环至少会执行一次
*/
public class Demo11_dowhile {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//用户登录：用户输入用户名和密码，用户名是admin 密码是123才能登录成功，其余都失
败！
//1、分析
//循环条件：用户名是admin 密码是123
//循环操作：用户输入，判定对错
//2、套用语法
String name;
int password;
do {
//循环操作：用户输入，判定对错
System.out.println("请输入用户名和密码：");
name=input.next();
password=input.nextInt();
if(!"admin".equals(name) || password!=123) {
System.out.println("用户名或密码错误！登录失败！");
}
}while(!"admin".equals(name) || password!=123);
System.out.println("登录成功！");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

for循环
语法

for(表达式1：定义循环变量;表达式2：循环条件;表达式3：循环变量的变化){
//循环操作
}
1
2
3

执行顺序
1、先执行表达式1：定义循环变量，该表达式只执行一次
2、判断循环条件是否成立：
3、循环条件成立：执行循环操作， 不成立：退出循环
4、执行完循环操作，执行表达式3–循环变量的变化
5、重复2-4步骤

特征
先判断后执行
使用场合
适合解决循环次数固定的题目
案例

package lina;
public class Demo12_for {
public static void main(String[] args) {
//案例1：打印1-100
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
//案例2：打印1-100的所有的数字之和
//循环条件：没有加到100次
//循环操作：累加
int sum=0;
for(int k=1;k<=100;k++) {
sum=sum+k;
}
System.out.println("1-100之和："+sum);
//案例3：打印1-100之间所有的偶数
for(int i=1;i<=100;i++) {
if(i%2==0) {
System.out.println(i);
}
}
//可以仿写while的格式，语法正确，但是不推荐
// int j=1;
// for(;j<=100;) {
// System.out.println(j);
// j++;
// }
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

死循环

循环中的关键字
break
作用–退出循环

示例
万米赛跑项目，坚持不住可以退出！

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int i=1;
while(i<=25) {
System.out.println("跑圈，第"+i+"圈");
i++;
System.out.println("还能坚持吗？T/F");
char isOk=input.next().charAt(0);
if(isOk=='f') {
System.out.println("坚持不住了，退出！");
break;
}
}
System.out.println("over");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

continue
作用–结束当次循环，进入下一次循环

三种循环对比

嵌套循环
语法

案例
利用二重循环打印图形。
打印矩形`

public static void main(String[] args) {
//使用*号打印5行6列的矩形
for(int i=1;i<=5;i++) {//外层循环控制行数
for(int j=1;j<=6;j++) {//内层循环控制个数
System.out.print("*");
}
System.out.println();
}
}
1
2
3
4
5
6
7
8
9

打印直角三角形

public static void main(String[] args) {
//打印直角三角形
for(int i=1;i<=5;i++) {
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}}
1
2
3
4
5
6
7
8

打印等腰三角形

public static void main(String[] args) {
//打印等腰三角形
for(int i=1;i<=5;i++) {
//打印空格
for(int k=1;k<=5-i;k++) {
System.out.print(" ");
}
//打印*号
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

break和continue在双重循环中的使用
就近原则：break在哪一层使用就退出哪一层循环
continue在哪一层使用就结束哪一层的当次循环，进入该层的下一次循环。

public static void main(String[] args) {
//打印九九乘法表
for(int i=1;i<=9;i++) {
for(int j=1;j<=i;j++) {
System.out.print(j+"*"+i+"="+i*j+"\t");
if(j==5) {
break;
}
System.out.print("===");
}
System.out.println();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

一维数组

1.1 概念
数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的
方式对这些数据进行统一管理。
变量：在内存开辟一块空间。
数组：也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改
数组的常见概念
数组名
下标(或索引)
元素
数组的长度
1.2 基本用法

1. 格式
   格式 1. 数据类型[] 数组名，属于只创建了数组引用名， 并未在内存创建数组空间
   格式 2. 数据类型[] 数组名称 = new 数据类型[数组长度];
   格式 3. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
   格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n}
2. 代码

import java.util.Arrays;

public class Test1 {

    public static void main(String[] args) {
        //方式1，声明数组变量，没有分配内存空间
        int[] arr1 = null; //null,没有分配内存空间
        System.out.println(arr1);
        //方式2：给数组分配内存空间
        arr1 = new int[4]; //分配内存空间
        System.out.println(arr1); //打印内存地址

        arr1[3] = 3;
        System.out.println(Arrays.toString(arr1)); //数组中的元素的字符串

        //方式3,4,创建数组直接给定初始值
        int[] arr2 = {1,2,3,4};
        System.out.println(Arrays.toString(arr2)); //数组中的元素的字符串
        arr2 = new int[] {3,2,1};
        System.out.println(Arrays.toString(arr2)); //数组中的元素的字符串

    }

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.3 内存结构
JMM
JVM的内存结构
第四行代码内存状态





1.4 数组实战

1. 读取数组
   取出数组中的值：数组名称[下标索引]

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test2 {

    public static void main(String[] args) {
        int[] arr1 = new int[4];
        
        //数组的循环赋值
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = i + 1;
        }

        //访问第2个元素
        arr1[1] = 123;

        //数组的循环读取
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }

        System.out.println(arr1);
        System.out.println(Arrays.toString(arr1));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2. 数组的默认值

public class Test3 {

    public static void main(String[] args) {
        //int类型数组元素的默认值是0
        int[] arr1=new int[4];
        for(int i=0;i<arr1.length;i++) {
            System.out.println(arr1[i]);
        }
        //double类型数组元素的默认值是0.0
        double[] arr2=new double[4];
        for(int i=0;i<arr2.length;i++) {
            System.out.println(arr2[i]);
        }
        //String类型数组元素的默认值是null
        String[] names=new String[5];
        for(int i=0;i<names.length;i++) {
            System.out.println(names[i]);
        }
        //char类型数组元素的默认值是0
        char[] genders=new char[5];
        for(int i=0;i<genders.length;i++) {
            System.out.println((int) genders[i]);
        }
        //boolean类型数组元素的默认值是false
        System.out.println("over");

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

求极值问题

public class Test4 {

    public static void main(String[] args) {
        int[] arr= {12,43,-45,567,13};
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println("最大值" + max);
        System.out.println("最小值" + min);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

练习
从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩

import java.util.Scanner;

public class test4 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入学生个数：");
        int num = input.nextInt();
        int[] score =new int[num];
        System.out.println("请输入"+num+"个学生成绩：");
        int max=score[0];
        for (int i = 0; i < score.length; i++) {
            score[i]=input.nextInt();
            if(max<score[i]){
                max=score[i];
            }
        }
        System.out.println(max);
        char level;
        for (int i = 0; i < score.length; i++) {
            if(max-score[i]<=10){
                level='A';
            } else if (max-score[i]<=20) {
                level='B';
            } else if (max-score[i]<=30) {
                level='C';
            }else {
                level='D';
            }
            System.out.println("student "+i+" score is "+score[i]+" grade is "+level);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2 二维数组
2.1 概念
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存
在。其实，从数组底层的运行机制来看，其实没有多维数组

1. 语法格式
   格式1：

int[][] arr = new int[3][];
1

二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1];
arr[2] = new int[2];
注： int[][] arr = new int[][3] 非法

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
1

2.2 二维数组的使用

1. 方式一：

int[][] arr1 = new int[3][2];
arr1[0][1] = 3;
1
2

//方式2
int[][] arr2 = new int[3][];
arr2[0] = new int[3];
arr2[1] = new int[4];
arr2[0][1] = 3;
1
2
3
4
5

public static void main(String[] args) {
//方式3
int[][] arr2 = new int[][]{{3,8,2},{2,7}, {9,0,1,6}};
//取值
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
System.out.println(arr2[i][j]);
}
System.out.println("------------------");
}
}
1
2
3
4
5
6
7
8
9
10
11

2.3 内存结构


练习
基本都跟循环打交道；一维数组数组一重循环；2维数组数组2重循环；
基本离不开坐标问题；一维数组一个下标索引；二维数组一定就是两个坐标（横纵坐标）
二维数组练习：

• 数组中常见的异常： NullPointerException异常 空指针异常
• ArrayIndexOutOfBoundsException 数组下标越界

ublic class test13 {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        double[][]score =new double[3][];
        for (int i = 0; i < score.length; i++) {
            double sum =0;
            System.out.println("第"+(i+1)+"个班级有多少人" );
            int num =input.nextInt();
            score[i]=new double[num];
            for (int j = 0; j < num; j++) {
                System.out.println("请输入这位同学的成绩"  );
                 score[i][j] = input.nextDouble();
                 sum+=score[i][j];
            }
            System.out.println("平均分是:"+sum/num);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3 数组中常见算法
3.1 二分查找
数组的复制、反转、查找(线性查找、二分法查找)

public class test9 {
    public static void main(String[] args) {
        String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制(区别于数组变量的赋值：arr1 = arr)
        String[] arr1 = new String[arr.length];
        for(int i = 0;i < arr1.length;i++){
            arr1[i] = arr[i];
            System.out.println(arr1[i]);
        }
        //数组的反转
        for(int i = 0,j = arr.length - 1;i < j;i++,j--){
             String temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
        }
        System.out.println(Arrays.toString(arr));

        //遍历
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
//线性查找
        String dest = "BB";
        //dest = "CC";
        boolean isFlag = true;
        for(int i = 0;i < arr.length;i++){
            if(dest.equals(arr[i])){
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
            System.out.println("很遗憾，没有找到的啦！");
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

二分查找

public class test12 {
    public static void main(String[] args) {
        int[]arr = new int[]{1,2,3,4,5,6,7,8,9,10};
        int isthat=-2;
        int left=0;
        int right=arr.length-1;
        boolean isFlag = true;
        while(left<=right){
            int middle=(left+right)/2;
            if(isthat==middle){
                System.out.println("找到啦"+middle);
                isFlag=false;
                break;
            } else if (isthat<arr[middle]) {
                right=middle-1;
            }else{
                left=middle+1;
            }
        }
        if(isFlag){
            System.out.println("没有找到");
        }
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26