Java數組

時間 2019-11-08

標籤 java 數組欄目 Java 简体版

原文原文鏈接

Java數組java

數組的定義：
　　數組是相同類型數據的有序集合。數組描述的是相同類型的若干個數據，按照必定的前後次序排列組合而成。其中，每個數據稱做一個元素，每一個元素能夠經過一個索引(下標)來訪問它們。
數組的基本特色：
1. 長度是肯定的。數組一旦被建立，它的大小就是不能夠改變的。
2. 其元素必須是相同類型，不容許出現混合類型。元素的類型能夠是java 支持的任意類型
3. 數組類型能夠是任何數據類型，包括基本類型和引用類型。
4. 數組的元素在堆內存中被分配空間，而且是連續分配的
5. 使用new 關鍵字對數組進行內存的分配。每一個元素都會被jvm 賦予默認值。默認規則：整數：0 浮點數：0.0 字符：\u0000 布爾：false 引用數據類型：null。
6. 數組的元素都是有序號的，序號從0開始，0序的。稱做數組的下標、索引、角標
數組的聲明：
1. 聲明的時候並無實例化任何對象，只有在實例化數組對象時，JVM才分配空間，這時才與長度有關。
2. 聲明一個數組的時候並無數組真正被建立。
3. 構造一個數組，必須指定長度。
數組格式：
元素類型[ ] 數組名 = new 元素類型 [元素個數或數組長度]; // int [] arr = new int [3];
[]：表明這是數組類型。
數組名：一個合法的標識符，命名規範和局部變量規範一致。
new：是java 的關鍵字。用來向JVM申請內存的。
元素類型[元素個數] ：決定了向JVM申請的內存空間的大小。
　　　　　　　　　大小：元素類型字節數 * 元素個數
元素的個數：只要是一個合法的java 表達式就能夠。返回一個int 類型的值便可
example數組

數組的常見問題：

數組的優缺點：
優勢：
1：能夠保存若干個數據。
2：隨機訪問的效率很高。根據下標訪問元素效率高（元素連續分配空間）。
缺點：
1：數組的元素的類型必須一致。元素類型必須一致。
2：連續分配空間在堆中，若是數組的元素不少，對內存的要求更加的嚴格。
3：根據內容查找元素效率比較低，須要逐個比較個。
4：刪除元素、插入元素效率比較低，須要移動大量的元素。
5：數組定長，不能自動擴容。
6：數組沒有封裝，數組對象只提供了一個數組長度的屬性，可是沒有提供方法用來操做元素。
java 提供了一整套的針對不一樣需求的對於容器的解決的方案。集合框架部分。不一樣的容器有不一樣的特色，知足不一樣的需求。數組的缺點都會被幹掉。框架

