“陣列就是大型倉庫,讓你存放數據;學會它,你就可以處理大量資料了!”
“不過,要操作它也會比較複雜 ”
陣列 Array
陣列 Array 是甚麼?
如果把一個變數想成是一個箱子的話,那麼陣列就是一組箱子,存放許多
個相同型態資料的物件--int, double, String, 以及任何的物件 objects。
存放 50 位學生所有考試科目的成績,變數就必須宣告 50 次,但是陣列只
需要宣告一次。
1
Array 是一種重要常用的 資料結構(Data Structure),各式各樣的程式都會用到陣
列。
依據維度 Dimension 的多寡,陣列有簡單也有複雜:
⚫
1 維陣列 single dimensional array
⚫
2 維陣列 two dimensional array
⚫
多維陣列 multidimensional array
一維陣列 Single dimensional array
1
1
2
存放內容示意圖:
位置
0
1
2
array
10
20
30
int[ ] array = new int[3];
或
int array[ ] = new int[3];
int 為新陣列內存放資料的型態
array 為新陣列的名稱
[3]代表預留 3 個空間(3 個箱子,箱子編號為 0,1,2)
位置/索引/index
2
陣列的索引值是從 0 開始的,因此的陣列元素為
array [0]、array [1]、array [2]。
陣列元素/陣列內容 (element)
array [0]的內容值
⚫
先宣告
再配置
再指定初值
int[] array; 宣告方式 1 建議用這種!
int array[]; 宣告方式 2
array = new int[3]; 配置陣列大小
array[0]=10; //給值
array[1]=20;
2
印出陣列內的每一個元素 element:
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
⚫
一氣呵成:宣告、配置、指定初值
int[] array = {10,20,30};
或
int array[] = {10,20,30};
印出陣列內的每一個元素 element:
3
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
array 名稱
{10,20,30}
--陣列被建立之後,陣列大小即不可再更改
array.length 取得陣列大小
--當陣列被建立時,其元素會指定有預設值
如果是數字基本資料型態,會被指定為預設值 0
如果是 boolean 型態,則會被指定為預設值 false
3
3
4
範例:陣列內容操作:
int[] array = new int[3];
array[0] = 10;
array[1] = 20;
array[0] = array[0]+1;
array[0] += 1;
array[0]++;
array[0] *= 5;
array[2] = array[0]+ array[1];
System.out.println(array[0]);
4
System.out.println(array[1]);
System.out.println(array[2]);
例外錯誤:
陣列
array index out of bounds exception
索引 超出邊界
例外
當陣列的索引不能超出陣列的大小,若超過會有例外訊息出現!!
看到這個錯誤訊息,你就知道該如何排除錯誤了。
範例:使用迴圈印出陣列內容
int[] array = {10,20,30};
for (int i=0; i<array.length; i++)
{
4
System.out.print(array[i]+" ");
}
新式迴圈寫法:類似 C#的 foreach 或是 Python 的 for e in array:
for (int value : array) //新式 foreach 迴圈寫法
{
System.out.print( value +" ");
}
Python 或其他語言也有類似的寫法
for value in array:
print(value)
5
讓我們動手做一些容易理解的範例
範例:陣列內容值加總
int[] array={10,20,30};
int total=0;
for (int i=0; i<array.length; i++)
{
total += array[i];
}
System.out.println(total );
新式迴圈寫法:
int[] array={10,20,30};
int total=0;
for (value in array)
{
total += value;
5
5
6
}
System.out.println(total );
範例:陣列內容值平均:
int[] array={10,20,30};
int total=0;
for (int i=0; i<array.length; i++)
{
total += array[i];
}
System.out.println( (double)total/array.length );
陣列也可當作靜態方法的參數
6
範例:寫一個靜態方法 display(int[] array),可以印出陣列內容
用迴圈印出陣列內容
public static void display(int[]
array)
{
for (int i=0; i<array.length; i++)
{
System.out.print(array[i]+" ");
}
System.out.println();
}
用迴圈印出順序逆轉的陣列內容
public static void displayReverse(int[] array) {
for (int i =array.length-1 ; i >=0; i--) {
System.out.print(array[i] + " ");
}
System.out.println();
}
6
7
另法:新式 foreach 迴圈寫法
public static void display(int[] array)
{
for (int value : array) //新式 foreach 迴圈寫法
{
System.out.print( value +" ");
}
System.out.println();
}
如何呼叫?
public static void main(String[] args)
7
{
int[] array={10,20,30};
display( array ); //沒有回傳值
}
範例:回傳陣列數字之總和 getTotal()
public static int getTotal (int[] array)
{
int total=0;
for (int i=0; i<array.length; i++)
{
total += array[i];
}
return total;
}
如何呼叫?
7
//回傳
public static void main(String[] args)
{
System.out.println( getTotal(array) ); 印出回傳值
}
範例: 改寫成靜態方法--回傳陣列數字之平均
public static double getAvg(int[] array)
{
double avg;
int total=0;
for (int i=0; i<array.length; i++)
{
total += array[i];
}
8
avg = (double)total/array.length ;
return avg; //回傳平均值
}
範例:回傳陣列數字之平均-呼叫 getTotal()
(更佳寫法)
public static double getAvg(int[] array)
{
return (double)getTotal(array)/array.length ; 回傳平均值
}
如何呼叫?
public static void main(String[] args)
{
int[] array = {80,90,70};
System.out.println( getAvg(array) ); 印出回傳值
8
8
9
}
每個人與平均分數差距多少? 列印到小數點下一位
public static void main(String[] args)
{
int[] array = {80,90,70};
double avg = getAvg(array);
for (int i=0; i<array.length; i++)
{
System.out.printf("%.1f ", array[i] - avg);
}
}
9
範例:回傳陣列中最大的數字
public static int max(int[] array)
{
int max=-1;
for (int i=0; i<array.length; i++)
{
if (array[i] > max)
max = array[i];
}
return max;
}
如何呼叫?
public static void main(String[] args)
{
int[] array = {80,90,70};
System.out.println( max(array) ); 印出回傳值
}
9
10
每個人與最高分差距多少?
public static void main(String[] args)
{
int[] array = {80,90,70};
int maxValue = max(array); //最大值都一樣,取得只要呼叫一次
for (int i=0; i<array.length; i++)
{
System.out.printf("%d ",
array[i] - maxValue);
}
}
這樣寫好嗎?是不是呼叫 max(array)太多次了,最大值都一樣,只要呼叫一次,
這樣才有效率,節能減碳喔!
public static void main(String[] args)
10
{
int[] array = {80,90,70};
for (int i=0; i<array.length; i++)
{
System.out.printf("%d ",
array[i] - max(array) );
}
}
OJ 考題練習:每個人的分數與最高分相差多少分
輸入: 第一個數字 3,表示有 3 個人的成績
3 70 90 80
輸出: 與最高分相差多少分
20 0 10
參考程式碼
public static void main(String[] args)
10
{
int[] array;
Scanner input = new Scanner(System.in);
// 讀入分數個數 size,並初始化大小為 size 的 array 陣列
int size = input.nextInt();
array = new int[size];
for (int i=0; i < size; i++)
{
array[i] = input.nextInt();
}
int maxValue = max(array);
for (int i=0; i<array.length; i++)
{
System.out.printf("%d ",
maxValue- array[i] );
}
}
11
OJ 考題練習:與平均分數相差多少分
輸入:
3 90 70 80
輸出: 與平均分數相差多少分,列印到小數點下一位
10.0 -10.0 0.0
範例:統計陣列內數字出現頻率…開始複雜了!
給產品的評分(評價)等地為 1,2,3,4,5 分
有 10 位客戶給評分
統計各等地的人數(次數)(頻率)為多少
public static void main(String[] args) {
int[] grades={2,2,5,1,1,3,4,2,4,5,1};
11
11
int[] freq = new int[6]; //0,1,2,3,4,5
for (int i = 0; i < grades.length; i++) {
freq[ grades[i] ]++; //這個寫法很高竿! grades[i]的內容是評分 1~5
12
}
// 印出頻率次數
for (int i=0; i< freq.length; i++)
{
if (freq[i]!=0)
System.out.println(i+":"+freq[i]);
}
}
grades
12
freq
0
1
2
3
4
5
6
7
8
9
2
2
5
1
1
3
4
2
4
5
0
1
2
3
4
5
0
0
0
0
0
0
分解動作:
以下三種寫法結果相同:
freq[2] = freq[2] +1
freq[2] += 1
freq[2] ++
請問 freq[2]的值變為多少?
12
grades[0]
→ 2
grades[1]
→ 2
freq[
grades[0] ] → freq[
freq[
grades[0] ]++ → freq[
2
]
2
]++
grades[0]是 2,將 2 做為 freq 的索引
13
延伸問題:
如果 freq 的大小規定為 5,則程式如何修改?
int[] freq = new int[5]; //0,1,2,3,4
OJ 考題練習:計算頻率
輸入:
2 2 5 3 -1
輸出:
13
2:2
3:1
5:1
(1)頻率統計利用陣列。
(2)輸入的數字沒必要用陣列存放,讀完統計後即丟。
import java.util.Scanner;
public class FrequencyMain {
public static void main(String[] args) {
int[] freq = new int[6]; //0,1,2,3,4,5
int grade;
Scanner input = new Scanner(System.in);
grade = input.nextInt();
while(grade != -1) {
freq[ grade ]++;
13
grade = input.nextInt();
}
// 印出頻率次數
for (int i=0; i< freq.length; i++)
{
if (freq[i]!=0)
System.out.println(i+":"+freq[i]);
}
}
}
計算隨機數的頻率
14
Description
產生 200 個隨機數字,計算 0-9 數字出現的頻率
輸入:200 (產生隨機數的數量)
輸出:統計 0-9 數字出現的頻率
提示:
(1) 亂數種子固定為 123:
Random rnd = new Random(123);
rnd.nextInt(10);
(2) 輸出格式:System.out.println( i + " quantity is " + counts[i]);
Input
輸入:200 (產生隨機數的數量)
Output
0 quantity is 19
1 quantity is 22
14
14
15
2 quantity is 18
3 quantity is 18
4 quantity is 21
5 quantity is 17
6 quantity is 21
7 quantity is 22
8 quantity is 14
9 quantity is 28
OJ 也可能要求格式如下:
200
0:19
1:22
2:18
15
3:18
4:21
5:17
6:21
7:22
8:14
9:28
package chapter07;
import java.util.Random;
import java.util.Scanner;
public class FreqRandomMain {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
//200
Random rnd = new Random(123);
15
16
int[] freq = new int[10]; //0 1 2 .... 9
for (int i = 1; i <= N; i++) {
freq[rnd.nextInt(10)]++; //0 1 2
...
9
}
for (int i = 0; i < freq.length; i++) {
if (freq[i] != 0) {
System.out.println(i + ":" + freq[i]);
}
}
}
}
範例:將陣列的順序反轉
16
規定你不能使用額外的陣列,也就是只能用 array 本身調換內容。
寫一個靜態方法 reverseArray(),將陣列的順序反轉
0
1
2
3
4
5
10
20
30
40
50
60
觀念: 後半部換到前面
16
前半部換到後面
17
演算法:
我們要關注在索引…
i=0
i=1
i=2
0
1
2
5
4
3
3
索引 i 跟 j 要交換?
要讓以下關係成立的關係式 → 找出這個關係,就成功了
17
i=0
i=1
i=2
j=5
j=4
j=3
i
j = array.length - 1 - i;
→ j = 5-i
如何與新位置的值交換?
兩個人要換座位,規定兩個人的屁股不能同時離開椅子
宣告一個 temp 變數,暫時的椅子,讓人暫時坐一下
temp = array[i];
array[i] = array[j];
array[j] = temp;
先在 main()方法中測試
public static void main(String[] args) {
int array[] = {10,20,30,40,50,60};
int j; //取哪個位置的數?
int temp;
17
4
5
0
// 將前半部 與 後半部 一一交換!
for (int i = 0; i < array.length / 2; i++) {
//j 位置是後面的那個數字
j = array.length - 1 - i;
// i 與 j 位置的值交換
temp = array[i];
array[i] = array[j];
array[j] = temp;
// 把交換的過程列印出來觀察正不正確!
System.out.printf("%d %d\n", i, j);
}
}
寫成方法
18
public static void reverse(int[] array) {
int j; //取哪個位置的數?
int temp;
// 將前半部 與 後半部 一一交換!
for (int i = 0; i < array.length / 2; i++) {
j = array.length - 1 - i;
//與新位置的值交換
temp = array[i];
array[i] = array[j];
array[j] = temp;
// 把交換的過程列印出來觀察正不正確!
System.out.printf("%d %d\n", i, j);
}
}
用迴圈印出陣列內容
public static void display(int[] array)
18
18
{
for (int i=0; i<array.length; i++)
{
System.out.print(array[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
int array[] = {10,20,30,40,50,60};
reverse(array);
display(array);
}
}
19
思考問題:
1.
印出呼叫 reverse()前、後的 array 內容,你發現甚麼?
2.
array 內容是不是不一樣?
3.
甚麼是傳值呼叫?傳參考呼叫?
範例:將陣列的順序打亂
想法: 針對每一個數字,與新位置(隨機產生新位置)的值交換
規定不能使用額外的陣列。
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};
Random rnd = new Random(123); //給定種子
int j;
//某個隨機決定的位置
int temp; //用來暫放數字的變數
19
19
for (int i = 0; i < array.length; i++) {
//隨機產生新位置
j = rnd.nextInt( array.length ); //0,1,2,3,4
//j = (int) (Math.random() * array.length); //0,1,2,3,4
System.out.println(j);
//與新位置的值交換
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
display(array);
}
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
20
System.out.println();
}
範例:將陣列的順序打亂(改寫成方法呼叫)
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};
random(array);
display(array);
}
public static void random(int[] array) {
int j;
int temp;
Random rnd = new Random(123); //給定種子
for (int i = 0; i < array.length; i++) {
//隨機產生新位置
j = rnd.nextInt( array.length ); //0,1,2,3,4
20
20
21
//與新位置的值交換
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
範例:將陣列的順序打亂,規定數字不能位於原來位置
21
請問以下寫法有何不同?
public static void main(String[] args)
{
int[] array = {10,20,30,40,50};
int j;
int temp;
Random rnd = new Random(123); //給定種子
for (int i= array.length-1;
i > 0;
{
//隨機產生新位置
//j =(int)(Math.random()*(i));
j = rnd.nextInt( i );
// i=4 時 j 可能值為 0,1,2,3
// i=3 時 j 可能值為 0,1,2
// i=2 時 j 可能值為 0,1
// i=1 時 j 可能值為 0
// i=0 沒必要!
//與新位置的值交換
temp = array[i];
array[i] = array[j];
21
i--)
array[j] = temp;
}
display( array );
22
}
範例:排列組合
Description
輸入:
陣列大小 N(整數)、各別數值(整數)
輸出:
印出陣列數字的所有組合,陣列中較前位置的數字先印出
22
例如:有一個陣列內容為 int[]numbers = {1, 2, 3},印出以下排列
12
13
23
演算法(步驟):
使用巢狀 for 迴圈,外面的迴圈控制索引 i 印出前面數字 numbers[i],內部的迴
圈控制索引 j 印出後面數字 numbers[j]
System.out.println(numbers[i] + " " + numbers[j]);
Input
輸入 N 個數字(整數),例如:N=3
22
23
各別數值:1 2 3
Output
12
13
輸入:
4
4231
輸出:
42
43
41
23
23
21
31
參考答案巢狀迴圈
public class CombinationMain {
public static void main(String[] args) {
int[] array = {10,20,30}; //10, 20
10, 30
20, 30
for (int i=0; i < array.length; i++)
{
for (int j=i+1; j < array.length; j++)
{
System.out.printf("%d, %d\n",array[ i], array[j]);
}
}
}
}
23
24
字串 String 陣列宣告與 new 使用
⚫
先宣告
再配置
再指定初值
String[] seasons= new String[4];
seasons[0] ="春天";
seasons[1] = new String("夏");
字串初始化較正式的寫法
seasons[2] = new String("秋");
seasons[3] = new String("冬");
24
⚫
一氣呵成:宣告、配置、指定初值
String seasons[] = { "春", "夏", "秋", "冬" };
for (int i=0; i < seasons.length; i++)
System.out.println(seasons[i]);
⚫
字串陣列的列印方法
public static void display(String[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
24
範例:簡單的樸克牌發牌
亂數函數怎麼使用? 你忘記了嗎?
亂數類別 Random
25
Random rnd = new Random(123); //給定種子
rnd.nextInt( 6 );
// 0 1 2 3 4 5
樸克牌花色
String suits[] = { "Hearts", "Diamonds", "Clubs", "Spades" };
for (int i=0; i < suits.length; i++)
System.out.println(suits[i]);
發牌遊戲很複雜,不太適合初學者,講完自訂類別之後,期末若還有時間,再
介紹樸克牌遊戲,使用自訂類別,會比較好寫樸克牌發牌。
25
假設我們的牌有很多付(Deck of cards, 52 張)混和在一起,牌可以重複發。
String suits[] = { "紅心", "鑽石", "梅花", "黑桃" };
int[] points = {1,2,3,4,5,6,7,8,9,10,11,12,13};
int suit;
int point;
// 發 1 張牌
suit = rnd.nextInt(4);
//0,1,2,3
point =rnd.nextInt(13); //0,1,2,3,…,12
System.out.printf("%s%d", suits[suit], points[point]);
// 發 3 張牌 並計算點數和
// 請自行完成點數的加總
for(int i=1; i<=3; i++)
{
suit = rnd.nextInt(4);
25
//0,1,2,3
point =rnd.nextInt(13);
//0,1,2,3,…,12
System.out.printf("%s%d", suits[suit], points[point]);
}
OJ 驗收:樸克牌發牌
隨機發樸克牌 N 張,印出發牌結果,並計算點數和
亂數種子固定為:123
花色與點數陣列已知:
String suits[] = { "紅心", "鑽石", "梅花", "黑桃" };
int[] points = {1,2,3,4,5,6,7,8,9,10,11,12,13};
26
先用亂數決定花色,再用亂數決定點數,按此順序決定某一張牌的內容。
注意:
亂數種子、花色與點數陣列必須與題目給的一樣。
假設:我們的牌有很多付牌混和在一起,牌可以重複發。
輸入: 3
輸出:
梅花 2,黑桃 7,鑽石 8
17
import java.util.Random;
public class PokerGame {
public static void main(String[] args) {
//亂數類別 Random
Random rnd = new Random(123); //給定種子
//隨機發樸克牌 3 張算點數和
26
26
String suits[] = {"紅心", "鑽石", "梅花", "黑桃"};
int[] points = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int suit; //置放花色
int point; //置放點數
int N = 3; //發牌張數
// 發 N 張牌 並計算點數和
int pointSum = 0; //置放點數和
for (int i = 1; i <= N; i++) {
suit = rnd.nextInt(4);
//0,1,2,3
point = rnd.nextInt(13);
//0,1,2,3,…,12
System.out.printf("%s%d,", suits[suit], points[point]);
pointSum += points[point];
}
System.out.println();
System.out.println(pointSum);
}
27
}
方法:可變長度的引數列表
不定數量引數的方法
型別後面的刪節號 (...)
表示要接收此一特定型別不定數量的引數
範例: 計算平均值
public static double average( double… numbers)
{ //把 numbers 當成是一個陣列去操作即可!!
double total = 0.0;
for (double num : numbers)
{
total += num;
}
27
27
return total / numbers.length ;
}
public static void main(String[] args)
{
System.out.println( average(2,3) );
System.out.println( average(2,3,4) );
}
範例:任意個整數的最大公因數
// 2 個參數的 gcd 輾轉相除法,原理請參考迴圈講義
public static int gcd(int x, int y) {
int tmp = 0;
28
while (x % y != 0) {
tmp = y;
y = x % y;
x = tmp;
}
return y;
}
// 3 個參數的 gcd
public static int gcd(int x, int y, int z) {
return gcd(gcd(x, y), z);
}
任意參數的 gcd(),你要寫好多的多載?!
不用喔!
額外寫一個即可…
public static void main( String[] args ) {
28
28
System.out.println(gcd(25,15));
System.out.println(gcd(25,15, 5));
System.out.println(gcd(25,15, 30, 75));
}
// 寫一個兩個參數的 gcd(int x, int y){}
// 寫一個任意參數的 gcd(int...
public static int gcd(int...
numbers){}
numbers){
}
29
多個參數的 gcd()寫法
public static int gcd(int...
numbers) {
int x = ?? ;
for ( … )
{
…
}
return x;
}
gcd(12, 6, 4, 8);
分解步驟
x = 12
29
numbers[0]
x = gcd(12, 6)
x=6
x = gcd(6, 4)
x=2
29
x = gcd(2, 8)
x=2
x = gcd(x, number[i])
return x;
多個參數的 gcd()寫法
public static int gcd(int...
numbers) {
int x = numbers[0] ;
for (int i=1; i< numbers.length; i++)
{
x = gcd(x, numbers[i]); // 神奇的一步驟!!
30
}
return x;
}
完整的版本
public class GcdMultipleParameters {
public static void main(String[] args) {
System.out.println(gcd(25, 15));
System.out.println(gcd(25, 15, 5));
System.out.println(gcd(25, 15, 30, 75));
}
// 2 個參數的 gcd 輾轉相除法,原理請參考迴圈講義
public static int gcd(int x, int y) {
int tmp = 0;
while (x % y != 0) {
tmp = y;
30
30
y = x % y;
x = tmp;
}
return y;
}
public static int gcd(int... numbers) {
int x = numbers[0];
for (int i = 1; i < numbers.length; i++) {
x = gcd(x, numbers[i]); // 神奇的一步驟!!
}
return x;
}
}
31
傳“值”呼叫 vs. 傳“參考”呼叫
傳值呼叫(Call by value, pass by value)
傳“值”呼叫
英文 call-by-value
參數是基本型別數值 int double
將引數複製一份副本(copy)給參數用
就是大家所說的“傳值呼叫”
傳“參考”呼叫(call-by-reference, pass by reference)
傳參考呼叫(call-by-reference)
31
⚫
在方法中可以直接修改引數內容 (修改陣列內容)
⚫
不用複製的大量資料(不用拷貝一份),增進效能
31
32
實例:針對一維成績陣列,寫一個方法可以將每一個人的成績加 10 分。
public class GradeBook
{
public static void main(String[] args)
{
int[] score = {53,42,63};
plus10( score); 呼叫方法
display(score);
}
public static void plus10(int[] array)
{
for (int i=0; i < array.length; i++)
{
array[i]+=10;
32
}
}
public static void display(int[] array)
{
for (int value : array) //新式 foreach 迴圈寫法
{
System.out.print( value +" ");
}
System.out.println();
}
}
問題:
方法用陣列當參數,在方法中對該陣列內容操作,會不會影響到呼叫處的陣列
原來內容?
這就是 call-by-reference 傳參考呼叫的特性!! (參數內容可以被修改!!)
32
當參數類型是一個陣列或是物件時,就是傳參考呼叫
33
傳“值”呼叫 vs. 傳“參考”呼叫更詳細的說明
Java 中所有的引數都是透過以下兩種傳值,也就是可以傳遞兩種型態的值
給所呼叫的方法:
(1)基本型別數值的副本(copy):
int
double 也就是大家所說的“傳值呼叫”
(2)物件 “參照值” “參考值” 的副本(copy): 就是“傳參考(照)呼叫”,與 C++的
“傳址 address (地址 位址)呼叫”,結果相同,達到相同的目的(不過內部運作方
式不同喔!)。
傳參考呼叫必須注意,原始呼叫處的引數可以被任意修改其內容!
問題: 請問以下參數是提供何種方式呼叫?
參數: “陣列型態”
答案: 陣列當參數,是一種“傳參考呼叫”,例如:前面的實例。
33
問題: 請問以下參數是提供何種方式呼叫?
參數:是“物件型態” 就是用 new 一個類別所產生的物件 (下一個章節才會教到
自訂的類別)
答案: “物件”當參數,是一種“傳參考呼叫”
“物件”的參照是一種 “傳參考呼叫”
方法中的參數與呼叫程式傳遞過來的引數,兩者是指向記憶體中相同的物
件。
方法中可以使用物件參照的副本,呼叫此物件的 public 方法,藉此和被參
照的物件互動。
不過,如果方法更改參照型別的參數,讓它指向另一個物件,則只有該則
參數會指到新的物件,存放於呼叫者的變數中的參照,仍然會指向原本的物件
如果你喜歡,“傳參考呼叫” 也可以稱呼為 “傳參考值呼叫” ➔多一個“值”似乎
更貼切於 Java 內部的運作。
方法之回傳值: 陣列
33
參數可以是陣列
34
範例:針對一維成績陣列,寫一個方法可以將每一個人的成績加 10 分,
回傳加分之後的陣列。
public class GradeBook
{
public static void main(String[] args)
{
int[] score = {53,42,63};
display( getPlus10(score) ); //呼叫方法並列印
// 有時候需要用一個變數"儲存"回傳的陣列
int[] result; //不必配置記憶體空間,此陣列名稱會指到另一個陣列
result = getPlus10(score); //指定回傳加分後的陣列參考(位置)給 result
34
display(result); //列印
}
public static int[] getPlus10(int[] array)
{
int[] result = new int[array.length];
for (int i=0; i < array.length; i++)
{
result[i] = array[i]+10;
}
return result;
}
public static void plus10(int[] array)
{
for (int i=0; i < array.length; i++)
{
array[i]+=10;
}
}
34
35
public static void display(int[] array)
{
for (int value : array) //新式 foreach 迴圈寫法
{
System.out.print( value +" ");
}
System.out.println();
}
}
範例:將陣列反過來並回傳反轉之後的結果
寫法 1: 容易理解
public static int[] getReverse(int[] array)
{
35
int[] result = new int[ array.length ];
int j; //取哪個位置的數?
for (int i=0; i < array.length; i++)
{
j = array.length-1
result[i] =
-i
; // index: 4, 3, 2, 1, 0
array[j];
}
return result;
}
public static void main(String[] args)
{
int array = {10, 20, 30};
int[] result;
result = getReverse( array );
display( result );
}
35
//接收回傳的一維陣列
i=0
5-1-0
36
寫法 2: for 迴圈較複雜的寫法
練習一下以下的宣告方式:
int a,b;
public static int[] getReverse(int[] array)
{
int[] result = new int[
for ( int i=0,
array.length
j = array.length-1 ; i <
];
array.length
;
i++, j-- )
result[i] = array[j];
return result;
}
範例:將陣列的順序打亂回傳,呼叫後,引數陣列內容仍保持原樣,不
36
被修改。
注意:前面已經寫好一個 random 函數可以直接呼叫使用,不必再寫一次。
package chapter7;
public class P50_RandomArray {
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50};
display(getRandom(array));
//random(array);
//display(array);
}
public static int[] getRandom(int[] array) {
int j;
int temp;
//用新的陣列來操作,引數陣列不要更動內容
int[] result = new int[array.length];
36
//複製一份給 result
System.arraycopy(array, 0, result, 0, array.length);
random(result); //呼叫 random()把順序打亂!
return result;
}
public static void random(int[] array) {
int j;
int temp;
for (int i = 0; i < array.length; i++) {
//隨機產生新位置
j = rnd.nextInt(array.length);
//與新位置的值交換
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
37
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
OJ 範例: 寫一個方法可以判斷兩個陣列是否完全相同
順序與內容都一樣
輸入:兩個陣列
輸出:兩個陣列相同為 true, 不同則為 true
37
37
38
輸入:
3 10 20 30
3 10 20 30
輸出:
true
輸入:
3 10 20 30
3 15 20 30
輸出:
false
輸入:
4 10 20 30 10
3 10 20 30
輸出:
38
false
public class Ex20_ArrayEquals {
Scanner input = new Scanner(System.in);
public static void main(String[] args) {
//讀第 1 個陣列
int N1=input.nextInt();
int[] array1 = new int[N1];
for (int i=0; i < array1.length; i++)
{
array1[i] = input.nextInt();
}
//讀第 2 個陣列
int N2=input.nextInt();
int[] array2 = new int[N2];
for (int i=0; i < array2.length; i++)
38
{
array2[i] = input.nextInt();
}
//印出比對結果
System.out.println(equals(array1, array2));
}
public static boolean equals(int[] array1, int[] array2) {
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < list1.length; i++) {
if (array1[i] != array2[i]) {
return false;
}
}
39
return true;
}
}
另法:
使用 Arrays 提供的靜態方法,一行搞定。
import java.util.Arrays;
System.out.println(Arrays.equals(array1, array2));
System.arraycopy 複製陣列內容
System 類別的 arraycopy 方法
將一份陣列的內容複製到另一陣列
System.arraycopy(來源, 起始索引, 目的, 起始索引, 複製長度)
39
39
int [] array1 = {1,2,3,4,5};
int [] array2 = new int[5];
System.arraycopy(array1, 0, array2, 0, array1.length);
以下寫法不是複製陣列:
array2 = array1
//參照到同一個陣列物件
範例:自己寫一個 arrayCopy()
void arrayCopy(int[] array1, int[] array2),可以將 array1 的內容 copy 給 array2
(用 for 迴圈可輕鬆搞定!)
public class ArrayCopy {
40
public static void arrayCopy(int[] array1, int[] array2) {
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
}
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = new int[array1.length]; //先配置好 array 的長度
arrayCopy(array1, array2);
display(array2);
}
40
40
41
}
範例:自己寫一個有回傳的 arrayCopy()
自己寫一個 int[] arrayCopy(int[] array),可以將 array 的內容回傳(等同於複製一
份)
public class ArrayCopyV2 {
public static int[] arrayCopy(int[] array) {
int[] result = new int[array.length];
for (int i = 0; i < array.length; i++) {
result[i] = array[i];
41
}
return result;
}
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4, 5};
int[] array2;
array2 = arrayCopy(array1);
display(array1);
display(array2);
}
41
42
}
Arrays 類別:提供許多好用的陣列操作的靜態方法
Arrays 類別,提供了進行常見陣列操作的 靜態 static 方法
其方法包括
⚫
sort,用來排序陣列 (以遞增順序排列元素)
⚫
binarySearch,用來在陣列中進行搜尋
⚫
equals,用來比較陣列內容有沒有相同
⚫
fill,用來把數值放入陣列中
這些方法都有多個多載,以處理參數為基本型別的陣列以及物件的陣列
42
int[] data = {50, 40, 30, 10, 20};
Arrays.sort(data); 陣列內容會被排序!存放位置也變了!
進階陣列處理(資料結構)
資料結構 Data Structure 是二年級的必修課,也是各校研究所入學考科,也是程式的基礎工具,
它非常重要!
Algorithms + Data Structures = Programs
來源
線性搜尋 Linear Search
42
43
在 main()程式
int[] data = {6,4,1,9,7,3,2,8};
System.out.println("Index is " + binarySearch(data, 11));
參考寫法
public class LinearSearch {
43
/** The method for finding a key in the array */
public static int linearSearch(int[] array, int key) {
// 逐一去比對
for (int i = 0; i < array.length; i++){
if (key == array [i])
return i;
// return array index
}
return -1; //
// not found
}
}
另一種寫法也不錯
public static int linearSearch(int[] array, int key) {
int index = -1;
for (int i = 0; i < array.length; i++)
{
if (key == array [i])
{
index=i; // array index
break;
//找到就不必再找了
43
}
}
return index;
}
}
二分搜尋法 Binary Search
課本實例:
控制 3 個指標(low, mid, high)
mid = (low+high)/2
陣列元素有奇數個,剛好整除,mid 是中間的那個元素
陣列元素有偶數個,mid 是小數但取整數
展示找到 key 的步驟
44
key 找不到的情況: low high 位置不正常交錯!
44
44
key is 54
low
key > 50
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]
list
2
mid
4 7 10 11 45
high
50 59 60 66 69 70 79
low
key < 66
list
45
mid
high
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]
59 60 66 69 70 79
low mid
high
[7] [8]
key < 59
list
59 60
low
high
[6] [7] [8]
59 60
在 main()程式
int[] data = {2, 4, 7, 10, 11, 45, 50, 59, 60, 66, 69, 70, 79};
45
System.out.println("Index is " + binarySearch(data, 11));
public static int binarySearch(int[] array, int key) {
int low = 0;
int high = array.length - 1;
int mid = (low + high) / 2;
System.out.printf("low:%d mid:%d high:%d\n", low, mid, high); //印出看看
while ( high >= low ) {
//處理三種可能情況
if ( key < array[mid] )
high = mid - 1; //在左半邊
else if ( key == array[mid] )
return mid;
//找到了 直接離開 不必再進行後面的迴圈
else if (key > array[mid])
low = mid + 1; //在右半邊
mid = (low + high) / 2; //mid 的值依據新的 low, high 去計算
System.out.printf("low:%d mid:%d high:%d\n", low, mid, high); //印出看看
}
45
return -1;
//找不到,就回傳-1
//return -1 - low; //找不到,就回傳 key 該插入之位置
}
疑問: int mid 宣告在 for 迴圈裡面比較好?還是在迴圈外面比較好?
•
If type of variable is simple (int, double, ...) I prefer inside.
Reason: reducing scope of variable.
•
If type of variable is not simple (some kind of class) I prefer outside.
Reason: reducing number of object initialization.
參考: statckoverflow
氣泡排序法(陣列由小排到大 Ascending)
46
*氣泡排序法使用兩個 for 迴圈即可搞定
外部迴圈條件為 for (int i=0; i < array.length ;i++)
內部迴圈條件為 for (int j=0; j < array.length -1 ;j++)
*氣泡排序法使用兩個 for 迴圈—少比較幾次,不做白工(請問為甚麼?)
外部迴圈條件為 for (int i=0; i < array.length-1 ;i++)
內部迴圈條件為 for (int j=0; j < array.lenght -1-i ;j++)
第 1 輪(外層迴圈 i):比較 4 次(內層迴圈 j)
(不要比第 5 次,陣列索引會出界 array index out of bound exception)
46
5
4
3
2
1
5、4 比較,5>4 故互換
4
5
3
2
1
5、3 比較,5>3 故互換
4
3
5
2
1
5、2 比較,5>2 故互換
4
3
2
5
1
5、1 比較,5>1 故互換➔4 3 2 1 5
5 浮出
46
4
3
2
1
5
5 浮出
第 2 輪:比較 3 次
4
3
2
1
5
4、3 比較,4>3 故互換
3
4
2
1
5
4、2 比較,5>3 故互換
3
2
4
1
5
4、1 比較,5>2 故互換
3
2
1
4
5
4、5 比較,不動(這步做白工 )
2
1
4
5
4 浮出
4 浮出
3
第 3 輪:比較 2 次
47
3
2
1
4
5
2
3
1
4
5
2
1
3
4
5
不動
2
1
3
4
5
不動
1
3
4
5
3 浮出
3 浮出
2
第 4 輪:比較 1 次
2
1
3
4
5
1
2
3
4
5
不動
1
2
3
4
5
不動
1
2
3
4
5
不動
2
3
4
5
2 浮出
2 浮出
1
47
47
48
第 5 輪:比較 0 次(這輪做白工)(最後一輪不必做,因此,只要做 n-1 輪即可)
1
2
3
4
5
不動
1
2
3
4
5
不動
1
2
3
4
5
不動
1
2
3
4
5
不動
2
3
4
5
1 浮出
1 浮出
1
⚫
如何交換陣列內容?
temp = data[j];
48
j 位置的人到 temp 暫坐
data[j] = data[j + 1];
data[j + 1] = temp;
⚫
temp 坐到 j+1 位置
參考答案
public class MyArrays {
public static void sort(int[] array) {
int temp;
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array [j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
public static void display(int[] array) {
48
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
49
System.out.println();
}
public static void main(String[] args) {
int[] data = {5, 4, 3, 1, 2};
MyArrays.sort(data);
display(data);
}
}
氣泡排序法:印出排序之詳細過程
請改寫前述氣泡排序法,將排序的詳細過程(每一輪 每一次比較之結果)列印在
49
畫面。
氣泡排序法時間複雜度是 O(𝒏𝟐 )
*氣泡排序法之時間複雜度 Big O 是 O(𝑛 2 ),請問為甚麼?
時間複雜度(time complexity): Big O
O 是 ‘Order’ 用來表示一個演算法
(algorithm)的執行效率
n 表示陣列長度,陣列的元素越多,排序就越花時間,所以,時間複雜度與 n
的大有有關。
但是,為甚麼是𝑛 2 ?
→ 兩個迴圈執行次數: n*n
由大排到小 Descending 氣泡排序法
public static void sortDescend (int[] array) {
int temp;
49
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array [j]
<
array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
漂亮好用的排序方法:透過參數決定由大或由小兩種排序法
50
活用以前學過的方法多載,開發一個專業有水準的工具程式!
請提供多載方法,讓使用者可以這樣呼叫:
排序:由小到大
MyArrays.sort(data)
or
MyArrays.sort(data, 0)
or
MyArrays.sort(data, MyArrays.ASCEND)
→這樣寫最佳!
or
MyArrays.sort(data,"ascend")
排序:由大到小
MyArrays.sort(data, 1)
or
MyArrays.sort(data, MyArrays.DESCEND)
or
MyArrays.sort(data,"descend")
50
→這樣寫最佳!
50
51
在 MyArrays 中先定義: 由小到大 ASCEND=0、由大到小 DESCEND=1 與兩種
代號
這樣呼叫:
MyArrays.sort(data, MyArrays.ASCEND)
參考答案
public class MyArrays {
// 定義類別(靜態)變數,讓使用者方便使用,不必記憶數字代碼
public final static int ASCEND = 0;
public final static int DESCEND = 1;
51
// 版本 1
public static void sort(int[] data, int sortedMethod) {
switch (sortedMethod) {
case ASCEND: // 寫 case 0:也可以,不過較不清楚!
sort(data);
break;
case DESCEND:
sortDescend(data);
break;
default:
System.out.println("未執行排序");
break;
}
}
// 版本 2
public static void sort(int[] data, String sortedMethod) {
if (sortedMethod.equals("ascend")) {
sort(data);
} else if ("descend".equals(sortedMethod)) {
sortDescend(data);
51
} else {
System.out.println("未執行排序");
}
}
public static void sort(int[] data) {
int temp;
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] > data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
52
}
// 以下這個方法若不公開,可以設定為 private
public static void sortDescend(int[] data) {
int temp;
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] < data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}
public static void display(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
52
52
public static void main(String[] args) {
int[] data = {50, 40, 30, 10, 20};
//MyArrays.sort(data);
//MyArrays.sort(data, MyArrays.ASCEND);
MyArrays.sort(data, "ascend2");
display(data);
}
}
在另外一個類別程式中呼叫:
import static chapter07.MyArrays.display; //靜態方法 import
public class MyArraysTest {
public static void main(String[] args) {
53
int[] data = {50, 40, 30, 10, 20};
MyArrays.sort(data);
//MyArrays.sort(data, MyArrays.ASCEND);
//MyArrays.sort(data, "ascend");
//MyArrays.sortDescend(data); //改成 private 方法,這行會報錯嗎?
display(data); // MyArrays.display(data); 這樣寫也可
}
}
OJ 各種考題
⚫
課本習題:
7.9 寫一個方法回傳陣列中最大的一個數
7.11 寫一個方法計算陣列的平均數。寫一個方法計算陣列的標準差。
53
53
課本習題
1.
隨機產生骰子的點數 1~6 的整數 60 萬個,統計各數字出現的次數(頻率)
2.
寫一個方法 boolean isSorted(int[] array) ,可以判斷陣列是否由小排到大
3.
寫一個方法 boolean equals(int[] array1, int[] array2),可以判斷兩個陣列是否
內容完全相等
⚫
寫一個方法回傳對應的分數 10 個等級陣列
等第的的計算如下:
54
分數
等第
100
10
90
9
80
8
70
7
…
10 以下 0
輸出畫面如下:
Grade 1 : 5
Grade 2 : 3
Grade 10: 1
public static void main(String[] args)
{
int score = {96, 83, 77};
int[] grade; //宣告一個新陣列名稱,不必 new,只用到其名稱
grade = getGrade( score ); 接收回傳的分數等級的一維陣列
display( grade );
printLevel( score );
}
54
54
⚫
public static int[] getGrade(int[] array) {
int[] feq = new int[11];
55
for (int i = 0; i < array.length; i++) {
freq[ array[i] / 10 ]++; //這個寫法很高竿!
}
return freq;
//回傳一個陣列回去
}
public static void printGrade(int[] array) {
int[] levels = new int[11];
for (int i = 0; i < array.length; i++) {
levels[ array[i] / 10 ]++; //這個寫法很高竿!
}
display( levels );
//列印結果陣列
}
55
public static void display(int[] array)
{
for (int i=0; i<array.length; i++)
{
System.out.print(array[i]+" ");
}
System.out.println();
}
⚫
OJ 考題:氣泡排序
1.
寫氣泡排序法 sort()可以由小到大
排序:由小到大
public static void sort(int[] array)
2.
改寫氣泡排序法 sortDescend()可以由大排到小(這不能多載,必須另取一個
名字為 sortDescend(),為甚麼?)
55
排序: 由大排到小
public static void sortDescend(int[] array)
56
MyArrays.sortDescend(data)
3.
寫一個氣泡排序法 sort()的多載方法,提供第二個參數,決定由大排到小或
是由小到大
public final static int ASCEND=0;
public final static int DESCEND=1;
public static void sort(int[] array, int sortedMethod)
排序:由小到大
56
MyArrays.sort(data, MyArrays.ASCEND)
排序:由大到小
MyArrays.sort(data, MyArrays.DESCEND)
如何判斷 sortedMethod?
if ( sortedMethod == ASCEND )
{
由小到大! 呼叫 sort()
} else if ( sortedMethod == DESCEND )
{
由大到小! 呼叫 sortDescend()
}else
{
System.out.println("參數不正確");
return;
}
56
57
4.
實作二分搜尋法 binarySearch( int[] array )
⚫
請先判斷該陣列是否為已排序(由小到大!),若是未排序,則列印"請先排序
資料,資料未經排序,搜尋結果將會不正確!"
public static boolean isSorted(int[] array)
你已經寫過這隻程式!這時可以派上用
場了!
⚫
可以印出每個回合之 low, high 的值,藉以觀察搜尋的過程。
陣列名稱是一個參考(reference)
57
⚫
展示情況 1
int[] array1 = {1,2,3};
int[] array2;
array2 = array1;
不是把 array1 拷貝給 array2 的意思!!
是把 array1 的參考指定給 array2!!
也就是 array2 指到(參考到)array1 的位置
array2 的內容現在是甚麼?
當然是
{1,2,3}
array1
array2
{1,2,3}
57
對 array2 操作就等於是對 array1 操作 這是你學習陣列不可不知道的事!
⚫
展示情況 2
int[] array1 = {1,2,3};
int[] array2 = {4,5,6};
array2
array1
{1,2,3}
以下這行的做甚麼?
58
array2 = array1;
array2 的內容現在是甚麼?
當然是
{1,2,3}
{4,5,6}被它拋棄了!
array1
array2
{1,2,3}
以指令的的輸出是甚麼?
if ( array2 == array1)
System.out.println("兩個陣列的位置(參考值)相等");
答案會是甚麼?
58
{4,5,6}
58
59
判斷兩個陣列之內容是否相等?
int[] array1 = {1,2,3};
int[] array2 = {1,2,3};
if ( array2 == array1)
System.out.println("兩個陣列相等??");
答案會是甚麼? false
兩個陣列內容一樣,為甚麼得到 false?
這樣比對是沒用的!
59
以下兩行的輸出是甚麼?
System.out.println(array1);
System.out.println(array2);
[I@15db9742
[I@6d06d69c
➔這是甚麼東東亂碼? 這就是傳說中的 ‘參考’ ‘reference’
可以這樣去想: 陣列的地址、位址、address、參考、 reference
array2
array1
{1,2,3}
if ( array2 == array1)不是 用來判斷陣列內容是否相等!
59
{1,2,3}
是用來判斷兩個陣列的位置(參考值) 是否相等!
60
那麼,你要如何寫一個方法可以判斷兩個陣列是否相等?? 參看前面介紹過的靜
態方法。
ArrayList 的用法
ArrayList 集合
類似陣列
動態調整大小
它們會在執行時自動增加大小,以容納更多元素
當你要存放的個數不固定,或是事先不知道時,可以用 ArrayList 較方便。
60
main()方法之參數—就是一個字串陣列
…終於看懂
String[] args 這個奇怪的東東…
arguments: 引數
爭論
爭辯
範例:請在 command line(Console)(Terminal 終端機)環境下執行兩個
數相加
(java 環境設定,請參考講義:"如何在 CommandLine 執行 Java 程式")
(1) 使用文書編輯器編輯以下程式碼,存成檔案 Plus.java
(不要寫套件比較方便執行)
(2) 在檔案目錄之下,進入 terminal 畫面
60
(3) 在命令列輸入:
java Plus.java 3 5
會得到相加結果: 8
public class Plus {
public static void main( String[] args ) {
//檢查是否輸入兩個數?
if (args.length != 2) {
System.out.println(
"請輸入兩個數!");
System.exit(0);
}
// 運算並列印
int result = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
61
System.out.println(result);
}
}
執行方式 2
(1) 先編譯 Plus.java
javac Plus.java
(2) 執行編譯後的 class 字元碼(byte code)
java Plus 2 3
會得到相加結果: 8
61
61
62
若有中文字,則請更換編碼為 UTF-8,否則會有錯誤!(微軟內定編碼系統為
MS950)
62
C:\...>javac -encoding UTF-8 Plus.java
若有定義套件 mymath,則程式碼要放在套件(卷夾)內,執行.java 檔案的方式不
影響,但是執行字元碼的方式不一樣
編譯:
javac .\mymath\Plus.java
或在 mymath 目錄中編譯
javac Plus.java
執行時,必須確定當前目錄之下,有一個子目錄 mymath:
java mymath.Plus 3 5
62
範例:command line 計算機
public class Calculator {
/** Main method */
public static void main(String[] args) {
// Check number of strings passed
if (args.length != 3) {
System.out.println(
"Usage: java Calculator operand1 operator operand2");
System.exit(0);
}
// The result of the operation
int result = 0;
// Determine the operator
int n1 = Integer.parseInt(args[0]);
int n2 = Integer.parseInt(args[2]);
63
switch (args[1].charAt(0)) {
case '+': result = n1 + n2;
break;
case '-': result = n1-n2;
break;
case '*': result = n1 * n2;
break;
case '/': result = n1 / n2;
}
// Display result
System.out.printf("%s%s%s=%d", args[0],args[1],args[2], result);
}
}
⚫
63
設定 Java 路徑的方式:
63
64
64
64
編輯 Path
65
新增 java bin 路徑
65
65
0
You can add this document to your study collection(s)
Sign in Available only to authorized usersYou can add this document to your saved list
Sign in Available only to authorized users(For complaints, use another form )