Java知识点总结 (数组)

Java知识点总结 (数组)

@(Java知识点总结)[Java, Java数组]

[toc]

一维数组

定义

• 用于存储同一类型数据的一个容器
• 可以对该容器中的数据从0开始进行编号
• 数组是对象

声明数组

1. 元素类型 [ ] 变量名 等价 元素类型 变量名 [ ]
2. 元素类型 [ ] 变量名 = new 元素类型 [元素的个数];
3. 元素类型 [ ] 变量名 = ｛元素1，元素2...｝;
4. 元素类型 [ ] 变量名 = new 元素类型[ ]{元素1，元素2...}；

数组元素的个数：__length__

下标运算：[ ]

• 数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 length-1.

场景异常

• ArrayIndexOutOfBoundsException（数组下标越界异常）

二维数组

二维数组可以看成以数组为元素的数组，例如：

Java中多维数组的声明和初始化应从高维到低维的顺序进行，例如：

需要两次下标运算才能取出元素

应用：表格、矩阵、棋盘、地图

数组相关算法

数组拷贝

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]<array[j-1]) {
        temp = array[j];
        array[j] = array[j-1];
        array[j-1] = temp;
      }else break;
     }
   }
   System.out.println(Arrays.toString(array));
  }
 
  public static void main(String[] args) {
   int[] array = getArray();
   bubbleSort(array);
   arraySort(array);
   selectSort(array);
   insertSort(array);
 
  }
 
  private static int[] getArray() {
   int[] array = new int[10];
   for (int i = 0; i < array.length; i++) {
     array[i] = (int) (Math.random() * 100);
   }
 
   return array;
  }
 
}

数组查找

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<array[mid ]) {
      high = mid - 1;
     }else {
      return mid;
     }
   }
   
   return -1;
  }
  
  //Java 提供的查找方式。查看源码，它的本质就是二分查找
  public static void test(int[] array ,int num){
   int index = Arrays.binarySearch (array, 8);
   System.out.println(index);
  }
  
  
  //无序数组,采用遍历，也可以先排序，后采用二分查找
  public static int search(int[] array ,int num){
   int index = -1;
   for (int i = 0; i < array.length; i++) {
     if (num==array[i]) {
      index = i;
     }
   }
   return index;
  }
  
  public static void main(String[] args) {
   int[] array = {2,4,6,8,11,24,45,56,78,92,102};
   int index = binarySerarch(array, 8);
   System.out.println(index); // 3
   
   test(array, 8); // 3
   
   int[] array1 = {34,21,56,22,1,7,8,3,0,21};
   System.out.println(search(array1, 1)); // 4
   
  }
 
}

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<int[]> list1 = Arrays.asList(array1);
   System.out.println(list1.size()); //1
   
   Integer[] array2 = {34,21,56,22,1,7,8,3,0,21};
   List<Integer> 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变量。如图：

二维数组内存：