Java学习笔记之流程控制，数组（四）

最新推荐文章于 2020-11-06 09:01:20 发布

置顶老王学Java

最新推荐文章于 2020-11-06 09:01:20 发布

阅读量2.5k

点赞数 1

分类专栏： JAVA SE 文章标签： java 数组流程控制

本文链接：https://blog.csdn.net/yali1990515/article/details/13385719

版权

JAVA SE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

在这一篇博客中主要介绍Java的流程控制和数组。流程控制在编程中是经常用到的，流程控制主要包括分支控制，循环控制，跳转控制和异常控制。在这里我们首先介绍一下分支控制。

流程控制

（一）分支控制

分支控制主要包括两种语句if和switch语句。if有三种形式，一种是if，if else 和嵌套的if语句。在这里先看一下if 的第一个形式。

if（表达式） {
       语句1 ；
	   语句2 ；
}
if中当表达式的值为true时，则执行花括号里面的语句。反之则不执行里面的内容。值得注意的是if括号内的表达式为
逻辑表达式和关系表达式。例如：
int a = 3 ;
int b = 2 ;
if（a>b){
    a = a-b;
}
/*
  上面的if语句也可以写成
  if（a>b）
    a = a- b;
*/

简单的if语句的流程图

（2） if(){}else{}
if else的形式中在判断if后的表达式为true则运行if后面的语句反之运行else的语句中的内容。格式如下：

if(表达式){

语句1 ；

语句2 ；

}else if(表达式2){

语句1 ；

语句2 ；

}else{

........

}

（3）嵌套的if 。。。。else 语句

if ...else 是可以嵌套使用的，即是一个if 。else中嵌套一个或者多个if。else语句，格式如下：

