@(Java知識點總結)[Java, Java數組]

[toc]

用于存儲同一類型數據的一個容器

可以對該容器中的數據從0開始進行編號

數組是對象

元素類型 [ ] 變量名 等價 元素類型 變量名 [ ]

元素類型 [ ] 變量名 = new 元素類型 [元素的個數];

元素類型 [ ] 變量名 = ｛元素1，元素2...｝;

元素類型 [ ] 變量名 = new 元素類型[ ]{元素1，元素2...}；

數組的元素是通過索引訪問的。數組索引從 0 開始，所以索引值從 0 到 length-1.

ArrayIndexOutOfBoundsException（數組下標越界異常）

import java.util.Arrays;
 
/**
 * 數組拷貝
 * @author Administrator
 *
 */
public class ArrayTest2 {
  
  //這樣拷貝數組間沒有隔離性
  public static void test1(){
   String[] ss1 = {"1","2","3"};
   String[] ss2 = ss1; //把ss1對數組的引用傳遞給變量ss2，兩個變量指向的是同一個數組
   
   ss2[0] = "張三";
   System.out.println(ss1[0]); //張三
  }
  
  public static void test2(){
   String[] ss1 = {"1","2","3"};
   String[] ss2 = new String[ss1.length];//通過new關鍵字在內存中開辟一塊空間，ss2指向的是新的數組對象
   
   for (int i = 0; i < ss2.length; i++) {
     ss2[i] = ss1[i];
   }
   
   ss2[0] = "張三";
   System.out.println(ss1[0]); //1
  }
  
  //API提供的方式，底層用C++寫的，所以速度很快，比for循環的效率高
  public static void test3(){
   String[] ss1 = {"1","2","3"};
   String[] ss2 = new String[ss1.length];
   System.arraycopy (ss1, 0, ss2, 0, ss1.length);
   
   System.out.println(Arrays.toString(ss2)); // [1, 2, 3]
  }
  
  public static void test4(){
   String[] ss1 = {"1","2","3"};
   String[] ss2 = Arrays.copyOf (ss1, ss1.length);
   
   System.out.println(Arrays.toString(ss2)); //[1, 2, 3]
  }
  
  public static void main(String[] args) {
   test1();
   test2();
   test3();
   test4();
  }
 
}

import java.util.Arrays;
 
/**
 * 數組擴容
 * @author Administrator
 *
 */
public class ArrayTest3 {
  
  public static void test1(){
   String[] arry1 = {"張三","李四","王五"};
   arry1 = Arrays.copyOf (arry1, arry1.length+2);
   
   System.out.println(arry1.length); //5
   System.out.println(Arrays.toString(arry1)); //[張三, 李四, 王五, null, null]
  }
  
  
  public static void test2(){
   String str = "統計一個字符在字符串中的所有位置";
   //int[] arry = countAll(str, "字"); // [4, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   int[] arry = countAll2(str, "字"); // [4, 7]
   System.out.println(Arrays.toString(arry));
   
  }
  
  //浪費內存
  private static int[] countAll(String str,char ch){
   char[] charArray = str.toCharArray();
   int[] array = new int[charArray.length];
   int index = 0;
   for (int i = 0; i < charArray.length; i++) {
     if (ch == charArray[i]) {
      array[index] = i;
      index ++;
     }
   }
   
   return array;
  }
  
  private static int[] countAll2(String str,char ch){
   int[] array = {}; //創建一個空數組
   for (int i = 0; i < str.length(); i++) {
     if (ch == str.charAt(i)) {
      array = Arrays.copyOf(array, array.length+1);
      array[array.length-1] = i;
     }
   }
   return array;
  }
  
  public static void main(String[] args) {
   test1();
   test2();
  }
 
}

import java.util.Arrays;
/**
 * 排序
 * @author Administrator
 *
 */
public class ArrayTest4 {
 
  // java 提供的排序方法
  public static void arraySort(int[] array) {
   Arrays.sort(array);
   System.out.println(Arrays.toString(array));
  }
 
  // 冒泡排序，前一個數與后一個數進行比較
  public static void bubbleSort(int[] array) {
   int temp = 0;
   for (int i = 0; i < array.length - 1; i++) {
     for (int j = i + 1; j < array.length; j++) {
      if (array[j] < array[i]) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
      }
     }
   }
   System.out.println(Arrays.toString(array));
  }
 
  // 選擇排序
  public static void selectSort(int[] array) {
   int temp = 0;
   for (int i = 0; i < array.length - 1; i++) {
     int min = i;
     for (int j = i + 1; j < array.length; j++) {
      if (array[min] > array[j]) {
        min = j;
      }
     }
     if (min != i) {
      temp = array[i];
      array[i] = array[min];
      array[min] = temp;
     }
   }
   System.out.println(Arrays.toString(array));
  }
 
  // 插入排序
  public static void insertSort(int[] array) {
   int temp = 0;
   for (int i = 1; i < array.length; i++) {
     for (int j = i; j > 0; j--) {
      if (array[j]
數組查找
import java.util.Arrays;
 
/**
 * 無序數組 - 順序查找
 * 有序數組 - 二分查找
 * @author Administrator
 *
 */
public class ArrayTest5 {
  
  //有序數組，二分查找
  public static int binarySerarch(int[] array ,int num){
   int low = 0;
   int high = array.length-1;
   
   while(low <= high){
     int mid = (low+high)/2;
     
     if (num>array[mid]) {
      low = mid + 1;
     }else if (num
Arrays工具類
java.util.Arrays類能方便地操作數組，它提供的所有方法都是靜態的
import java.util.Arrays;
import java.util.List;
 
public class ArrayTest6 {
  public static void main(String[] args) {
   int[] nums = new int[10];
   
   //填充數組
   Arrays.fill (nums, 3);
   System.out.println(Arrays.toString(nums)); //[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
   
   //將第4個元素到低8個元素的值，賦值為0
   Arrays.fill (nums,3,8,0);
   System.out.println(Arrays.toString(nums)); //[3, 3, 3, 0, 0, 0, 0, 0, 3, 3]
   
   // 將第3到第5之間的元素進行排序
   char[] ch = {"a","d","f","c","j","e"};
   Arrays.sort (ch,2,5);
   System.out.println(Arrays.toString(ch)); //[a, d, c, f, j, e]
   
   // 比較元素是否相等
   char[] ch2 = ch.clone();
   System.out.println(Arrays.equals (ch, ch2)); //true 數組元素內容相等
   System.out.println(ch == ch2); //false 不是同一個對象
   
   //二分查找
   Arrays.sort(ch); //必須先排好序，否則結果不正確
   int index = Arrays.binarySearch (ch, "c");
   System.out.println(index);  // 1
   
   //數組轉為list集合
   int[] array1 = {34,21,56,22,1,7,8,3,0,21};
   List list1 = Arrays.asList(array1);
   System.out.println(list1.size()); //1
   
   Integer[] array2 = {34,21,56,22,1,7,8,3,0,21};
   List list2 = Arrays.asList (array2);
   System.out.println(list2.size()); //10
   for (Integer i : list2) {
     System.out.print(i+","); // 34,21,56,22,1,7,8,3,0,21,
   }
   
  }
}



數組內存
int  score[];  //聲明一個整數數組score
此時這個變量并沒有包含任何內容，編譯器僅僅會分配一塊內存給它，用來保存指向數組實體的地址，如圖：


聲明之后，接著要進行內存分配的操作。這一行代碼會開辟3個可供保存整數的內存空間，并把此內存空間的參考地址賦給score變量。如圖：


二維數組內存：