黑马程序员---语句与数组

原创 2013年12月02日 12:56:38

语句与数组

----------- android培训java培训、java学习型技术博客、期待与您交流! ------------

1.流程控制

1.1 顺序结构

顺序结构就是一直执行下去的语句结构。就是我们前面所做的那种。

1.2 判断结构

判断结构可根据不同的判断条件执行不同的语句,判断条件就是关系表达式。

判断结构包括:if条件语句和 switch语句。

1)if语句

    定义 :在某个条件成立的情况下执行某段程序,如果条件不成立,就执行另外的语句。

If 条件语句也分为:简单的if条件语句、if…else…语句和 if .. else if … 多分支语句

if (判断条件)
{
         复合语句...
}
else if(判断条件)
{
         复合语句...
}
...//可以有零个或多个else if语句
else//最后的else语句也可以省略
{
         复合语句...
}

2) switch语句

语句特点:

1.switch语句选择的类型只有四种:byte,short,int,char(JDK 7 新增功能可以放下String类型).

2.case 之间与default 没有顺序。先执行第一个case,没有匹配的case 就执行default.

3.结束switch语句有两种情况,遇到break,执行到switch语句结束。

4.如果匹配的case 或者default没有对应的break,那么程序会继续向下执行,执行可能执行的语句,直到遇到break或者switch结尾结束。

switch(表达式){
      case 常量表达式 1 : 语句序列 1 ;break; //break可有可无
      case 常量表达式 2 : 语句序列 2 ;break; //break可有可无
      case 常量表达式 3 : 语句序列 3 ;break; //break可有可无
     .。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
      case 常量表达式 n : 语句序列 n ;break; //break可有可无
      default            : 语句序列 n + 1 ; break; 最后的break的确可省。
 
}

1.3 循环结构

循环结构:通过循环语句让同一段代码反复执行多次,执行完毕程序才会继续往后运行

1)while

while语句是“当型”循环语句,也就是条件表达式成立时,执行循环体中的内容。其语法格式为:

 while(条件表达式){
            循环体
}
public class TestWhile {	 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int count = 1 ;
        //循环条件
        while(count <= 10 ){                   
            if(count < 10)
            	//循环输出1~10的数
                System.out.print(count + ",");  
            else
                System.out.print(count);
           //count ++ 变量自增
            count ++;                          
        }
    }
}
输出:
1,2,3,4,5,6,7,8,9,10 

注:若有时循环条件难以写出,可直接在“()”填写true(所谓死循环),而后在循环体中加入判断条件,当满足条件时执行break语句就可以跳出循环。

while(true){
   If (条件表达式)break;
}

2) do….while 语句

    do … while先执行一次循环体,然后判断while中的表达式,如果是true继续执行,如果是false则跳出循环。

所以do …while 至少要执行循环体一次。

其语法格式为: 

do{
   循环体
} while(条件表达式)

3) for 语句

语法格式:

 for(表达式1; 表达式2;表达式3){
      语句序列
}

表达式1:该表达式用于初始化循环控制变量,它只在循环开始时执行一次。

表达式2:循环条件表达式,它的类型为boolean,如果表达式的值为true,则执行一次循环体。

表达式3:该表达式用于改变循环体变量的值。

for循环的执行过程如下:

1.执行表达式1,完成某一变量的初始化工作,如 int I = 0;

2.判断表达式2的值,如I < 100。若表达式2的值为true,则执行一次循环体,然后执行第三步,否则,退出循环体结束for循环。

3.执行表达式3,这部分通常执行循环控制变量的修改。

4. 跳转到第二步继续执行循环。

具体如下图:

4)嵌套的循环

当循环结构的循环体中又包含循环结构时,循环结构就呈嵌套的形式。三种循环语句可以相互嵌套。

代码实例:输出九九乘法表

public class TestWhile {
	 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
          for(int i= 1 ; i < 10 ; i ++ ){
        	  //输出九九乘法表的一行
            for(int j = 1 ; j <= i ; j ++){
            	        //输出九九乘法表的一小列  
                        System.out.print(j + "*" + i + "=" + j * i + "   ");   
               
            }  //第一行换一行
            System.out.println();                              
        }
    }
}
输出:
1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12   4*4=16   
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25   
1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36   
1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49   
1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64   
1*9=9   2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81  