if(表达式1）{
if(表达式2）{

语句1；。。。}

else {

。。。}

}
二 switch 多分支选择语句

switch是多分支语句，它可以根据表达式的不同结果选择不同的语句进行执行。值得注意的是switch的表达式类型只能 char，byte，short或者int。格式如下：

switch（表达式1）{

case value1 ：

语句1 ；break；

case value2 ：

语句2 ；break；

case value3 ：

语句3 ；

break；

default ：

语句4；

}

在switch中根据表达式的结果来与下面的case value的值对应则执行对应的语句。反之没有执行default中的语句，一个switch中只准有一个default语句。同时在case value中必须加入break语句。switch的流程图如下：

在这里来举一个例子来练习一下switch语句，主要是从从键盘总输入1-7 ，判断是周几。代码如下

import java.util.Scanner;
public class Test5 {
	public static void main(String[] args){
            /*
             * 1.scanner 是从文本中有计划的读取数据,使用时需要引入java.utl.Scanner包
             * 
             */
		    Scanner input = new Scanner(System.in);
            System.out.println("请输入1-7之内的数字！");
            String a  = input.next();
             int b = Integer.parseInt(a);//把字符转换成整型
             switch(b){
             case 1 :
            	 System.out.println("今天是星期一！");
                 break;
             case 2 : 
            	 System.out.println("今天是星期二！");
                 break;
             case 3 :
            	 System.out.println("今天是星期三！");
                 break;
             case 4 : 
            	 System.out.println("今天是星期四！");
                 break;
             case 5 :
            	 System.out.println("今天是星期五！");
                 break;
             case 6 : 
            	 System.out.println("今天是星期六！");
                 break;
             case 7 : 
            	 System.out.println("今天是星期日！");
                 break;
             default :
                	 System.out.println("输入的数字不合法");
             }            
	}

三循环分支结构

　　在java中的循环语句有普通的for循环和for/in循环，do{}while ,while  .需要注意的是for/in是java5.0新增加的一种循环方式，也称为增强的for循环。在这里来介绍一下for循环。
　　 For循环
普通的for循环的格式为：
      For(初始化条件;表达式2;步长)
          {
            语句1；
            语句2 ；
           }
初始化条件主要是对于对于值的赋值 ，表达式用于循环次数的判定，步长主要作用在于数的增长，相当于一个加法器或者减法器，可以递增也可以递减。For循环的流程图如下：
                            
 在for当表达式为true时，才执行循环语句，false时跳出for循环。For的表达式必须为关系表达式或者逻辑表达式。在for循环中可以对多个变了进行赋值，但是需要注意对于多个赋值必须用，隔开，不然则错误。例如：
    for(int i = 1,j = 2 ;i<8;i++){
                      语句1 ； 
                      语句2 ； 
         }
   而下面的这些都是错误的。
   编译错误，不能为表里个别定义数据类型
   for(int i = 1,int j = 2 ;i<8;i++){
                      语句1 ； 
                      语句2 ； 
         }
    编译错误，两个变量的数据类型不能不相同
    for(int i = 1,long = 2 ;i<8;i++){
                      语句1 ； 
                      语句2 ； 
         } 
    编译错误，j也需要在外部定义
     int i = 1 ;
     for( i = 1,j = 2 ;i<8;i++){
                      语句1 ； 
                      语句2 ； 
         }

while结构

while语句

while 的格式如下：

while（条件表达式）{
循环语句；

。。。。。

}

while中当条件语句为true时，则执行循环语句，当为false则退出。流程图如下：

do while语句

do while的结构是 do{...}while(...);中执行过是先执行一次循环语句，在while 中的条件表达式为true时则继续执行循环语句，为false时则退出。在这里需要注意的是在while后必须加上;流程图如下：

跳转语句

四跳转语句

在java中可以通过跳转语句来调出循环语句的控制。跳转语句有continue和break。goto也是跳转语句，但是在java中不经常使用。但是也可以通过continue和break 和标号的使用来实现goto语句的功能。下面来介绍continue和break的使用。

continue语句：跳转语句

continue语句的功能是终止这次循环，调成循环来执行下一次循环。下面用一个例子来看一下：

public class Test4 {

	/**
	 * 打印出1-100以内的可以被六整除的数字，以每行五个打印
	 */
	public static void main(String[] args) {

		int n = 0 ; 
		for(int i = 1;i<=100;i++){
           
			if(i%6!=0)//判断n是否可以被6整除，不可以调成这次循环，执行下一次循环
			  continue;
			n++ ; //一行打印五个数字，超过五个数字换行
			if(n%5==0){
				System.out.println(i+"\t"+"\n");
			}else 
			System.out.print(i+"\t");
		}
	}
}

运行结果如图：

continue还有一种形式，continue和标号outerloop,这样使用起来更加简单。例如如下：

public class Test4 {

	/**
	 * 打印出1-100以内的可以被六整除的数字，以每行五个打印
	 */
	public static void main(String[] args) {
        int n = 0 ;
		outerLoop:
		for(int i = 1;i<=100;i++){
			if(i%6!=0)  continue outerLoop;
			if(n%5==0)
				System.out.println(i+"\t");	
			else 
			System.out.print(i+"\t");
		}
	}
}

break语句：退出当前所在的循环

break语句可以在循环为执行完之前，退出当前所在的循环就可以使用break。具体的例子你可以看一下switch语句中的使用。在这里就不仔细介绍了。

数组

数组一般用于对于相同类型数据的处理。数组即是由一组相同类型的变量组成的数据类型，数组中的元素可以通过标下标来实现访问。数组由复杂程度分为一维数组，二维数组以及多位数组。

一：一维数组

数组的使用需要两步：

第一：对于数组的声明

第二：分配内存

数组的声明格式如下：

数组类型数组名 [ ]；

数组类型可以为基本的数据类型和字符类型。数组名主要是用来统一这个相同类型的数组的名称，命名的规则和标量的规则一样，在这里建议用有意义的名字。

1.一维数组的声明

一维数组的声明有两种形式，分别为数组类型数组名 [ ] ；数组类型 [ ] 数组名。这两个定义方法是等价的。

需要注意的是在数组的声明的过程中不能在 [ ]中填写数组的长度，不然会编译错误。例如 int array [ 10] ;

内存的分配

在数组声明后，只有对内存进行了分配才可以进行数组的使用。对于内存的分配使用new关键字来实现.例如：

int a [ ] = new int [3] ；//定义一个数据类型为int，长度为3的数组

int [ ] a = new int [ 3 ] ; //定义一个数据类型为int，长度为3的数组

对于数组也可以使用下列的方式进行声明。如 int a [ ] = {1,2,3,4,5} ;//声明一个int类型的数组，数组的长度为5，并且对于进行了赋值。

2一维数组的引用

数组是一个引用类型的变量，对于数组的元素可以通过下标来引用。格式如下：array [ index ] ;index代表的是数组的下标，而数组的下标从0开始。举例：

public class TestArray
{
	public static void main(String[] args) 
	{
		//定义一个长度为5的int类型数组
		int array [] = new int [5] ;//另一种形式 int array [] = {1,2,3,4,5};

		//数组的赋值
		array[0] = 1;
        array[1] = 2;
		array[2] = 3;
		array[3] = 4;
		array[4] = 5;
		/*
		  循环打印数组内的值
		  array.length 代表的是数组的长度
		*/
		for(int i=0;i<array.length;i++){
			System.out.println(array[i]);
			}
	}
}

二：二维数组

二维数组的声明和一维数组的类似。格式如下：

数组类型数组名称 [ ] [ ] ;

初始化的格式为数据类型数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }；二维数组的初始化的格式有如下的几种方式：

⑴ 分行进行初始化
　　int a[2][3]={{1,2,3},{4，5，6}};
　　在{ }内部再用{ }把各行分开，第一对{ }中的初值1，2，3是0行的3个元素的初值。第二对{ }中的初值4，5，6是1行的3个元素的初值。相当于执行如下语句：
　　int a[2][3]；
　　a[0][0]=1；a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；
　　注意，初始化的数据个数不能超过数组元素的个数，否则出错。
　　⑵ 不分行的初始化
　　int a[2][3]={ 1,2，3，4，5，6};
　　把{ }中的数据依次赋给a数组各元素（按行赋值）。即a[0][0]=1; a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；
　　⑶ 为部分数组元素初始化
　　static int a[2][3]={{1,2},{4}};
　　第一行只有2个初值，按顺序分别赋给a[0][0]和a[0][1]；第二行的初值4赋给a[1][0]。由于存储类型是static，故其它数组元素的初值为0。注：某些C语言系统（如：Turbo C）中，存储类型不是static的变量或数组的初值也是0。
　　static int a[2][3]={ 1,2};
　　只有2个初值，即a[0][0]=1，a[0][1]=2，其余数组元素的初值均为0。
　　⑷ 可以省略第一维的定义，但不能省略第二维的定义。系统根据初始化的数据个数和第2维的长度可以确定第一维的长度。
　　int a[ ][3]={ 1,2，3，4，5，6};
　　a数组的第一维的定义被省略，初始化数据共6个，第二维的长度为3，即每行3个数，所以a数组的第一维是2。一般，省略第一维的定义时，第一维的大小按如下规则确定：
　　初值个数能被第二维整除，所得的商就是第一维的大小；若不能整除，则第一维的大小为商再加1。例如，int a[ ][3]={ 1,2，3，4};等价于：int a[2][3]={ 1,2，3，4};
　　若分行初始化，也可以省略第一维的定义。下列的数组定义中有两对{ }，已经表示a数组有两行。
　　static int a[ ][3]={{1,2},{4}};

举例如下：

1.二维数组的初始化以及遍历二维数组的值，

public class TestArray {
	public static void main(String[] args) {
		/*
		 * 定义了一个一个数组类型为int 数组名为a的二维数组， 二维数组有可以存储6个int类型的数据
		 */
		int a[][] = new int[2][3];
		/*
		 * 对于二维数组a初始化赋值 另一种直接赋值 int a [] [] = {1,2,3,4,5,6};
		 */
		a[0][0] = 1;
		a[0][1] = 2;
		a[0][2] = 3;
		a[1][0] = 4;
		a[1][1] = 5;
		a[1][2] = 6;
		/*
		 * 循环打印出二维数组的数据
		 */
		for (int i = 0; i < a.length; i++) {
			 //for循环中是输出第一行的数据a[i].length代表的是第一行的长度
              for(int j = 0 ;j<a[i].length;j++){
            	  System.out.print(a[i][j]+"\t");
              }
              System.out.println("\n");
		}

	}
}

2.二维数组的应用，主要实现的是一个班级里30个人，十门科目的成绩，通过random来实现赋值，打印出班级每一个人的科目的成绩以及总分和平均分。

public class TestArray {
	public static void main(String[] args) {
		// 定义一个二维数组，30个学生，10个科目的成绩
		int score[][] = new int[30][10];
		// 使用random的随机产生50 - 100 的数字
		for (int i = 0; i < score.length; i++) {
			for (int j = 0; j < score[i].length; j++) {
				score[i][j] = (int) (40 * Math.random() + 40);
			}
		}
		// 打印出30个人的每一个科目的成绩，并且就算总分
		for (int i = 0; i < score.length; i++) {
			double sum = 0;
			double avg = 0 ;
			for (int j = 0; j < score[i].length; j++) {
				System.out.print(score[i][j]+"\t");
				sum = sum + score[i][j];
			}
			avg = sum/10;
			System.out.println("第"+i+"个人的总分："+sum+"\t"+"科目的平均分为"+avg+"\n");
		}
	}
}

数组中相关的ARRAYS类

arrays是对于数组的操作的一个类，使用arrays类必须先引用java的utl包，因为它是在utl包下的，该类中包含了对于数组的排序和搜索等操作。在这里主要介绍arrays的sort（）方法，fill（）方法以及equals（）方法。

1数组的排序：sort方法

sort方法主要的作用是针对数组进行升序排列，该排序算法是一个经过调优的快速排序法。排序的方法有好几种具体的可以参考java的帮助文档。格式如下：

public static void sort(type [] a);

public static void sort(type [] a,fromindex ,toindex);

参数含义为：

a - 排序的数组

fromindex- 要排序的第一个元素的索引（包括）。

toindex - 要排序的最后一个元素的索引（不包括）。

关于数组的引用的一个例子：

import java.util.Arrays;

public class TestArray {
	public static void main(String[] args) {
           int a [] = {1,3,2,6,5,17,11,7};
           System.out.println("排序之前数组：");
           for(int i = 0 ;i<a.length;i++){
        	   System.out.print(a[i]+"\t");
           }
           
          //对于数组进行排序
           Arrays.sort(a);
           System.out.println("\n"+"排序后的数组：");
           for(int i = 0 ;i<a.length;i++){
        	   System.out.print(a[i]+"\t");
           }
	}
}

运行的结果如下：

2数组的填充 fill()方法

fill方法主要的作用是把数据填充到数组中，主要的格式有下面两个：

public static void fill(type [ ] a,type ty);

参数含义：

a - 要填充的数组

ty - 要填充的数值

public static void fill(type [] a, type fromIndex , type toIndex,type ty)

参数含义：

a - 要填充的数组。

fromIndex - 要使用指定值填充的第一个元素的索引（包括）。

toIndex - 要使用指定值填充的最后一个元素的索引（不包括）。

ty - 要存储在数组所有元素中的值。

实验的例子如下：

import java.util.Arrays;

public class TestArray {
	public static void main(String[] args) {
           int a [] = new int [6] ;
           int b [] = new int [6];
           Arrays.fill(a, 4);
           System.out.println("fill(a, val) 的使用;");
           for(int i = 0 ;i<a.length;i++){
        	   System.out.print(a[i]+"\t");
           }
           System.out.println("\n"+"fill(a, fromIndex, toIndex, val)的使用：");
           Arrays.fill(b, 2, 4, 5);
           for(int i = 0 ;i<b.length;i++){
        	   System.out.print(b[i]+"\t");
           }
	}
}

运行结果如图：

对于数组的相关的ARRAYS类的介绍这几个，arrays类中的sort（）方法，fill（）方法的形式有很多中形式，具体的可以参见java的帮助文档，里面介绍的很详细，在这里就不多介绍了。当然了大家也可以看一下arrays的equals（）方法，在博客中没有介绍，这个方法主要的作用是判断两个数组是否相等。