Java基础之一维数组,栈内存,堆内存和数组排序和查找(冒泡排序,选择排序,折半查找)

一.一维数组

一维数组:保存一组相同数据类型的元素

1.声明方式:

数据类型[] 数组名 = 初值;数据类型表示的是数组中保存的元素的数据类型

注意:数组的长度一但确定就不能改变

2.创建数组的方法:
方法一:数据类型[] 数组名 = new 数据类型[数组长度];
方法二:数据类型[] 数组名 = new 数据类型[] {1,2,3,4,5};
方法三:数据类型[] 数组名 = {1,2,3,4,5};简化创建(语法糖)

//遍历打印数组:
/*for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr[i]);
}*/

//在循环外打印数组方法是:
/* 打印数组所有元素的方法:
 * System.out.println(Arrays.toString(数组名));
 * Arrays是数组工具类
 */

public class Kll {
    public static void main(String[] args) {
        //声明一个数组 保存5个int元素
        //关键词 new 表示 会从堆内存[在下边会有解释]中开辟一块空间
        //数组会在堆内存中开辟一块连续的堆内存空间
        int[] arr = new int[5];
        //如何给数组中的元素赋值呢?
        //  是使用下标来进行对数据元素的赋值和取值
        //  下标是从0开始,所以最后一个元素的下标就是长度减一
        //  数组名[下标] = 值;
        arr[3] = 10;
        //下标越界异常
        //ArrayIndexOutOfBoundsException
        //arr[5] = 15;
        System.out.println(arr[3]);
        //把arr保存的地址指向空
        arr = null;
        //NullPointerException(空指针异常)
        //访问了一块不属于你的内存区域
        //arr[3] = 3;
        System.out.println();
    }
}

这是上述创建数组在内存中的部分实现过程

 堆内存和栈内存下面会有讲到

3.找数组对应元素的下标或者是元素

public class Kll {
    public static void main(String[] args) {
        System.out.println(findKeyIndex(1));
        int[] array = {3, 6, 11, 22};
        int index = findKeyIndex(11, array);
        if (index == -1) {
            System.out.println("数组内不存在");
        }
        System.out.println(index);
    }
    //需求: 封装一个函数 传入数字1 返回 一  
    //      数字2 返回 二 ….. 数字5 返回 五
    public static char findKeyIndex (int n) {
        char[] arr = {'一','二','三','四','五'};
                return arr[n - 1];
    }
    /* 需求: 
     * 定义一个数组 数组值 分别 3,6,11,22 
     *  在数组中 查找 11的位置
     */
    public static  int findKeyIndex(int key,int[] array) {
        int index = -1;//声明一个变量保存返回的下标
        //之所以index赋值不能是0是因为,当元素不存在数组时,也会返回一个0
        for (int i = 0; i < array.length; i++) {
            if (key == array[i]) {
                index = i;
                //return i;
            }
        }
        return index;
        //return -1;
    }
}

二.栈内存

特点:
     1.所有函数都会在栈内存中执行,函数执行完毕会自动出栈销毁
     2.先入栈后出栈(只针对函数中调用函数时).

二.堆内存

1.堆内存的特点

1.堆内存会分配内存地址

2.堆内存分配初值:基本数据类型初值是0;引用数据类型初值是null

3.有垃圾回收机制(这块内存没人用就是垃圾)

2.Java数据类型:

基本类型(有八种):四种整数类型(int,short,byte,long),两种浮点数类型(float,double),一种字符类型(char),一种布尔类型(boolean)

引用数据类型:类,接口,数组.

3.注意:

基本数据类型(八个)参数传递时是值的传递

引用数据类型(数组) 参数传递时是地址的传递

 //例子:
public class Kll {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 6, 8, 9, 18};
        reverse(array);
        System.out.println(Arrays.toString(array));
        int a = 10;
        int b = 15;
        fun2(a, b);
        System.out.println(a,b);
    }
    private static void fun2(int a, int b) {
        int temp = a;//声明temp保存数据
        a = b;
        b = temp;
    }
    public static void reverse(int[] array) {

        /*第一种 利用数组进行数组元素倒放
         * int[] arr = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            arr[i] = array[array.length - 1 - i];
        }
        System.out.println(Arrays.toString(arr));
        */
        //第二种 利用变量进行倒放
        for (int i = 0; i < (int)(array.length / 2); i++) {
            int temp =array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        //打印数组
        System.out.println(Arrays.toString(array));

    }
}


//上述代码打印出的数组是交换的是因为:在调用函数时,传参传的是地址
//而基本类型进行传参只穿数值,不是地址,所以打印出来的a和b数值不变

三.排序和查找

这次讲的排序和查找都是最基础的方法

1.数组排序:冒泡排序,选择排序

冒泡排序:

核心思想:交换两个相邻元素的位置
会依次把最大值(或最小值)一个一个找出来,从最后向前依次排序放好

例子:

public class Kll {
    public static void main(String[] args) {
        int[] arr = {3, 2, 5, 1};
        fun1(arr);
    }
    private static void fun1(int[] arr) {
        //外层循环控制比较的趟数(即数组的次数)
        //外层循环减一:表示4个数比较3次
        for (int i = 0; i < arr.length-1; i++) {
            //内层循环控制比较每趟比较的次数(即数组内的元素的次数)
            //内层循环减i是已经排好的数,再减1是为了不让角标越界(是为了减少程序执行次数)
            for (int j = 0; j < arr.length - 1 - i; j++) {
                int temp = arr[j];//声明变量保存元素
                if (temp > arr[j + 1]) {
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }else {
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序:

核心:选择一个数(一般选择第一个数)与其他的数进行比较

例子:

public class Kll {
    public static void fun1(int[] array) {
        int temp;
        //外层循环array.length -1:4个数比较3趟
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i+1; j < array.length - 1; j++) {
                //i+1:是已经确定的数就不用比较了.
                //内层循环控制未进行排序的数与要比较的数进行比较
                if (array[i] > array[j]) {
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
    public static void main(String[] args) {
        int[] array = {2, 6, 5, 4, 1};
        fun1(array);
    }

}

2.数组查找:折半查找:

折半查找(在数组中根据元素查找对应的角标)

前提:必须是在有序数组中查找 

例子:

public class Kll {
    public static void main(String[] args) {
        int[] arr = {1, 11, 22, 33, 44, 55, 66, 77, 99};
        int index = findKeyIndex(arr, 0 );
        System.out.println(index);
    }

    // 折半查找顾名思义就是对半找:1.先把数组(已排好序)的最大值下标和最小值下标用变量表示,把中间值的下标(最大值下标和最小值下标的一半)也用一个变量保存;2.比较查找元素和中间值的大小,然后更换最大值或最小值的值的角标,中间值也随之变化.  
    private static int findKeyIndex(int[] arr,int num) {//数组是升序
        int min = 0;//最小值角标
        int max = arr.length - 1;//最大值角标
        int mid = (min + max) / 2;//中间值角标
        while(num != arr[mid]) {
            if (num > arr[mid]) {
                min = mid + 1;//也可以不加1,加一是因为已经比较了不在范围内,可以
                略掉
                mid = (min + max) / 2;
            }else if (num < arr[mid]) {
                max = mid - 1;也可以不加1,同上加1
                mid = (min + max) / 2;
            }
            if (min > max) {//判断不在数组元素内存在的情况
                mid = -1;
                break;
            }
        }
        return mid;
    }
}