5) 循环的跳转 

continue、break、return

continue:结束本次循环,继续执行下一次(只是不执行contine下面的内容)

break:结束循环

return:结束方法

其中continue 、break 是可以用标记来实现跳转的。

用九九乘法表看看标记的作用

public class TestWhile {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		outer: for (int i = 1; i < 10; i++) {
			for (int j = 1; j <= i; j++) {
				if (i == 2)
					// 中断外循环 连空行也不输出
					continue outer; 
				if (i == 3)
					// 中断内循环 这里是因为在这循环里i == 2 , 所以作用相当于break
					continue; 
				if (i == 6)
					// 跳出内循环 只是结束一层循环
					break; 
				if (i == 8)
					// 跳出外循环 跳出时循环已结束
					break outer; 
				// 输出九九乘法表的一列
				System.out.print(j + "*" + i + "=" + j * i + "   "); 
			}
			// 第一循环换一行
			System.out.println(); 
		}
	}
}
输出:
1*1=1   

1*4=4   2*4=8   3*4=12   4*4=16   
1*5=5   2*5=10   3*5=15   4*5=20   5*5=25   

1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49  

4.   函数

定义:函数就是定义在类中的具有特定功能的一段独立小代码。函数也称为方法。

格式

[访问修饰符] [静态修饰符] 返回值类型函数名(参数类型 形式参数1,参数类型 形式参数2){
     执行语句
     return 返回值;
}  

参数说明:

返回值类型:函数运行后的结果的数据类型 ,不需要返回,返回值类型为 void 。

参数类型:是形式参数的数据类型。

实际参数:是一个变量,用于存储调用函数时传递函数的实际参数。

return: 用于结束函数。

返回值:该值会返回给调用者。

函数的特点

1.  定义函数可以将功能代码进行封装。

2.  全类对该功能的复用。

3.  函数只有被调用才会执行。

4.  函数的出现提高了代码的复用性。

5.  对于没有具体返回值的情况,返回值用关键字void表示,那么该函数中的return如果在最后一行可以省略不写。

注意:1.函数中只能调用函数,不可以函数内部定义函数.

      2.定义函数时,函数的结果应该返回给调用者,交由调用者处理。

      3.写代码的规范:主类只负责调用,其他功能在其他类中完成!方便后来的复用。

数组

定义:具有相同数据类型的一组数据的集合。Java中数组是被看作一个对象,程序设计中引入数组可更有效地管理和处理数据。数组分为一维与多维数组。

初始化一维数组,初始化一维数组有两种方法:

1)静态初始化int arr []  = new int []{34,65,87,41};

2)动态初始化int arr [] = new int [4]; arr[0] = 34 ; arr[1] = 68 ; arr[2] =87 ; arr[3] = 41 ;

数组的长度:数组的长度可以通过数组名.length 获得。

数组的遍历:可以通过已知的数组长度来达到遍历数组的目的,也可以通过JDK1.5的新增功能来遍历数组。

数组的下标:数组的下标由0开始,所以数据的最大下标为 (数组名.length -1);

数组常见的异常:如果访问数组时索引越界(小于0或者大于length-1),会抛出异常:ArrayIndexOutOfBoundsExcepion

如果访问数组的引用为空(null),会抛出空指针异常:NullPointerException

public class TestWhile {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = { 54, 41, 74, 96, 87, 45, 65, 41 };
		System.out.println("数组的长度:" + arr.length);
		System.out.println("数组中的元素有:");
		//根据数组长度遍历数组
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length -1) 
				//根据数组下标输出数组成员
				System.out.print(arr[i] + ",");
			else
				System.out.println(arr[i]);		
		}
	}
}
输出:
数组的长度:8
数组中的元素有:
54,41,74,96,87,45,65,41

多维数组:所谓多维数组就是二维和大于二维的数组。多维数组的声明其实就是用一维数组的嵌套声明实现的。拿二维数组来举例,二维数组就是一个所有元素都是一维数组的一组数组。

