java数组基础知识

数组

定义：

数组是一个存放类型相同、一组数的“容器”。

数据创建

类型[] 变量名 = new 类名[数组大小];

例如：

int[] num = new int[4];
int[] num = {1,2,3,4};

数组创建的时候做的事情：

1.数组在创建的时候会在堆中开辟一个存放N个长度的连续空间
2，给数组中的每个元素赋初值，依据当前数组类型决定的
3.将堆中的地址给具体的引用变量存放

静态创建数组对象时：

指定了数组个数以及数组中每个元素的值

动态创建数组：

创建数组的时候只指定长度，在运行的过程当中给数组的每个索引赋值。
例如：

int[] primes = new int[4];
primes[0] = 2;
primes[1] = 3;
primes[2] =5;
primes[3] =7;

数组常见的属性：

索引：数组中的有序，就是指的是索引有序，数组中索引是从0开始到数组长度-1结束。
长度：数组在定义的时候就会初始化长度，可以用length属性获取数组长度

数组的CRUD

数组的遍历：

有两种遍历方式：

1.普通for循环：

for(int i=0;i<num.length;i++){
System.out.println(num[i]);
}

2.增强for循环:

for(int n:num){
System.out.println(n);
}

给定一个指定长度的数组，进行初始化，初始化的元素范围是[13-109]

/**
     * 传入一个数组，初始化内容，范围为【13-109】
     * @param num
     */
    public static void initArray(int[] num) {
        try {
            for(int i=0;i<num.length;i++) {
                num[i]=(int)(Math.random()*97+13);
            }
        } catch (NullPointerException e) {
            throw new NullPointerException("传入的对象为null");
        }catch(ArrayIndexOutOfBoundsException e) {
            throw new ArrayIndexOutOfBoundsException("传入对象越界");
        }
    }

迭代数组中的每个元素

/**
     * 遍历数组元素，通过字符串输出
     * @param num 传入的数组
     * @return 返回数组中的每个元素
     */
    public static String toString(int[] num) {
        if(num==null) {
            return "null";
        }
        int iMax = num.length-1;
        if(iMax==-1) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i=0;;i++) {
            sb.append(num[i]);
            if(i==iMax) {
                sb.append("]");
                return sb.toString();
            }
            sb.append(",");
        }
    }

修改数组中的某个值。将要修改的值传入 改变的值也传入

/**
     * 修改数组中的某个值。将要修改的值传入 改变的值也传入
     * @param num 要修改的数组
     * @param oldValue 要修改的值
     * @param newValue 要改变的值
     */
    public static void update(int[] num,int oldValue,int newValue) {
        int index = QuerByValue(num, oldValue);
        num[index]=num[newValue];
    }

截取数组 截取数组的指定位置的元素 变为一个新的数组返回

/**
     * 截取数组
     * @param num 要截取的数组
     * @param sIndex 其实索引
     * @param eIndex 
     * @return
     */
    public static int[] subArrys(int[] num,int sIndex,int eIndex) {
        int newNum[]=new int[eIndex-sIndex];
        for(int i=sIndex;i<eIndex;i++) {
            newNum[i-sIndex]=num[i];
        }
        return newNum;
    }

给数组排序 从小到大

冒泡排序

/**
     * 冒泡排序
     * @param num   传入的数组
     */
    public static void bubbleSort(int[] num) {
        for(int i=0;i<num.length-1;i++) {//趟数
            boolean flag = true;
            System.out.println("第"+(i+1)+"趟:");
            for(int j=0;j<num.length-1-i;j++) {//次数
                if(num[j]>num[j+1]) {
                    num[j]=num[j]^num[j+1];
                    num[j+1]=num[j]^num[j+1];
                    num[j]=num[j]^num[j+1];
                    flag= false;
                }
                System.out.println("第"+(j+1)+"次"+toString(num));
            }
            if(flag) {
                return;
            }
        }
    }

选择排序

/**
     * 选择排序
     * @param num 传入的数组
     */
    public static void selectedSort(int[] num) {
        for(int i=0;i<num.length-1;i++) {
            int index =i;
            for(int j=i+1;j<num.length;j++) {
                if(num[j]>num[j+1]) {
                    index=j;
                }
            }
            if(index!=i) {
                num[i]=num[index]^num[i];
                num[index]=num[index]^num[i];
                num[i]=num[index]^num[i];
            }
        }
    }

查找数组中指定的元素 如果没有返回-1

普通查找

/**
     * 获取指定值的索引
     * @param num   传入的数组
     * @param oldValue  指定的值
     * @return  返回索引
     */
    public static int QuerByValue(int[] num,int oldValue) {
        for(int i=0;i<num.length;i++) {
            if(num[i]==oldValue) {
                return i;
            }
        }
        return -1;
    }

二分法查找

/**
     * 二分查找发查找指定的索引
     * @param num 传入的数组
     * @param value 查找的值
     * @return 返回索引
     */
    public static int binerySearch(int[] num,int value) {
        int min =0;
        int max=num.length-1;
        int mid;
        while(min<=max) {
            mid=(min+max)/2;
            if(value>num[mid]) {
                min=mid+1;
            }else if(value<num[mid]) {
                max=mid-1;
            }else {
                return mid;
            }
        }
        return -1;
    }

删除数组中指定的元素 删除一个

    /**
     * 删除数组中指定的一个数
     * @param num 传入的数组
     * @param value 删除的值
     * @return 返回新的数组
     */
    public static int[] remove(int[] num,int value) {
        int index =QuerByValue(num, value);
        int[] newNum=new int[num.length-1];
        for(int i=0;i<index;i++) {
            newNum[i]=num[i];
        }
        for(int j=index+1;j<num.length;j++) {
            newNum[j-1]=num[j];
        }
        return newNum;
    }