Stoker的Java入门教学之数组

Java入门教学之数组

1.栈内存与堆内存

栈内存
特点:
1.所有函数在执行时都会进入栈内存(函数的入栈)，
当函数执行完毕后会出栈被系统销毁。
2.先入栈后出栈 。入栈又叫压栈， 出栈又叫弹栈。

堆内存
特点
1.堆内存会分配内存地址
2.堆内存会分配初值，基本数据类型初值 0 ，
引用数据类型初值 null。
3.有垃圾回收机制(这块内存没人用 就是垃圾)。

2.数组

数组相当于一个容器，用来保存一组相同数据类型的元素。
声明方式：
数据类型[] 数组名 = 初值
注意：这里的数据类型表示的是数组中保存的元素的数据类型。

//声明一个数组 保存五个int元素
        //注意:数组的长度一旦确定,就不能改变
        //关键词new 表示会从堆内存中开辟一块空间
        //数组会在堆内存中开辟一块连续的内存空间
        int[] array = new int[5];
        //如何给数组中的元素赋值
        //使用下标来进行对数组元素的赋值和取值
        //下标从0开始
        //数组名[下标] = 值;

        array[3] = 10;
        //ArrayIndexOutOfBoundsException
        //下标越界异常
        //array[5] = 15;
        System.out.println(array[3]);
        //把array保存的地址指向空
        array = null;
        //NullPointerException(空指针异常)
        //访问一块不属于你的内存区域
        //array[3] = 3;

数组的遍历

遍历数组通俗点就是说把数组中的每个数都读一遍（部分有if条件+break的则可能不会完全遍历），你可以对于数组中的每个数进行处理，亦或者是找到数组中那个你需要的数。

//重点:打印数组中的每一个元素(遍历数组)
        //循环遍历数组(for)
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }

数组的简单练习
1.根据下标查找对应的元素
2.根据元素查找对应的下标

public class Test {
    //需求: 封装一个函数 传入数字1 返回 一  
    //      数字2 返回 二 ….. 数字5 返回 五

    public static char findKeytToIndex(int n) {
        //声明char类型的数组 保存一二三四五
        char [] array = {'一','二','三','四'};
        return array[n-1];
    }
    /* 需求: 封装一个函数
     * 定义一个数组 数组值 分别 3,6,11,22 
     *  在数组中 查找 11的位置
     */
    public static void main(String[] args) {
        int[] array = new int[] {3, 6, 11, 22};
        int key = 11;
        int index = findIndexToKey(array, key);
        if (index == -1) {
            System.out.println("该数组没有元素");
        }
        System.out.println(index);
            }
    private static int findIndexToKey(int[] array,int key) {
        //声明一个变量保存返回的下标
        int index = 0;
        for (int i = 0; i < array.length; i++) {
            //查找相同的元素
            if (array[i] == key) {
                index =i;
            }
        }
        return index;
    }

}

数组的排序

1.元素的翻转
基本数据类型(int) 参数传递时是值的传递。
引用数据类型(数组) 参数传递时是地址的传递。

public static void reverse(int[] array) {
        //计算交换次数
        int num = array.length / 2;
        //遍历数组
        for (int i = 0; i < num; i++) {
            //交换
            //array[i]------array[length-1-i]
            int temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i]=temp;
        }
        //System.out.println(Arrays.toString(array));
    }
    public static void main(String[] args) {
//      int a = 10;
//      int b = 15;
//      //交换两个变量的值
//      int temp = a;
//      a = b;
//      b = temp;
//      System.out.println(a);
//      System.out.println(b);
        int[] array = {1, 2, 3, 6, 8};
        reverse(array);
        System.out.println(Arrays.toString(array));
    }

2.冒泡排序
核心思想:交换两个相邻元素的位置。

public static void main(String[] args) {
        int[] array = {3, 2, 5, 1};
        //外层循环控制比较的趟数
        //内层循环控制一趟计较的次数
        //外层循环-1表示4个数比3趟
        //内层循环-1表示防止角标越界
        //内层循环-i表示每一趟比较确定一个数 就少一次比较
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                //交换相邻位置的元素比较大小
                if (array[j] > array[j+1]) {
                    //j和j+1进行交换
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }

            }
        }
        System.out.println(Arrays.toString(array));
    }

3.选择排序
核心思想:选择一个数(一般选第一个数)与其他的数进行比较交换。

public static void main(String[] args) {
        int[] array = {3, 2, 5, 1};
        //外循环-1 四个数比三趟
        //内循环1+i表示每一趟确定的数不用再重复比较了
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 1 +i; j < array.length; j++) {
                if (array[i] > array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] =temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

4.折半查找(在数组中根据元素查找对应的角标)
前提:必须在有序的数组中查找。

public static void main(String[] args) {
        int[] array = {1, 11, 22, 33, 44, 55, 66, 77, 99};
        //声明最大最小中间角标
        int max =array.length-1 ;
        int min = 0;
        int mid = (min + max) / 2;
        //声明要查找的值
        int key = 1;
        //循环查找
        //明确的循环结束条件 中间角标对应的值和查找的值相等,停止循环)
        while (array[mid] != key) {
            //挪动角标
            if (key > array[mid]) {
                min = mid +1;
            }
            if (key < array[mid]) {
                max = mid - 1;
            }
            //重新计算中间角标
            mid = (min + max) / 2;
            if (min > max) {
                //确定数组中没这个值
                mid = -1;
                //停止循环
                break;
            }
        }
        System.out.println("要寻找的值得下标是" + mid);
    }