二维数组也有两个方法初始化:

1)  int [] [] a = new int [2][4]; 

2)  int [] [] a = new int [2] []; a[0] = new int [4] ; a [1] = new int[4];(就是分别跟N个一维数组赋值)

上述代码创建的二维数组就是两个长度为4的一维数组组成。

论坛上看到的题目:求最值和素数

/**
1.输入10个数,求最值。
2.求输入的10个数是中素数之和。
要求:
 1.使用多种方法来操作,比较方法的优缺点。
 2.在每个方法的注释上写清楚编程思路。
 3.一定要使程序清晰。
*/
import java.util.Arrays;
import java.util.Scanner;
public class Practice 
{
     public static void main(String[] args) 
     {
             Practice pra = new Practice();
             pra.manager();
             System.out.println("Hello World!");
     }
     //代理类---其实可以写在main()中,不过想想还是分开吧!
     public  void manager(){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入十个数:");
    int count = 0 ;
        int [] arr = new int[10];
       //循环向数组输出数值
        while (count  < 10)
        {
                System.out.print("输入第" + (count + 1 ) + "个数:" );
                arr[count++] = input.nextInt();
        }
        System.out.println("数组中的素数之和为:" + getPrime(arr));
        //比较大小的有三种方法
        //1.直接比大小,最简单的方法
        System.out.println("输入数最大值为:" + getMax(arr));    
        //2.用数组的sort()方法排序:数组中的下标最大值为最大值
        System.out.println("输入数最大值为:" + getMax2(arr)); 
        //冒泡排序法                
        System.out.println("输入数最大值为:" + getMax3(arr));
        //选择排序法                 
        System.out.println("输入数最大值为:" + getMax4(arr));                 
     }
     //求最佳的方法1,直接遍历比较,返回最大值者
     public int getMax(int [] arr){ 
    	 //设第一个数为最值                         
             int max = arr[0]; 
             //循环比较                                 
         for ( int i = 1; i < arr.length ; i ++ )            
         {
        	 //若大于max,则将其值赋予max
                     if (max < arr[i])                            
                     {
                             max = arr[i];

                     }
         }
             //返回max
             return max;                                     
     }
     //直接用Arrays中的方法实现排序
     public int getMax2(int [] arr){                    
         Arrays.sort(arr);
         //返回数组的最后一位,也就是最大值了
             return arr[arr.length -1];                   
     }
     /*
      *冒泡排序法:一个一个比较大小,大的向极位移动
      *优点就是实现思想比较简单,让人容易了解,比较稳定
      *缺点就是要经常作变量交换,比较耗时
      * */
     public int getMax3(int [] arr){                     
              //一个中间变量,用来作变量交换                                                                                                
             int temp;  
             //遍历数组                                    
          for (int i = 1 ; i < arr.length ;  i ++)      
          {
        	  //比较相邻的幸免于难,较大者则往后
                      for ( int j = 0 ; j < arr.length - i ; j ++ )      
                      {
                    	  //若前一位数比后一位数大,则交换位置
                              if (arr[j] > arr[j+1])                     
                              {
                                      temp = arr[j];
                                      arr[j ] = arr[j + 1];
                                      arr[j + 1] = temp;
                              }
                      }
          }
            //返回最后一位数组,即是最大值
              return arr[arr.length -1];                   
     }
      /*直接排序法,就是遍历数组将最大值放在最后位,次值放在后二位的做法
       * 优点:算法交换的次数比冒泡排序要少,所以比较节省时间
       * 缺点:比较不稳定
       * */
     public int getMax4(int [] arr){                  
             //设中间值,作数据交换之用                                               
             int temp;
             //遍历数组
           for ( int i = 1 ; i < arr.length ; i ++)        
           {          //索引变量
                       int index = 0 ;     
                       //比较各数,排序                         
                       for ( int j = 1 ; j <= arr.length - i ; j ++ )
                       {
                    	   //比较两者,大者下标为index
                               if (arr[j] > arr[index])                 
                               {
                                       index = j;
                               }
                       }
                       temp = arr[arr.length - i]; 
                       //循环结束后再将其进入数据交换                 
                       arr[arr.length - i] = arr[index];
                       arr[index] = temp;
           }
               return arr[arr.length -1];
     }
     //求素数的方法
     public int getPrime(int [] arr ){  
    	 //获取数组中的素数之和                       
             int sum = 0;
             System.out.print("数组中的素数为:");
             //遍历数组
          for ( int i = 0; i < arr.length ; i ++ )            
          {
                      
        	  /*
        	   * 用一个布尔常量表示是否是素数
        	   * 判断数组中的每一个数是否是素数,循环条件为该数的 1 / 2 ,因为除了2外偶数都不是素数,
        	   * 而将该数除以 它一半和之前的数就可以判断它是否为素数
        	   * */
                              boolean isPrime = true;                      
                              for ( int j = 2 ;  j <=  arr[i] / 2; j ++ )  
                                                                           
                              {
                            	      //如果一个数能被它一半以下的数整除,那它就不是素数
                                      if ( arr[i] % j == 0)                     
                                      {
                                    	  //此处的布尔值为不是素数
                                              isPrime = false; 
                                           //一旦能整除退跳出循环,不用再判断                     
                                              break;                               
                                      }

                              }
                              if (isPrime)
                              {
                            	        //输出素数
                                      System.out.print(arr[i] + "\t");  
                                      //将它们的和相加      
                                      sum += arr[i];                        
                              }
                     

          }
              System.out.println("素数之和为:" + sum);
              //返回素数结果
              return sum;                                       
              
     } 
}

