Java知识点总结 (数组)

@(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变量。如图：


二维数组内存：