數組的初始化：靜態初始化、動態初始化、默認初始化
靜態初始化：int[] arr = { 1, 2, 3 };// 靜態初始化基本類型數組；動態初始化：int[] arr = new int[2];//動態初始化數組，先分配空間；　　　　　　arr[0]=1;//給數組元素賦值；　　　　　　arr[1]=2;//給數組元素賦值；默認初始化：int arr[] = new int[2]; // 默認值：0,0 　　　　　　boolean[] b = new boolean[2]; // 默認值：false,false 　　　　　　String[] s = new String[2]; // 默認值：null, null 數組的遍歷：for循環 for-each循環基於數組的拷貝操做:拷貝、刪除、擴容　　System類裏也包含了一個static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，該方法能夠將src數組裏的元素值賦給dest數組的元素，其中srcpos指定從src數組的第幾個元素開始賦值，length參數指定將src數組的多少個元素賦給dest數組的元素。dom

 1 package com.boom.arrays;
 2 
 3 /**
 4  * 關於數組的操做:拷貝，刪除，擴容
 5  * 
 6  * @author Administrator
 7  *
 8  */
 9 public class ArrayCopyTest {
10 
11     public static void main(String[] args) {
12          arrayCopy();
13 
14 //        String[] str = { "Java", "C", "C++", "Python", "JScript" };
15 //        removeElement(str, 1);
16 //        
17 //        String[] str = { "Java", "C", "C++", "Python", "JScript" };
18 //        extendRange(str);
19         
20         
21     }
22 
23     // 數組的拷貝
24     public static void arrayCopy() {
25         String[] s1 = { "aa", "bb", "cc", "dd", "ee", };
26         String[] s2 = new String[7];
27         // 從s1 裏下標爲1的數組開始拷貝到s2,存放在s2裏下標爲2的位置開始，拷貝3個數組。
28         System.arraycopy(s1, 1, s2, 2, 3);
29         for (int i = 0; i < s2.length; i++) {
30             System.out.print(s2[i] + " ");
31         }
32     }
33 
34     // 刪除數組中指定索引的位置,並返回原數組.實則仍是拷貝數組，再覆蓋原來的數組
35     public static String[] removeElement(String[] s, int index) {
36         System.arraycopy(s, index + 1, s, index, s.length - index - 1);
37         // 特殊處理最後一個數組
38         s[s.length - 1] = null;
39         for (int i = 0; i < s.length; i++) {
40             System.out.print(s[i] + " " + "\n");
41         }
42         return s;
43     }
44     
45     // 數組的擴容
46     public static String[] extendRange(String[] s1){
47         // 傳入的數組基礎上空間+3
48         String[] s2  = new String[s1.length+3];
49         System.arraycopy(s1, 0, s2, 0, s1.length);
50         for(int i = 0; i<s2.length;i++){
51             System.out.println(s2[i]);
52         }
53         return s2;
54         
55     }
56 
57 }

ArrayCopy Code

java.util.Arrays類
JDK提供的java.util.Arrays類，包含了經常使用的數組操做，方便咱們平常開發。Arrays類包含了：排序、查找、填充、打印內容等常見的操做。
打印數組 Arrays.toString(arr)
jvm

數組元素的排序 Arrays.toString(arr)

二分法查找 Arrays.binarySearch(arr, key)

ide

數組填充

多維數組
　　多維數組能夠當作以數組爲元素的數組。能夠有二維、三維、甚至更多維數組，可是實際開發中用的很是少。最多到二維數組(學習容器後，咱們通常使用容器，二維數組用的都不多)。
數組的排序：學習

 1 package com.boom0904;
 2 
 3 import java.util.Arrays;
 4 
 5 import javax.sound.sampled.Mixer;
 6 
 7 import com.boom.util.RandomNumber;
 8 
 9 /**
10  * 數組的排序
11  * 
12  * @author Administrator
13  *
14  */
15 public class SortTest {
16 
17     public static void main(String[] args) {
18         bubbleSort();
19         //selectSort();
20     }
21 
22     private static void selectSort() {
23         int arr[] = RandomNumber.createRandomArray(10, 0, 20);
24         System.out.println(Arrays.toString(arr));
25         selectSort(arr);
26         System.out.println(Arrays.toString(arr));
27     }
28 
29     private static void bubbleSort() {
30         int arr[] = RandomNumber.createRandomArray(10, 0, 20);
31         System.out.println(Arrays.toString(arr));
32         bubbleSort(arr);
33         System.out.println(Arrays.toString(arr));
34 
35     }
36 
37     /**
38      * 冒泡排序
39      * 
40      * @param arr
41      * @return
42      */
43     public static void bubbleSort(int[] arr) {
44         for (int i = 0; i < arr.length - 1; i++) { // 外層循環控制趟數
45             // boolean flag = false;
46             for (int j = 0; j < arr.length - i - 1; j++) { // 內層循環控制一趟
47                 // 若是前面的的數大於後面的數，定義最大值爲前面的數。再進行位置置換，ASC
48                 if (arr[j] > arr[j + 1]) { // arr[j] < arr[j + 1] 反則DESC
49                     // flag = true;
50                     int temp = arr[j];
51                     arr[j] = arr[j + 1];
52                     arr[j + 1] = temp;
53                 }
54             }
55             // if (!flag) {
56             // System.out.println("i==" + i);
57             // break;
58             // }
59         }
60     }
61 
62     /**
63      * 選擇排序
64      * 
65      * @param arr
66      */
67     public static void selectSort(int[] arr) {
68         // 外層循環控制 選擇的趟數
69         // i 既能夠控制次數，還表明了當前待排序區的第一個元素的索引
70         for (int i = 0; i < arr.length - 1; i++) {
71             // 用於保存當前最小值的下標
72             int minIndex = i;
73             // 對待排序區查找最小值的索引
74             for (int j = i + 1; j < arr.length; j++) {
75                 if (arr[j] < arr[minIndex]) {
76                     minIndex = j;
77                 }
78             }
79             // 將最小值和 下標是i 的元素交換
80             if (i != minIndex) {// 待排序的第一個元素不是最小的狀況
81                 int temp = arr[i];
82                 arr[i] = arr[minIndex];
83                 arr[minIndex] = temp;
84             }
85         }
86     }
87 
88 }