3.编程练习

3.1按输入的数字输出相应长度的菱形

import java.util.Scanner;
public class Diamond {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("请输入要输出的菱形的长度:");
		int num = input.nextInt();
		printDiamond(num);
	}
	public static void printDiamond(int num) {
		// 计算菱形的大小,若输入为双数则加一
		if (num % 2 == 0) 
			num++;
		for (int i = 0; i < num / 2 + 1; i++) {
			// 输出左上角的空白
			for (int j = num / 2 + 1; j > i + 1; j--) 
			{
				System.out.print(" ");
			}
			// 输出菱形上半部分实体
			for (int j = 0; j < 2 * i + 1; j++) 
			{
				System.out.print("*");
			}
			System.out.println();
		}
		for (int i = num / 2 + 1; i < num; i++) { 
			// 输出左下角的空白
			for (int j = 0; j < i - num / 2; j++)
			{
				System.out.print(" ");
			}
			// 输出菱形下半部分实体
			for (int j = 0; j < 2 * num - 2 * i - 1; j++) 
			{
				System.out.print("*");
			}
			System.out.println();
		}
	}
}
输出:
请输入要输出的菱形的长度:12
      *
     ***
    *****
   *******
  *********
 ***********
*************
 ***********
  *********
   *******
    *****
     ***
      *
3.2计算1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! ;
public class Diamond {
	public static void main(String[] args) {
		manager();
	}
	private static void manager() {
		// TODO Auto-generated method stub
		//设总和为sum
		double sum = 0;
		//循环加1~1/20之间的和
		for(int i = 1; i <= 20 ; i ++ ){
			//每个阶乘的值
			double partSum = 1 ;
			for (int j = 1; j <= i; j++) {
				//j的阶乘
				partSum *= j;
			}
			sum += 1 / partSum;
		}
		//输出
		System.out.println("1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = " + sum);		
	}
}
输出:

1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = 1.7182818284590455

3.3打印出10行的杨辉三角;

/**
 * 思路:杨辉三角的定义,
 * 一个数前提:端点的数为1.
 *  1、每个数等于它上方两数之和。
 *  2、每行数字左右对称,由1开始逐渐变大。
 *  3、第n行的数字有n项。
 *  由杨光三角的定义可知,此数列应用二维数组来做
 *  且每一个一维数组的长度为其下标加一
 *  由定义可知,除杨辉三角的边界为1外,其里面的元素triangle[i][j] = triangle[i-1][j] + triangle[i][j-1];
 *
 * */
