java循环及数组

##1 、 程序的流程控制
1996年,计算机科学家Bohm和Jacopini证明了:任何简单或复杂的算法都可以由顺序结构、分支结构
和循环结构这三种基本结构组合而成。
它们的共同点是都包含一个入口和一个出口,它们的每个代码都有机会被执行,不会出现死循环。
1.1顺序结构
顺序结构是一种基本的控制结构,它按照语句出现的顺序执行操作
在这里插入图片描述
1.2分支结构
分支结构又被称为选择结构,根据条件成立与否来执行操作。
1.2.1 基本选择结构 if
`/*语法:
if(条件){
条件成立执行的内容
}

/*语法:
if(条件){
条件成立执行的内容
}
*/

在这里插入图片描述
1.2.2 if-else选择结构

/*语法:
if(条件){
条件成立执行的内容
}else{
条件不成立执行的内容
}
*/

在这里插入图片描述
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.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("其他出路!");
}
}

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

switch(表达式){
case1://相当于if(){}
//满足表达式的结果==值1的时候执行的代码
break;//退出当前的switch选择结构
case2://相当于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后面的执行体可写{ }也可以不写{ }
*/

在这里插入图片描述
示例

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("再接再厉");
}
}*/

巧用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
运动会百米赛跑项目: 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("很遗憾,没能进入决赛!下次努力!");
}}}

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

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

在这里插入图片描述
循环结构
循环结构是一种重复结构,如果条件成立,它会重复执行某一循环体,直到出现不满足的条件为止。
循环两个点:1、循环操作 2、循环条件
while循环
语法

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

流程图
在这里插入图片描述
解决循环题目的步骤
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、检查循环能否退出--循环条件是否发生变化
}

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

public static void main(String[] args) {
//1、分析循环条件和操作
//循环操作:打印数字
//循环条件:不够100
int i=1;
while(i<=100) {
System.out.println(i);
i++;
}
}

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

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

在这里插入图片描述
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("登录成功!");
}
}

for循环
语法

for(表达式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++;
// }
}
}

死循环
在这里插入图片描述
循环中的关键字
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");
}

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();
}
}

打印直角三角形

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();
}}

打印等腰三角形

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();
}
}

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.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.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. 数组的默认值
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");

    }

}

求极值问题

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);
    }

}

练习
从键盘读入学生成绩,找出最高分,并输出学生成绩等级。
成绩>=最高分-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);
        }
    }
}

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

  1. 语法格式
    格式1:
int[][] arr = new int[3][];

二维数组中有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}};

2.2 二维数组的使用

  1. 方式一:
int[][] arr1 = new int[3][2];
arr1[0][1] = 3;

在这里插入图片描述

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

在这里插入图片描述

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("------------------");
}
}

在这里插入图片描述

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);
        }

    }
}

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("很遗憾,没有找到的啦!");
        }

二分查找

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("没有找到");
        }
    }


}
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值