數組作業
一、 填空題
1. 數組會在內存中開闢一塊____________的空間，每個空間相當於之前的一個變量，稱爲數組的元素。數組的長度一經確定，就無法再改變。
2. 要獲取一個數組的長度，可以通過____________屬性來獲取，但獲取的只是爲數組分配的空間的數量，而不是數組中實際已經存放的元素的個數。
3. ____________僅僅是給出了數組名字和元素的數據類型，要想真正的使用數組還必須使用new關鍵字爲它分配內存空間。
4. 創建數組後，系統會給每一個數組元素一個默認的值，如String類型元素的默認值是____________。
5. 在Java中有二維數組int [ ] [ ] array={{1,2,3},{4,5}} ，可以使用____________得到二維數組中第二維中第一個數組的長度。
6. 數組元素下標(或索引)的範圍是____________。
二、 選擇題
1. | 在Java中，以下程序段能正確爲數組賦值的是（ ）。（選擇二項） | |
|
|
|
| A | int a[]={1,2,3,4}; |
| B. | int b[4]={1,2,3,4}; |
| C. | int c[];c={1,2,3,4}; |
| D. | int d[];d=new int[]{1,2,3,4}; |
2. | 數組元素的索引可以是（ ）。（選擇一項） | |
|
|
|
| A | 整型常量 |
| B. | 整型變量 |
| C. | 整型表達式 |
| D. | 以上都可以 |
3. | 已知表達式int [] m={0,1,2,3,4,5,6};下面（ ）表達式的值與數組最大下標數相等。（選擇一項） | |
|
|
|
| A | m.length() |
| B. | m.length-1 |
| C. | m.length()+1 |
| D. | m.length+1 |
4. | 在Java中，以下定義數組的語句正確的是（ ）。（選擇二項） | |
|
|
|
| A | int t[10]=new int[ ]; |
| B. | char [ ]a=”hello”; |
| C. | String [ ] s=new String [10]; |
| D. | double[ ] d [ ]=new double [4][ ]; |
5. | 在Java中,下面代碼的輸出結果爲（ ）。（選擇一項） | |
| public static void main(String[] args) { int[] arrA = { 12, 22, 8, 49, 3 }; int k = 0; int len = arrA.length; for (int i = 0; i < len; i++) { for (int j = i + 1; j < len; j++) { if (arrA[i] > arrA[j]) { k = arrA[i]; arrA[i] = arrA[j]; arrA[j] = k; } } } for (int i = 0; i < arrA.length; i++) { System.out.print(arrA[i]); if (i < arrA.length - 1) { System.out.print("，"); } } } | |
|
|
|
| A | 3，8，12，22，49 |
| B. | 12，22，8，49，3 |
| C. | 49，22，12，8，3 |
| D. | 編譯錯誤 |
6. | 分析下面的Java源程序，編譯後的運行結果是（ ）。（選擇一項） | |
| import java.util.*; public class Test { public static void main(String[ ] args) { int [ ] numbers=new int[ ]{1,2,3}; System.out.println(Arrays.binarySearch(numbers, 2)); } } | |
|
| 輸出 |
| A | 輸出：0 |
| B. | 輸出：1 |
| C. | 輸出：2 |
| D. | 輸出：3 |
7. | 以下選項中關於Java中方法的可變參數的說法正確的是（ ）。（選擇二項） | |
|
|
|
| A | 可變參數是JDK1.5增加的內容，用來表示方法的形參 |
| B. | 一個方法可以沒有可變參數，可以有1個或者多個可變參數 |
| C. | 可變參數可以被當作數組參數來處理 |
| D. | 可變參數對應的實參可以1個，2個，多個，但不能0個，還可以是一個數組 |
8. | 以下選項中能夠正確創建一個數組的是（ ）。（選擇二項） | |
|
|
|
| A. | float []f[] = new float[6][6]; |
| B. | float f[][] = new float[][]; |
| C. | float [6][]f = new float[6][6]; |
| D. | float [][]f = new float[6][]; |
9. | 下面的數組定義哪些是正確的？（ ）。（選擇二項） | |
|
|
|
| A | int a[][] = new int[3,3]; |
| B. | int a[3][3] = new int[][]; |
| C. | int a[][] = new int[3][3]; |
| D. | int []a[] = new int[3][3]; |
三、 判斷題
1. 數組可以聲明爲任何數據類型，包括任何基本數據類型和引用數據類型。（ ）
2. 數組的長度是確定的，數組一旦被創建，它的大小就是不可以改變的。但是其元素類型可以是不同類型，允許出現混合類型。（ ）
3. 數組中的元素的類型必須是相同的，並且數組中的元素是有序的。（ ）
4. 聲明數組並分配空間組的每個元素將會賦予初始值。（ ）
5. 創建數組後，系統會給每個數組元素一個默認值，如double型元素的默認值是0.0。（ ）
6. 數組的主要優點是按照索引查找某個元素效率高，同時按照元素值查詢某個元素效率也很高，但是添加和刪除元素需要大量移動元素，效率低下。（ ）
7. 數組的某個元素被傳遞給一個方法並被該方法修改，當被調用方法執行完畢時，這個元素中含有修改過的數值。（ ）
8. Java允許創建不規則數組，即Java多維數組中各行的列數可以不同。（ ）
9. 對於數組int[][] t={{1,2,3},{4,5,6}}來說，t.length等於3，t[0].length等於2（ ）
10. 數組是引用類型，數組也是對象。（ ）
四、 簡答題
1. 數組的特點。
2. 數組的優缺點
3. 冒泡排序的算法。
4. 數組的三種初始化方式是什麼?
五、 編碼題
1. 數組查找操作：定義一個長度爲10 的一維字符串數組，在每一個元素存放一個單詞；然後運行時從命令行輸入一個單詞，程序判斷數組是否包含有這個單詞，包含這個單詞就打印出“Yes”，不包含就打印出“No”。
2. 獲取數組最大值和最小值操作：利用Java的Math類的random()方法，編寫函數得到0到n之間的隨機數，n是參數。並找出產生50個這樣的隨機數中最大的、最小的數，並統計其中>=60的有多少個。
提示：使用 int num=(int)(100*Math.random());獲取隨機數
3. 數組逆序操作：定義長度爲10的數組，將數組元素對調，並輸出對調前後的結果。
思路：把0索引和arr.length-1的元素交換，把1索引和arr.length-2的元素交換…..
只要交換到arr.length/2的時候即可。
{1, 2, 3, 4, 5, 6} //0 ---5 1--4 2--3 arr[i] <==> arr[arr.length - 1 - i]
4. 合併數組操作：現有如下一個數組： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求將以上數組中值爲0的項去掉，將不爲0的值存入一個新的數組，生成的新數組爲： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}
思路： 確定出不爲0的個數，這樣可以開闢新數組；從舊的數組之中，取出內容，並將其賦給新開闢的數組。
5. 二分法查找操作：使用二分法查找有序數組中元素。找到返回索引，不存在輸出-1。
分析：二分法查找的前提是數組有序。
假如有一組數爲3，12，24，36，55，68，75，88要查給定的值24.可設三個變量front，mid，end分別指向數據的上界，中間和下界，mid=（front+end）/2.
1) 開始令front=0（指向3），end=7（指向88），則mid=3（指向36）。因爲mid>x，故應在前半段中查找。
2) 令新的end=mid-1=2，而front=0不變，則新的mid=1。此時x>mid，故確定應在後半段中查找。
3) 令新的front=mid+1=2，而end=2不變，則新mid=2，此時a[mid]=x，查找成功。
4) 如要查找的數不是數列中的數，例如x=25，當第三次判斷時，x>a[mid]，按以上規律，令front=mid+1，即front=3，出現front>end的情況，表示查找不成功。
6. 二維數組遍歷求和操作：用二重循環求出二維數組b所有元素的和：
int[][] b={{11},{21,22},{31,32,33}}
For(int i = 0; i < b.length; i++){
For(int j = 0; j < b[i].length; j++)
Sum+=b[i][j];
}
六、 可選題
1. 生成一百個隨機數，放入數組，然後排序輸出。
2. 題目：輸入某年某月某日，判斷這一天是這一年的第幾天？
分析：以3月5日爲例，先把前兩個月的加起來，然後再加上5天即本年第幾天，特殊情況，閏年且輸入月份大於3需考慮多加一天。可定義數組存儲1-12月各月天數。
3. 使用二分法查找有序數組中元素。找到返回索引，不存在輸出-1。使用遞歸實現
4. 數組A：1，7，9，11，13，15，17，19；數組b：2，4，6，8，10
兩個數組合併爲數組c，按升序排列。 要求：使用Arrays類的方法快速實現。
Int [] C = Arrays.copyOf(A, a.lenth + b.length);
數組作業答案
一、 填空題
1. 連續
2. length
3. 聲明數組
4. null
5. array[0].length
6. 0---（數組長度-1）
二、 選擇題
1. AD
2. D
3. B
4. CD
5. A
6. B
7. AC
8. AD
9. CD
三、 判斷題
1. √
2. ×
3. √
4. √
5. √
6. ×
7. √
8. √
9. ×
10. √
四、 簡答題
答案略
五、 編碼題
1. 定義一個長度爲10 的一維字符串數組，在每一個元素存放一個單詞；然後運行時從命令行輸入一個單詞，程序判斷數組是否包含有這個單詞，包含這個單詞就打印出“Yes”，不包含就打印出“No”。
public class Test {
// 思路：遍歷數組時當有值與輸入字符串相同時使用一個boolean記錄狀態
public static void main(String[] args) {
String[] strArr = new String[10];
strArr[0] = "java";strArr[1] = "html";
strArr[2] = "sql";strArr[3] = "android";
strArr[4] = "javascript";strArr[5] = "ruby";
strArr[6] = "c";
strArr[7] = "c++";
strArr[8] = ".net";
strArr[9] = "ios";
Scanner scanner = new Scanner(System.in);
System.out.print("請輸入需要查找的計算機編程語言:");
String inputStr = scanner.next();
boolean flag = false;
for (String string : strArr) {
if (string.equals(inputStr)) {
flag = true;
break;
}
}
if (flag) {
System.out.println("YES");
} else {
System.out.println("NO");
}
}
}
2. 利用Java的Math類的random()方法，編寫函數得到0到n之間的隨機數，n是參數。
提示： int num=(int)(n*Math.random());
並找出產生50個這樣的隨機數中最大的、最小的數，並統計其中大於等於60的有多少個。
public class Test {
public static void main(String[] args) {
//創建一個長度爲50的，每個元素在0-100之間的數組
int[] arr = getArray(100);
//遍歷數組
printArr(arr);
//獲取最大值和最小值
int min = getMin(arr);
int max = getMax(arr);
System.out.println("數組中最大值：" + max + "\t數組中最小值：" + min);
//統計其中大於等於60的元素個數
int count = count(arr,60);
System.out.println("數組中大於或等於60的數有:" + count + " 個");
}
//遍歷數組
private static void printArr(int[] arr) {
System.out.println("輸出數組元素");
for(int i=0;i<arr.length;i++){
if(i%10 ==0){
System.out.println();
}
System.out.print(arr[i]+"\t");
}
}
//獲取數組最大值
private static int getMax(int[] arr) {
int max = arr[0];
for(int i=1;i<arr.length;i++){
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
//獲取數組最小值
private static int getMin(int[] arr) {
int min = arr[0];
for(int i=0;i<arr.length;i++){
if(min>arr[i]){
min = arr[i];
}
}
return min;
}
// 創建數組 並且初始化50個數據
public static int[] getArray(int n) {
int arr[] = new int[50];
for (int i = 0; i < 50; i++) {
arr[i] = (int) (n * Math.random());
}
return arr;
}
// 統計數組中大於等於60的數量的方法 思路：使用一個int值計數
public static int count(int[] arr,int elem) {
int count = 0;
for (int i : arr) {
if (i >= elem) {
count++;
}
}
return count;
}
}
3. 數組逆序操作：定義長度爲10的數組，將數組元素對調，並輸出對調前後的結果。
public class Test{
public static void main(String[] args) {
//定義一個數組，並進行靜態初始化。
int[] arr = {12,98,50,34,76,87,90,34,67,80};
//逆序前
System.out.println("逆序前：");
printArr(arr);
//逆序後
System.out.println("逆序後：");
reverseArr(arr);
printArr(arr);
}
public static void reverseArr(int[] arr) {
for(int x=0; x<arr.length/2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
}
//遍歷數組
public static void printArr(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) { //這是最後一個元素
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}
4. 現在有如下的一個數組： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求將以上數組中值爲0的項去掉，將不爲0的值存入一個新的數組，生成的新數組爲： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}
思路： 確定出不爲0的個數，這樣可以開闢新數組；從舊的數組之中，取出內容，並將其賦給新開闢的數組。
public class Test {
public static void main(String[] args) {
int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 };
int newArr[] = selectArr(oldArr);
for (int i : newArr) {
System.out.print(i+" ");
}
}
// 去掉數組中值爲0的元素的方法
public static int[] selectArr(int[] arr) {
// 1.計算數組中元素不爲0的個數
int count = 0;
for (int i : arr) {
if (i != 0) {
count++;
}
}
// 2.創建一個新數組,長度爲count
int newArr[] = new int[count];
// 3.複製不爲0的元素到新數組中
int size = 0;
for (int i : arr) {
if (i != 0) {
newArr[size++] = i;
}
}
return newArr;
}
}
5. 使用二分法查找有序數組中元素。找到返回索引，不存在輸出-1。
public class BinarySearch {
public static void main(String[] args) {
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
System.out.println(searchLoop(array, 9));
}
/**
* 循環二分查找，返回第一次出現該值的位置
* @param array 已排序的數組
* @param findValue 需要找的值
* @return 值在數組中的位置，從0開始。找不到返回-1
*/
public static int searchLoop(int[] array, int findValue) {
// 如果數組爲空，直接返回-1，即查找失敗
if (array == null) {
return -1;
}
// 起始位置
int start = 0;
// 結束位置
int end = array.length - 1;
while (start <= end) {
// 中間位置
int middle = (start + end) / 2;
// 中值
int middleValue = array[middle];
if (findValue == middleValue) {
// 等於中值直接返回
return middle;
} else if (findValue < middleValue) {
// 小於中值時在中值前面找
end = middle - 1;
} else {
// 大於中值在中值後面找
start = middle + 1;
}
}
// 返回-1，即查找失敗
return -1;
}
}
6. 用二重循環求出二維數組b所有元素的和：
int[][] b={{11},{21,22},{31,32,33}}
public class Test {
public static void main(String[] args) {
int sum=0;
int[][] b={{11},{21,22},{31,32,33}};
for(int i=0;i<b.length;i++){
for(int j=0;j<b[i].length;j++){
sum += b[i][j];
}
}
System.out.println(sum);
}
}
六、 可選題
1. 生成一百個隨機數，放入數組，然後排序輸出。
public class Test {
public static void main(String[] args) {
//1.生成100個隨機數的數組
int []arr = createArr();
//2.從小到大排序
arr = sortArr(arr);
//3.打印
printArr(arr);
}
//生成100個隨機數的方法
public static int[] createArr(){
int []arr = new int[100];
for(int i=0;i<arr.length;i++){
arr[i]= (int) (100*Math.random());
}
return arr;
}
//對數組進行排序的方法
public static int[] sortArr(int arr[]){
int temp;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <= i; j++) {
if (arr[i] < arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
//數組遍歷輸出打印的方法
public static void printArr(int []arr){
for(int i:arr){
System.out.println(i);
}
}
}
2. 題目：輸入某年某月某日，判斷這一天是這一年的第幾天？
分析：以3月5日爲例，應該先把前兩個月的加起來，然後再加上5天即本年的第幾天，特殊情況，閏年且輸入月份大於3時需考慮多加一天。可以定義數組存儲1-12月各個月的天數。
public class Test {
public static void main(String[] args) {
Scanner scanner1 = new Scanner(System.in);
System.out.print("輸出今年是第幾年");
int year = scanner1.nextInt();
System.out.print("輸出今年是第幾月");
int month = scanner1.nextInt();
System.out.print("輸出今年是第幾日");
int day = scanner1.nextInt();
int daynum = 0; // 天數
//一年365天
int[] month1 = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 };
//閏年366天
if (year % 400 == 0 && year % 100 != 0 || year % 100 == 0) {
month1 = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31,30, 31 }; // 閏年裏的每個月的天數
}
//判斷這一天是第幾天
for (int index = 1; index <= month; index++) {
if (index == 1) {
daynum = day;
} else {
daynum += month1[index - 2];
}
}
System.out.println("這一天是這一年的第" + daynum + "天！");
}
}
3. 使用二分法查找有序數組中元素。找到返回索引，不存在輸出-1。使用遞歸實現
public class BinarySearch {
public static void main(String[] args) {
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
System.out.println(searchRecursive(array, 0, array.length - 1, 20));
}
/**
* 執行遞歸二分查找，返回第一次出現該值的位置 *
* @param array 已排序的數組
* @param start 開始位置
* @param end 結束位置
* @param findValue 需要找的值
* @return 值在數組中的位置，從0開始。找不到返回-1
*/
public static int searchRecursive(int[] array, int start, int end,
int findValue) {
// 如果數組爲空，直接返回-1，即查找失敗
if (array == null) {
return -1;
}
if (start <= end) {
// 中間位置
int middle = (start + end) / 2;
// 中值
int middleValue = array[middle];
if (findValue == middleValue) {
// 等於中值直接返回
return middle;
} else if (findValue < middleValue) {
// 小於中值時在中值前面找
return searchRecursive(array, start, middle - 1, findValue);
} else {
// 大於中值在中值後面找
return searchRecursive(array, middle + 1, end, findValue);
}
} else {
// 返回-1，即查找失敗
return -1;
}
}
}
4. 現在給出兩個數組：
數組A：“1，7，9，11，13，15，17，19：；
數組b：“2，4，6，8，10”
兩個數組合併爲數組c，按升序排列。
要求：使用Arrays類的方法快速實現。
public class Test {
public static void main(String[] args) {
int data1[] = new int[] { 1, 7, 9, 11, 13, 17, 19 };
int data2[] = new int[] { 2, 4, 6, 8, 10 };
int newArr[] = concat(data1, data2);
print(newArr);
Arrays.sort(newArr);
print(newArr);
}
public static int[] concat(int src1[], int src2[]) {
int len = src1.length + src2.length; // 新數組的大小
int arr[] = new int[len]; // 新數組
//int count = 0;
//for (int i : src1) {
//arr[count++] = i;
//}
//for (int i : src2) {
//arr[count++] = i;
//}
// 還可以通過系統的方法拷貝數組
System.arraycopy(src1, 0, arr, 0, src1.length); // 拷貝第一個數組
System.arraycopy(src2,0,arr,src1.length, src2.length); //拷貝第二個數組
return arr;
}
public static void print(int[] temp) {
for (int x = 0; x < temp.length; x++) {
System.out.print(temp[x] + "、");
}
System.out.println();
}
}