黑馬程式設計師---語句與陣列
語句與陣列
----------- 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
*
***
*****
*******
*********
***********
*************
***********
*********
*******
*****
***
*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.71828182845904553.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