《java学习笔记》之数组

数组

一. 一维数组

1.1一维数组基础语法

//数组
public class ArrayTest01 {
    public static void main(String[] args) {
        //数组的定义(数组一旦创建数组长度不可变)
        //原则：什么时候用静态初始化的方式，什么时候采用动态的初始方式？
        //    当你创建数组的时候，确定数组中存储的具体元素时，采用静态初始化的方式
        //    当你创建数组的时候，不确定将来数组中存储哪些具体数据，可以采用动态初始化的方式，预先分配内存空间

        //静态初始化
        int[] array1 ={1,2,3,4,5};
       //所有数组对象都有length属性（java自带的），用来获取数组中元素个数。
        System.out.println(array1.length);//5
        //动态初始化
        int[] array2 =new int[10];
        System.out.println(array2.length);//10

        //遍历数组
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

        //调用参数为数组的方法遍历数组
        printArray(array2);
        //还可以这样
        printArray(new int[]{1,2,3});

        //查询数组某个位置上的元素
        //数组首位是从零开始的
        //数组中每个元素都是有下标的，下标从0开始，
        // 以1递增。最后一个元素的下表是：length - 1。
        System.out.println(array1[0]);

        //越界了会怎么样
        //System.out.println(array1[5]);//java.lang.ArrayIndexOutOfBoundsException
    }
    //创建一个方法，参数是数组，遍历数组
    public static void printArray(int[] array){
        //增强for循环
        for(int i:array){
            System.out.println(i);
        }
    }
}

1.2 public static void main(String[] args)中的String[] args

public class ArrayTest02 {
    //这个方法程序员写，JVM调
    public static void main(String[] args) {
        //JVM默认传过来的数组长度是0
        //通过测试args不是null,如果是null就会有空指针异常
        System.out.println("JVM传过来的args数组参数，这个数组长度是？ " + args.length);

        //遍历 args
        for (int i = 0; i <args.length ; i++) {
            System.out.println(args[i]);
        }
        /*
在cmd中运行就是：
例如这样运行程序： java ArrayTest05 abc efg hrj 
那么这个时候JVM就会自动将abc efg hrj通过空格的方式分离，自动放到“String[] args”中
    所以main方法上的 String[] args 数组主要是来接受客户输入的参数的
    abc efg hrj  变成 {"abc","efg","hrj"}

        */

    }
}

什么都不做处理

但是其实可以传数据给args数组
在IDEA中是这样操作的：
run–>Edit Configurations–>Program arguments 写参数，逗号隔开例如：

运行结果就变成了：

按照上面的方法在Program arguments 里面填取 小明 123 就可以正确执行了

/*
    模拟一个系统，假设该系统要使用，必须输入用户名和密码(通过args来)
 */
public class ArrayTest03 {
    public static void main(String[] args) {
        //用户名和密码是两组数，所以args.length 会为2
        if(args.length != 2){
            System.out.println("请输入用户名和密码");
            return;
        }

        //执行到这说明输入了用户名和密码
        if ("小明".equals(args[0]) && "123".equals(args[1])){
            System.out.println("密码正确");
            System.out.println("欢迎 " + args[0] + " 使用");
        }else{
            System.out.println("用户名或密码错误");
            return;
        }
    }

}

1.3 数组的扩容

/*Java中数组的扩容：
        先新建一个大容量数组，然后将小容量的数据一个一个拷贝到大数据当中。
*/
public class ArrayTest04 {
    public static void main(String[] args) {
        //怎么进行拷贝？
        //System.arraycopy(五个参数);

        //拷贝源
        int[] array1 = {0,1,2,3,4,5};
        //拷贝目标(拷贝到目标数组上)
        int[] array2 = new int[10];

        //拷贝
        System.arraycopy(array1,1,array2,1,3);
        //遍历
        for (int i: array2){
            System.out.print(i + " ");//0 1 2 3 0 0 0 0 0 0
        }

        System.out.println();

        //完全拷贝
        System.arraycopy(array1,0,array2,0,6);
        for(int i:array2){
            System.out.print(i + " ");//0 1 2 3 4 5 0 0 0 0
        }
    }
}

二. 二维数组