SortTest Code

數組的查找：spa

 1 package com.boom0904;
 2 /**
 3  * 數組的查找
 4  */
 5 import java.util.Arrays;
 6 
 7 import com.boom.util.RandomNumber;
 8 
 9 public class ArithmeticTest {
10 
11     public static void main(String[] args) {
12         // test1();
13         test2();
14     }
15 
16     private static void test2() {
17         int[] arr = RandomNumber.createRandomArray(50, 0, 100);
18         Arrays.sort(arr);
19         int index = binarySearch(arr, 99);
20         System.out.println("index=" + index);
21         if (index != -1) {
22             System.out.println(arr[index]);
23         }
24     }
25 
26     private static void test1() {
27         int[] arr = RandomNumber.createRandomArray(10, 0, 20);
28         System.out.println(Arrays.toString(arr));
29         System.out.println(indexOf(arr, 9));
30 
31     }
32 
33     /**
34      * 自定義方法，實現查找指定的數組中是否存在指定的值 時間複雜度：T(n) = O(n)
35      * 
36      * @param arr
37      *            被查找的 數組
38      * @param key
39      *            被查找的值
40      * @return 若是 key 在arr 中存在，返回key 的第一個索引，不然返回 -1
41      */
42     public static int indexOf(int[] arr, int key) {
43         // 處理特殊狀況:若是數組爲空或者數組的長度爲0,返回-1
44         if (arr == null)
45             return -1;
46         int len = arr.length;
47         if (len == 0)
48             return -1;
49 
50         for (int i = 0; i < len; i++) {
51             if (arr[i] == key)
52                 return i;
53         }
54         return -1;
55     }
56 
57     /**
58      * 二分搜索法
59      * 
60      * @param arr
61      *            待搜索的數組
62      * @param key
63      *            搜索的值
64      * @return 若是 key 在arr 中存在，返回key 的第一個索引，不然返回 -1
65      */
66     public static int binarySearch(int[] arr, int key) {
67         // 處理特殊狀況:若是數組爲空或者數組的長度爲0,返回-1
68         if (arr == null)
69             return -1;
70         int len = arr.length;
71         if (len == 0)
72             return -1;
73         int low = 0;
74         int high = len - 1;
75         // 不在區間內
76         if (key < arr[low] || key > arr[high])
77             return -1;
78 
79         int mid = low + high >> 1;
80         int counter = 0;
81         while (high >= low) {
82             counter++;
83             if (arr[mid] == key) {
84                 System.out.println("找到了。。。查找次數=" + counter);
85                 return mid;
86             } else if (arr[mid] < key) {// 在右邊
87                 low = mid + 1;
88             } else { // 在左邊
89                 high = mid - 1;
90             }
91             mid = low + high >> 1;
92         }
93         System.out.println("沒找到。。查找次數=" + counter);
94         return -1;
95     }
96 
97 }