01-java数组的应用

数组概念

数组是先声明，在开辟空间的，但是开辟完空间后长度是固定的
所以数组一旦创建完成之后，它的长度就不变了
数组没有赋值，但是会有个默认值
* int 类型默认值是 0
* double 是 0.00
* boolean 是false
* String 是 null

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 数组，是先声明，在开辟空间的，但是开辟完空间后，长度就固定了
         * 所以数组一旦创建完成之后，它的长度就不变了
         * 数组没有赋值，但是会有个默认值
         * int 类型默认值是 0
         * double 是 0.00
         * boolean 是false
         * String 是 null
         */
        /**
         * 1、实例：随机在1-1000里面抽取一位数，能够被3整除就可以保存，知道存储10位就停止
         * 2、可以实现每次插入数据后，数组都是从大到小排序的吗？
         */
        Random random = new Random();
        int[] nums = new int[10];
        int i = 0;
        while (true) {
            int num = random.nextInt(1000);
            if(num%3 == 0){
                nums[i] = num;
                i++;
                System.out.println(Arrays.toString(nums));
            }
            if(i == 10){
                break;
            }
        }
    }
}

数组与基本数据类型的区别

/**
* 堆栈
* 栈区是先进后出
* main方法执行后，会在栈区分配空间，
* 遇到基本数据类型，都会直接在栈区保存数据 （int i = 10）
* 遇到引用数据类型，（int[] i = {1,2,3}）,现在堆区开辟空间存储数据，然后在栈区保存堆区的地址
/
/*
* 实现数组的拷贝
* 对于有序数组的插入与删除操作本质就是数组的拷贝
/
/*
* 数组的插入
*/

实现数组的添加数据

 @Test
    public void test01(){
        /**
         * 实现数组的拷贝
         * 对于有序数组的插入与删除操作本质就是数组的拷贝
         */
        /**
         * 数组的插入
         */
        // 目标数组
        int[] target;
        // 原数组
        int[] source = {1, 12, 23, 34};
        // 需要插入的数据
        int num = 56;
        // 记录要插入的位置
        int index = -1;
        //判断出新的数组应该在那个位置
        for (int i = 0; i < source.length; i++) {
            if(num <= source[i]){
                index = i; //找到位置，跳出循环
                break;
            }
        }
        if(index == -1){
            //在数组的最后以为插入
            target = Arrays.copyOf(source, source.length + 1); //把原数组赋值给新数组，并扩容一位
            target[source.length] = num; //并在最后一位插入数据
        }else{
            //在中间插入数据
            target = new int[source.length + 1];
            //新数组的赋值
            for(int i =0;i<target.length;i++){
                //如果i < 要插入的位置 那么就全部赋值给位置
                if(i < index){
                    target[i] = source[i];
                }else if(i == index){
                    target[i] = num;
                }else if(i > index){
                    target[i] = source[i - 1];
                }
            }
        }
        System.out.println(Arrays.toString(target));
    }

通过Arrays和System来实现数据添加

//案例
        int[] target = new int[20];
        int[] source = {1, 12, 23, 34,45,56,67,78};
        int num = 40;
        int index = 5;
        System.arraycopy(source,0,target,0,5);
        target[index] = num;
        System.arraycopy(source,index,target,index+1,source.length - index);
        System.out.println(Arrays.toString(target));

@Test
    public void test02(){
        /**
         * jdk中也有实现 System
         */
        // 目标数组
        int[] target;
        // 原数组
        int[] source = {1, 12, 23, 34};
        // 需要插入的数据
        int num = 2;
        // 记录要插入的位置
        int index = -1;
        //判断出新的数组应该在那个位置
        for (int i = 0; i < source.length; i++) {
            if(num <= source[i]){
                index = i; //找到位置，跳出循环
                break;
            }
        }
        if(index == -1){
            //在数组的最后以为插入
            target = Arrays.copyOf(source, source.length + 1); //把原数组赋值给新数组，并扩容一位
            target[source.length] = num; //并在最后一位插入数据
        }else{
            //在中间插入数据
            target = new int[source.length + 1];
            //新数组的赋值
            //index前面赋值
            System.arraycopy(source,0,target,0,index);
            //index赋值
            target[index] = num;
            //index
            System.arraycopy(source,index,target,index+1,source.length - index);
        }
        System.out.println(Arrays.toString(target));

    }

数组的冒泡排序

    /**
     * 冒泡排序
     */
    @Test
    public void test03(){
        int[] nums = {1, 34, 23, 12, 90, 35};
        int temp = 0;
        for(int i=0; i<nums.length - 1; i++){
            for(int j = 0; j< nums.length - 1 - i; j++){
                //前面一个数大于后面一个数交换位置
                if(nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }

数组案例实操

/**
* 使用数组保存，提前先初始化一部分数据,数组长度不可以变
* 然后输入字符串，动态插入，如果数组长度不够，可以动态扩容
*/

    /**
     * 判断数组是否有空串
     */
    public Boolean checkStringArray(String[] names){
        for (String name : names) {
            if ("".equals(name) || name == null) {
                return true;
            }
        }
        return false;
    }

 @Test
    public void test04(){
        String[] names = {"hehe", "zhangsan", "lisi", "wangcai"};
        String[] newNames; //扩展数组
        String next;
        Arrays.toString(names);
        System.out.println(Arrays.toString(names));
        //现在就输入字符串
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("请输入数据：");
            next = scanner.next();
            //判断names是否有空串
            if(checkStringArray(names)){
                //判断第几个为空
                for(int i=0; i<names.length;i++){
                    if(names[i] == null || names[i].equals("")){
                        names[i] = next;
                        break;
                    }
                }
            }else{
                //字符串不为空。动态扩容50%
                newNames = new String[names.length + (Integer)names.length/2];
                System.arraycopy(names, 0, newNames, 0, names.length);
                for(int i =0;i<newNames.length;i++){
                    if(newNames[i] == null || newNames[i].equals("")){
                        newNames[i] = next;
                        break;
                    }
                }
                //直接覆盖原来的数组
                names = newNames;
            }
            System.out.println(Arrays.toString(names));
        }
    }