//二维数组
public class ArrayTest05 {
    public static void main(String[] args) {
        //静态初始化
        int[][] array1={
                {1,2,3},
                {4,5},
                {6,7,8,9,10},
        };
        //动态初始化
        int[][] array2 = new int[3][4];

        //二维数组的读和写
        //二维数组的第三个一维数组的第三个元素
        System.out.println(array1[2][2]);//8
        array2[2][1] =3;
        System.out.println(array2[2][1]);//3

        //二维数组的遍历
        for (int i = 0; i < array1.length; i++) {//负责纵行
            for (int j = 0; j < array1[i].length; j++) {//负责横行
                System.out.print(array1[i][j]+ " ");
            }
            //输出一行就换行
            System.out.println();
        }
    }
}

三. 数组工具类Arrays

3.1。排序算法

import java.util.Arrays;

//Arrays是Sun公司提供的数组工具类
//java.util.Arrays
public class ArrayTest06 {
    public static void main(String[] args) {
        //例如排序
        int[] array1 = {8,3,4,5,1,9,2,3,6,0};
        /*Arrays.sort(array1);*/
        /*BubbleSort(array1);*/
        SelectSort(array1);
        //遍历
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + " ");//0 1 2 3 3 4 5 6 8 9
        }
    }

    //我们可以尝试自己定义排序算法
    //冒泡算法java代码实现

    /**
     * 冒泡排序java实现
     * @param array  目标数组
     * @return       已排序数组
     冒泡排序算法
*   1.每一次循环，都要找到最大的那个数字，放到参与比较的这堆数据的最右边。
*   2.核心
*       拿着左边的数字和右边的比较，当左边>右边的时候，交换位置
     */
    public static int[] BubbleSort(int[] array){
        for (int n = array.length - 1; n >= 0 ; n--){
            for (int i= 0; i < n ; i++) {
                //比较
                if (array[i] > array[i + 1]){
                    //交换，大的往右边放
                    int temp = array[i];
                    array [i] = array[i+1];
                    array[i+1] = temp;
                }
            }
        }
        return array;
    }

    //选择算法java实现
    //循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据“交换位置”
    public static int[] SelectSort(int[] array){
        for (int i = 0; i < array.length -1; i++) {
            //假定最小的是最前面的
            int min = i;

            //找出最小项的下标
            for (int j = i + 1; j <= array.length -1; j++) {
                //如果有比min小的
                if (array[j] < array[min]){
                    min = j;
                }
            }

            //如果i不是最小的
            if (i != min){
                //交换
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
        }
        return array;
    }
}

3.2 查找算法

/*
 * 数组元素查找
 *   两种方式：
 *       第一种方式：一个一个找，直到找到为止
 *       第二种方式：二分法查找，这个效率高
 * */
public class ArrayTest07 {
    public static void main(String[] args) {
        int[] array1 = {8,3,4,5,1,9,2,3,6,0};
        System.out.println("该元素在数组" + (arraySearch(array1,6) >= 0 ? "第"+ arraySearch(array1,6) + "位" : "不存在") );
        //该元素在数组第8位

        //二分法要先排序
        int[] array2 ={0,1,2,3,4,5,6,7,8,9,10};
        System.out.println("该元素在数组" + (binarySearch(array2,6) >= 0 ? "第"+ binarySearch(array2,6) + "位" : "不存在") );
        //该元素在数组第6位
    }

    //一个一个找，直到找到为止
    /**
     *
     * @param array  要查找的数组
     * @param dest     要查找的元素
     * @return          如果返回非负数表示数组下标，返回负数代表不存在
     */
    public static int arraySearch(int[] array,int dest){
        for (int i = 0; i < array.length; i++) {
            if (array[i] == dest){
                return i;
            }
        }
        return -1;
    }

    //二分法查找
    /**
     *
     * @param array  要查找的数组
     * @param dest     要查找的元素
     * @return          如果返回非负数表示数组下标，返回负数代表不存在
     */
    public static int binarySearch(int[] array,int dest){
        //开始下标
        int begin = 0;
        //结束下标
        int end = array.length -1;

        while(begin <= end){
            int mid = (begin + end)/2;
            if (mid == dest){
                return mid;
            }else if (mid < dest){
                begin = mid + 1;
            }else if (mid > dest){
                end = mid -1;
            }
        }
        return -1;
    }
}