黑馬程式設計師---語句與陣列
語句與陣列
----------- 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學習型技術部落格期待與您交流! ------------