java 数组详解

数组

概念：数组是一个定长的容器,数组中存储的数据类型需要是一致的

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的四种定义方式：

数据类型是数组中元素的数据类型

数组是有默认值的{0,0,0,0,0,0,0,0,0,0,}

int数据类型是数组中元素的数据类型

数组的数据类型是 int[]

元素 --> 数组中储存的值

数组的长度 --> 数组中的元素个数

//数据类型[] 数组名 = new 数据类型[数组中元素的个数]
 
int[] array = new int[10];

2.先声明数组，然后再进行赋值

//在类中，定义成员变量，方法传递
int[] array2;
array2 = new int[10];

3.创建数组的同时，给定当前数组中储存元素的值

//数组的长度：后面{}中储存多少个值，数组就有多长
 
int[] array3 = new int[]{1,2,3,4}

4.第3的简化版本

int[] array4 = {1,2,3,4}

数组的概念

    同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素， 也就是数组一旦定义，那么里边存储的数据类型也就确定了。

数组的内存分析

 

 数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中配置数组所需的内存，其中“元素的个数”（数组的长度）是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。

二维数组：

Arrays的使用

遍历： toString()    将数组的元素以字符串的形式返回

排序： sort()        将数组按照升序排列

        int[] arr = {23,64,2,37,43,67,1};
        Arrays.sort(arr); //升序
        for(int i=0;i<arr.length;i++) {
            System.out.println(arr[i]);
        }

查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回（-插入点-1） 注意：使用查找的功能的时候，数组一定要先排序。

 

二维数组：实质就是存储是一维数组。

数组定义：

       数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

数组排序：

数组排序有很多中:冒泡 ,选择,插入,快速,堆等等

* 速度最快的就是 堆 排序

冒泡排序 ( 两两相比 )
是相邻的两个数组元素进行比较

若当前元素大于后面的元素,交换两个元素的位置

若当前元素不大于后面的元素,就不交换

比较所有相邻的元素,最终的到一个有序的结果

冒泡最大的特点就是会先找出最大的值,然后放到数组的最后一位

升序(从小到大),降序(从大小) --> 默认排序都是升序

只要经过一轮排序,肯定会有一个数放到正确的位置上

 

3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列

3,4,6,7,1,9 -- > 9

3,4,6,1,7,9 --> 7,9

3,4,1,6,7,9 --> 6,7,9

3,1,4,6,7,9 --> 4,6,7,9

1,3,4,6,7,9 --> 1,3,4,6,7,9

       for(int i = 0 ; i < array.length - 1 ; i++){
          for(int j = 0 ; j < array.length -1 -i ; j++){
           if(array[j] > array[j + 1]){
              int tmp = array[j];
              array[j] = array[j+1];
              array[j + 1] = tmp;
           }
         }

选择排序 ( 固定一位一次向后比 )

升序(从小到大),降序(从大小) --> 默认排序都是升序

固定一个元素,依次和后面的元素进行比较

若当前元素大于后面的元素,交换

若当前元素不大于后面的元素,不交换

每次比较完成们都会有一个数放到正确的位置上,小的那个数

 

3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列

1,7,4,6,9,3 --> 1

1,3,7,6,9,4 --> 1,3

1,3,4,7,9,6 --> 1,3,4

1,3,4,6,9,7 --> 1,3,4,6

1,3,4,6,7,9 --> 1,3,4,6,7,9

for(int i = 0 ; i < array.length ; i++){
          for(int j = i+1 ; j < array.length ;j++){
                  if(array[i] > array[j]){
                        int tmp = array[i];
                       array[i] =  array[j];
                       array[j] = tmp; 
          }
      }
}

数组的复制
 

           int[] a = {10,20,30,40,50};
           //数组的扩容(创建了新的数组并将源数组的数据复制过去了)
           a = Arrays.copyOf(a,a.length+1); //
           for(int i=0;i<a.length;i++) {
               System.out.println(a[i]); //10 20 30 40 50 0
           }
         
         

           int[] a = {10,20,30,40,50};
           //a:源数组
           //a1:目标数组
           //6:目标数组的长度(多则补默认值，少则截取)
           int[] a1 = Arrays.copyOf(a,6); //灵活性差
           for(int i=0;i<a1.length;i++) {
               System.out.println(a1[i]); //10 20 30 40 50 0
           }

           int[] a = {10,20,30,40,50};
           int[] a1 = new int[6]; //0,0,0,0,0,0
           //a:源数组
           //1:源数组的起始下标
           //a1:目标数组
           //0:目标数组的起始下标
           //4:要复制的元素个数
           System.arraycopy(a,1,a1,0,4); //灵活性好
           for(int i=0;i<a1.length;i++) {
               System.out.println(a1[i]); //20 30 40 50 0 0 
           }

操作数组的工具类：Arrays

java.util.Arrays类包含了用来操作数组（比如排序和搜索）的各种方法，它提供的所有这些方法都是静态的。

Arrays拥有一组static方法：

public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

public class Test {
    public static void main(String[] args) {
        int array[] = { 2, 5, 8, 3, 1, 4, 9, 6, 7 }; // 声明一个整型数组 
        System.out.println("Object的toString："array.toString()); //Object的toString()方法
        Arrays.sort(array);  // 数组排序
        System.out.println("排序后的数组: " + Arrays.toString(array)) ; 
        int point = Arrays.binarySearch(array, 3) ; // 检索数据位置
        System.out.println("元素‘3’的位置在：" + point) ;
        Arrays.fill(array, 6) ; // 填充数组
        System.out.print("数组填充：" + Arrays.toString(array)) ;
    }
}

执行结果

Object的toString：[I@7852e922
排序后的数组: [1, 2, 3, 4, 5, 6, 7, 8, 9]
元素‘3’的位置在：2
数组填充：[6, 6, 6, 6, 6, 6, 6, 6, 6]

数组的基本操作

线性查找(顺序查找)

从数组中的第一个元素开始,依次向后查找,直到找当前要查找的值

要么是找到了,要么就是没有找到

//顺序查找
 for (int i = 0; i < array.length; i++) {
     if(n == array[i]){
        return i;    //需要范围找到的下标,系统API
     }
  }
     return -1;    //返回一个负数
     return i;    //需要范围找到的下标,系统API
   }
}
return -1;    //返回一个负数

折半查找(二分查找) 先排序

一定是一个有序的数组,通过待查找的数和数组中间索引值进行比较

大于: 待查找值大于中间索引值,就需要向数组的右半边进行查找

等于:待查找值等于中间索引值,就是找到了

小于:待查找值下于中间索引值,就需要向数组的左半边进行查找

    //定义开始值
    int beginIndex = 0;
    //定义结束值
    int endIndex = array.length-1;
    //获取中间值
    int middleIndex = (beginIndex+endIndex)/2;
    //进行比较 用中间值来比较要查找的值
    //第一种比较的次数应该是数组的长度
    //第二中死循环
    while(true){
            //缩小范围
        if(n > array[middleIndex]){
            //修改开始值
            beginIndex = middleIndex+1;
        }else if(n < array[middleIndex]){
            //修改结束值
            endIndex = middleIndex -1;
        }else{
            return middleIndex;
        }
        //无论是开始值还是结束中发生了改变
        //就要重新结算中间值
        middleIndex = (beginIndex+endIndex)/2;
        //若出现了一种情况 开始 > 结束
        if(beginIndex > endIndex){
            return -1;
        }   

  }