JAVA的Math用法、循环控制语句、break、continue、双重循环、数组的常用方法、数组的遍历

Math用法

上一篇文章我们讲过了Scanner和Random两个工具类的常用方法，那今天我们来说一下Math类的用法，Math类包含了我们基本数据函数所需的方法，一共分为：三角函数、指数函数方法和服务方法。除此之外，还提供了一些其他的用，可以直接使用Math.random来进行使用，不需要再去创建对象，我们来看一下。

三角函数

public static double sin(double radians)             //正弦函数  
public static double cos(double radians)             //余弦函数  
public static double tan(double radians)             //正切函数  
public static double toRadians(double degree)        //度转换成弧度  
public static double toDegree(double radians)        //弧度转换成度  
public static double asin(double a)                  //反正弦  
public static double acos(double a)                  //反余弦  
public static double atan(double a)                  //反正切

指数函数方法

public static double exp(double x)                   //e^x  
public static double log(double x)                   //ln（x）  
public static double log10(double x)                 //log 10（x）  
public static double pow(double a,double b)          //a^b  
public static double sqrt(double x)                  //√x 

取整方法

public static double ceil(double x)                 // 得到不小于某数的最大整数  
public static double floor(double x)                //得到不大于某数的最小整数  
public static double rint(double x)                 //返回值为最接近参数的double值。如果这两个整数的double值都同样接近，就取偶数  
public static int round(float x)                    //返回（int）Math.floor（x+0.5）  
public static long round(double x)                  //返回（long）Math.floor（x+0.5）

min,max,abs,random方法

• Math.min()返回两个数的最小值
• Math.max()返回两个数的最大值
• Math.abs()返回一个数的绝对值
• Math.random()可以生成大于等于0.0且小于1.0的double型随机数

循环控制语句

例如现实世界中我们开车遇到红绿灯会知道红灯停，绿灯行，Java中也是如此，有些代码必须满足条件才能被执行。对一些条件进行判断，从而来确定执行哪些代码的语句，就是选择结构语句。

for循环

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新){
    //代码语句
}

关于 for 循环有以下几点说明：

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式。循环执行上面的过程。
  例子如下：

public class Test {
   public static void main(String args[]) {
 
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}

运行结果如下：

while循环

while是最基本的循环，它的结构为，下面我们来看一下

while语句

语法定义格式如下：

while( 布尔表达式 ){
  //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。例子如下：

public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

运行结果如下：

do…while语句

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
while和do…while的区别：

• do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
  语法定义格式如下：

do {
       //代码语句
}while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
实例如下：

public class Test {
   public static void main(String args[]){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

运行结果如下：

跳出循环关键字

在我们循环结构里有两个关键字，一个是break和continue，它们两个都是跳出循环关键字，既然都是都是跳出循环体的关键字，那么怎么来使用呢？又有什么区别呢？

breeak关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
语法格式：

break;

break 的用法很简单，就是循环结构中的一条语句，我们来举例说明一下

public class Test {

   public static void main(String args[]) {
      int [] numbers = {1, 2, 3, 4, 5};
      for(int x : numbers ) {
         // x 等于 3 时跳出循环
         if( x == 3 ) {
            break;
         }
         System.out.print( "x=" + x );
         System.out.println();
      }
   }
}

运行结果如下：

continue关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳出当前循环，提前进入下一次循环，无论是for循环还是while、do…while循环都是一样的。
语法格式：

continue;

下面我们举例说明一下：

public class Test {

   public static void main(String args[]) {
      int [] numbers = {1, 2, 3, 4, 5};
      for(int x : numbers ) {
         // x 等于 3 时跳出循环
         if( x == 3 ) {
            continue;
         }
         System.out.print( "x=" + x );
         System.out.println();
      }
   }
}

运行结果如下：

break和continue我们举的例子都是一样的，大家可以看一下运行结果，就一目了然了。

双重循环

在我们循环结构中最重要的就是我们的双重循环（多重循环），双重循环的意思就是在一个循环体里面在去嵌套一个循环结构，我们称之为双重循环。
语法格式：

for(int i=1; i<5; i++){
	for(int j=1; j<5; j++){
		//代码块
	}
}

对于双重循环有一个经典的案例，那就是九九乘法表，我们要是弄清楚这个案例，那就说明双重循环就弄清楚了，当然网上有很多关于双重循环的题目，大家可以去搜索一下，去做一做，下面是九九乘法表的代码：

public class MultiplicationTable {
    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");// \t 跳到下一个TAB位置
            }
            System.out.println();
        }
    }
}

运行结果如下：

数组

我们今天粗略的讲解一下数组的含义，如何声明定义，如何去使用数组里面的内容。

数组的定义

什么叫做数组，就是用来存储一堆数据类型一样的容器

数组的特点

那数组的特点有什么呢？
我们用五个字来总结，那就是“定长且连续”，何为定长，就是在我们声明一个数组的时候需要给数组一个长度，长度一旦给了，就不能再去修改了。
那什么又叫连续呢，不是我们数组里面的内容是连续的，而是我们数组有一个下角标也就是索引，这个索引是连续，都是从0开始的，一直到数组定义的长度为止。
那为什么索引又是从0开始的呢？正常数数都是从1开始的，没有从0开始的呀！那是因为我们计算机最开始只识别0和1，而且计算资源特别的匮乏，0标号的写法节省编译时间，效率更快，在支持指针的语言中，标号被视作是偏移量，因此从0开始更符合逻辑。

数组的声明

那数组如何进行声明呢？数组的声明有一个特点的符号“[]”，当我们看到这个符号的时候说明这个是数组。

数据类型[] 数组名;  --推荐使用
数据类型 数组名[];
		数据类型 : 指明数组中存放的每一个数据的类型

数组的初始化

那我们又是如何进行初识化的呢？我们数组的初始化有两种，一种是静态初始化，一种是动态初始化。接下来我们看一下两种不同的初始化是什么样子的。

静态初始化

静态初始化：创建的同时就要进行赋值

1. 数据类型[] 数组名 = new 数据类型[]{值1,值2,值3…};
2. 数据类型[] 数组名 = {值1,值2,值3…};
   第二种写法是简略写法，不够灵活，但是简单。

public class Test{
	