public class YanghuiTriangle
{
    public static void main(String[] args)
    {
    	//调用输出杨辉三角的方法
        triangle();                                                           
    }
    //输出杨辉三角的方法
    public static void triangle(){
    	//新建一个长度为10的二维数组
               int [] [] triangle = new int [10][] ;  
               //按二维数组的长度来循环                      
               for ( int i = 0 ;  i < triangle.length ; i ++ )              
               {
            	   //输出左边的空格
                   for(int j = triangle.length -1 - i; j > 0 ; j --){      
                       System.out.print("  ");
                   }
                   //每次循环都新建一个一维数组,长度为数组元素下标加一
                   triangle [i] = new int[i + 1];                        
                   for ( int j = 0 ; j <= i ; j ++)
                   {
                	   //边界输出1
                       if(i == 0 || j == 0 || j == i )
                             triangle[i][j] = 1;                                          
                       else
                    	   //里面的元素按上面的公式定来计算
                           triangle[i][j] = triangle[i - 1] [j]  + triangle[i -1][j -1];     
                       //输出每个值
                       System.out.print(triangle[i][j] + "  ");
                   }
                   //第一循环换一行
                   System.out.println();
               }
    }
}
输出:
                  1  
                1  1  
              1  2  1  
            1  3  3  1  
          1  4  6  4  1  
        1  5  10  10  5  1  
      1  6  15  20  15  6  1  
    1  7  21  35  35  21  7  1  
  1  8  28  56  70  56  28  8  1  
1  9  36  84  126  126  84  36  9  1 
 ----------- android培训java培训、java学习型技术博客期待与您交流! ------------

相关文章推荐

黑马程序员->基础部分 (2--语句,函数,数组

--------------------android培训、java培训、期待与您交流! -------------------   六6------语句。程序流程控制,6.1,判断结构,6.2,...
  • hotbooy
  • hotbooy
  • 2012年09月26日 21:32
  • 96

黑马程序员----Java语言基础2(语句、函数、数组)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-程序流程控制 判断结构 、选择结构、循环结构判断结构 if语句 三种格式: 1、if(条件表达式)...

黑马程序员——语句 函数 数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------  if 语句:   if(布尔表达式) {            语句表达式 }   if ...
  • ninjass
  • ninjass
  • 2015年04月27日 12:46
  • 104

黑马程序员--C# foreach语句 及动态数组

---------------------- Windows Phone 7手机开发、.Net培训、期待与您交流! ---------------------- 声明数组并打印 ...
  • hehe04
  • hehe04
  • 2012年08月18日 11:07
  • 238

黑马程序员 JAVA初级-编程基础2 流程控制语句 函数 数组

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流! --------------------- -------------...

黑马程序员——>第三天<语句、函数、数组简介>

-------android培训、java培训、期待与您交流------- 01语句while 循环结构 代表语句:while   do while               for whi...

黑马程序员——学习日记之--流程语句与数组知识

——- android培训、java培训、期待与您交流! ———-1—流程控制java程序是按照代码出现的先后顺序执行的,通过流程控制语句可以有效组织代码执行顺序。一:判断语句 if –形式:if ...

黑马程序员-Java语法基础【2】(流程控制语句,方法,数组)

一、流程控制语句 1、选择控制语句(if) 选择结构也被称为分支结构,选择结构有特定的语法规则,代码要执行具体的逻辑运算进行判断,逻辑运算的结果有两个,所以产生选择,按照不同的选择执行不同...
  • sl93323
  • sl93323
  • 2015年09月01日 18:22
  • 238

黑马程序员----Java语法基础(2){语句,函数,数组}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、循环语句 循环语句:Java程序中,有的地方会需要我们重复一段相同的代码,而只改变其中的...

黑马程序员 Java基础1——Java控制语句

Java控制语句 § 利用选择语句结构就可以根据条件控制程序流程,改变程序执行的顺序。 if语句 § if语句的语法格式为: if(条件表达式) s1语句; § 这是最简单的单分支结构。条件表达式的值...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员---语句与数组
举报原因:
原因补充:

(最多只允许输入30个字)