java 数组初步学习小得

一、数组的定义： 相同数据的集合

二、一维数组的建立方法：
1.int[ ] arr =new int {1,2,3,} ;//动态初始化
2.int[ ] arr = {1,2，3}；//静态初始化
3.int[ ] arr = new int [10];//定义数组 未初始化

三、二维数组的建立方法
1.int[ ][ ] array = {{1,2,3},{4,5,6}};
2. int[ ][ ] array2 = new int[ ][ ]{{1,2,3},{4,5,6}};
3. int [ ][ ] array3 = new int[2][3];
4.int [ ][ ] array4 = new int[2][ ];
4. int[ ][ ] array5 = {{1,2},{4,5,6}};
5.
四、获取数组的长度与访问数组内元素

int[ ] arr =new int {1,2,3,} ;
System.out.println(array.length);
//访问数组内某一元素
System.out.println(array[0]);

注：如果访问操作超过有效范围[0,length-1],会出现下标越界异常
如：int[] arr = {16,72,63,4,51};
System.out.println(arr[6]);
则会出现：“Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException:”来提示你下标越界。

五、初识JVM
程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.
虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址
的引用就是在这里保存.
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部
堆：主要用来存放对象（new：产生一个对象）
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据.
方法编译出的的字节码就是保存在这个区域.
运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量与符号引用.
注：在JDk1.7之前，常量池存放在方法池中。JDK1.7之后存放在堆中。
变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的. 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )

六、数组的引用类型

```java
 public static int func(int[] array) {
       array[0] = 10;
       System.out.println(array[0]);
       }
       
 public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        func(array);
         System.out.println(array[0]);
         }

如上代码就是一个对数组的引用。引用的本质上只是存了一个地址. 
Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
七、数组的打印方式
可以通过for循环打印

```java
int[] array = {1,2,3,4,5};
for (int i = 1; i <array.length ; i++) {
            System.out.println(i );
            }
            

for-each循环打印
注：无法访问数组下标

 int[] array ={1,5,3,6,2,4,7,8,4,12,55,22,99,47,12,53};
    for(int num : array)
    {
       System.out.println(num );
    }

通过类：import java.util.Arrays; 打印数组

import java.util.Arrays;
int[] array = {1,2,3,4,5};
System.out.println(Arrays.toString(array));

八、数组的拷贝
1、for循环去拷贝
2、System.arraycopy
3、Arrays.copyOf
4、数组名.clone(); clone是Object的方法
* 返回一个副本
* 数组名->你要拷贝的数组
九、数组的最大值、最小值、平均值

import java.util.Arrays;
public class go {
    public static int max(int[] array) {
        int max =array[0];
        for (int i = 1; i <array.length ; i++) {
            if(array[i]>max) {
                max = array[i] ;
            }
        }
        return max;
    }
    public static int min(int[] array) {
        int min =array[0];
        for (int i = 1; i <array.length ; i++) {
            if(array[i]<min) {
                min = array[i] ;
            }
        }
        return min;
    }
    //平均值
    public static int func(int[] array) {
        int sum = 0;

        for (int i = 0; i <array.length ; i++) {
           sum+=array[i];

        }
        return  sum/array.length;
    }
     public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(max(array));
        System.out.println(min(array));
        System.out.println(func(array));

十、Arrays类当中的方法
Arrays.toString();
Arrays.copyOf();
Arrays.copyOfRange();//拷贝部分数组[)
Arrays.binarySearch();
Arrays.equals();判断数组是否相同
Arrays.fill(array,9); 数组的填充
Arrays.fill(array,2,7,88);[2,7)下标填充为88
Arrays.sort(array);将数组进行排序
十一、二分查找
针对有序数组,可以使用更高效的二分查找
以升序数组为例,二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小.如果小,就去左边找;否则就去右边找.

public static int binarySearch(
            int[] array,int key,int left,int right) {
        if(left > right) {
            return -1;
        }
        int mid = (left+right)>>1;
        if(array[mid] == key) {
            return mid;
        }else if(array[mid] > key) {
           return binarySearch(array,key,left,mid-1);
        }else {
            return binarySearch(array,key,mid+1,right);
        }
    }

十二、冒泡排序及改进方法

public static void bubbleSort(int[] array) {

        boolean flg = false;
        //趟数
        for (int i = 0; i < array.length-1; i++) {
            flg = false;//因为每一趟都有能有序
            //次数
            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;
                    flg = true;
                }
            }
            if(!flg) {
                return;
            }
        }
    }