	public static void main(String[] args){
		int[] array = new int{1,2,3}
		int[] array1 = {1,2,3};
	}
}

这样可以清晰的看到，我们静态初识化能清晰的看到我们的长度和数组中的元素。
静态初始化优缺点：

• 优点：清楚指导数组的长度和元素
• 缺点：声明后就进行初始化，否则不能使用，而且不够灵活

动态初始化

动态初始化:先根据数据的长度创建一个数组,但是没有赋值,确定数据的时候再赋值，语法格式如下：

• 数据类型[] 数组名 = new 数据类型[长度n];

那与我们静态初始化不同的是：我们在声明时，只要给定长度就可以了，在我们想要使用的时候，在赋值就ok了，代码如下：

public class Test{
	
	public static void main(String[] args){
		int[] array = new int[3];
		//我们要进行使用了，开始赋值
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
	}
}

数组的两个常用方法

我们只说数组中最近本的两个常用的方法：一个是如何往数组中添加值，一个是看数组长度的方法

如何在数组中添加值

语法格式如下：

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

这是添加的格式，但是如果数组长度为3，你非要添加第4个值的时候，那么程序就会抛出异常：ArrayIndexOutOfBoundsException 数组索引越界异常，大家需要注意一下。

如何查询数组的长度

语法格式如下：

int[] array = new array[3];
int num = array.length;

我们可以利用.length方法去查看数组的长度。

数组遍历

数组遍历有两种方式，方式一：for循环遍历；方式二：增强for循环/foreach，接下来看一下这样中遍历的不同之处。

for循环遍历

代码如下：

public class Test{
	
	public static void main(String[] args){
		int[] array = new int[3];
		//我们要进行使用了，开始赋值
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		
		//for循环遍历，因为我们数组的索引是从0开始的，所以i要等于0
		for(int i=0; i<array.length; i++){
			System.out.println(array[i]);
		}
	}
}

运行结果如下：

增强for循环/foreach

语法格式如下：

for(数组的数据类型  你起的名字 ： 原数组的名字){
	System.out.println(你起的名字);
}

代码如下：

public class Test{
	
	public static void main(String[] args){
		int[] array = new int[4];
		//我们要进行使用了，开始赋值
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		array[3] = 4;
		
		//增强for，因为我们数组的索引是从0开始的，所以i要等于0
		for(int arr : array){
			System.out.println(arr);
		}
	}
}

运行结果如下：

两个循环的区别

两个循环各有各的好处，那么它们的优缺点是什么呢？

• for循环：它在循环遍历的时候效率没有增强for快，但是如果我们想把数组中的值拿出来运算和或者其他用处的时候，是可以让我们把值取出来的。可以有实际性的操作。
• 增强for：它的遍历速度快，但是不能把数组中的值取出来进行修改操作，它能把数组里的内容拿出来看看或者更换位置，以及比大小，因为它不能取出值所对应的索引。

更多内容可以参考 API 文档：http://www.runoob.com/manual/jdk1.6/