Day8 1堆 ，栈 2冒泡排序_冒泡排序的堆栈

jvm在运行java应用程序过程中，会把它所管理的内存划分为若干不同的数据区域。

为什么要有堆和栈？这样设计有什么好处？

1. Java自动管理堆和栈，程序员不能直接地设置栈和堆。

2. Java的堆是一个运行时数据区。堆是由JVM的垃圾回收器自动管理的。堆的优势是可以在程序运行时，动态地分配内存大小，但是正是由于这个原因，它的存取速度较慢。

3. 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小和生存期是必须确定的，缺乏灵活性。

4. 栈有一个很重要的特性，就是存在栈中的数据可以共享。

栈：每一个方法被执行的时候，都会在栈区创建一块空间

​        栈的特点：先进后出

​        方法被调用直至执行完毕的过程，对应入栈到出栈的过程

​        栈是由系统自动分配，速度快，栈式一个连续的内存空间

堆：堆用于存储创建好的对象和数组（数组也是对象）

​        堆是一个不连续的内存空间，分配灵活，速度慢

 

 

public class Demo1 {
 
    public static void main(String[] args) {
        int[] arr = {53,67,34,6,724,8,0};
        //1. 写循环  
        for (int i = 0; i < arr.length/2 ; i++) { //交换的次数 i表示目前是第几轮
            //2. 交换 arr[i]  arr[6-i]
            int c = arr[i];
            arr[i] = arr[6-i];
            arr[6-i] = c;
        }
        //验证  遍历 输出fori
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
        //foreach循环遍历iter   for(数据类型  变量名 : 数组名)
        for(int number  : arr){
            //循环次数根据arr数组的长度，每次循环把当前数组中的数据赋值给number
            System.out.println(number);
        }
    }
}

public class Demo2 {
 
    public static void main(String[] args) {
        int[] arr = {53,67,34,6,724,8,0,60};//length = 8
        //循环里：交换
        for(int i =0;i< arr.length-1 ;i++){//外循环  经过几轮排序 7轮  完全排好
            //每一轮内部又是循环比较  相邻的数  比较7
            for (int j = 0; j < arr.length-1-i; j++) {
                //从小到大：什么情况才需要交换  前面的数 >  后面的数  才交换位置
                //从大到小：  前面的数 < 后面的数
                if( arr[j] < arr[j+1]){
                    // //交换相邻的数  arr[j] arr[j+1]
                    int temp =   arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //验证
        for (int i : arr) {
            System.out.println(i);
        }
 
    }
}

public class Arrays_Demo3 {
    public static void main(String[] args) {
        int[] arr = {53,67,34,6,724,8,0,60};
        //排序sort
        Arrays.sort(arr);//sort底层代码实现，一个一个比较，交换
 
        for (int i : arr) {
            System.out.println(i);
        }
 
        //复制copyOf
        String[] arrA = {"张三","李四","王五"};
        String[] arrB = new String[3];
        //返回值   用一个新数组来接收
        arrB = Arrays.copyOf(arrA,2);//第一个参数：原数据，第二个参数：拷贝长度
 
        for (String s : arrB) {
            System.out.println(s);
        }
 
 
        //查找binarySearch  ---必须先排序
        int[] arrC = {53,67,34,6,724,8,0,60};
        Arrays.sort(arrC);//查找的前提需要  一组排好序的数据
        int weizhi = Arrays.binarySearch(arrC,67);
        System.out.println("下标："+weizhi);
 
        //转换成字符串  toString()
        String str = Arrays.toString(arrC);
        System.out.println(str);
 
        //填充fill
        //Arrays.fill(arrC,0); 全部填充
        //填充前3
        Arrays.fill(arrC,2,6,9);//含头不含尾
        str = Arrays.toString(arrC);
        System.out.println(str);
 
 
 
 
    }
}

public class Arrays_Demo4 {
public class Arrays_Demo3 {
    public static void main(String[] args) {
        int[] arr = {53,67,34,6,724,8,0,60};
        //排序sort
        Arrays.sort(arr);//sort底层代码实现，一个一个比较，交换
 
        for (int i : arr) {
            System.out.println(i);
        }
 
        //复制copyOf
        String[] arrA = {"张三","李四","王五"};
        String[] arrB = new String[3];
        //返回值   用一个新数组来接收
        arrB = Arrays.copyOf(arrA,2);//第一个参数：原数据，第二个参数：拷贝长度
 
        for (String s : arrB) {
            System.out.println(s);
        }
 
 
        //查找binarySearch  ---必须先排序
        int[] arrC = {53,67,34,6,724,8,0,60};
        Arrays.sort(arrC);//查找的前提需要  一组排好序的数据
        int weizhi = Arrays.binarySearch(arrC,67);
        System.out.println("下标："+weizhi);
 
        //转换成字符串  toString()
        String str = Arrays.toString(arrC);
        System.out.println(str);
 
        //填充fill
        //Arrays.fill(arrC,0); 全部填充
        //填充前3
        Arrays.fill(arrC,2,6,9);//含头不含尾
        str = Arrays.toString(arrC);
        System.out.println(str);
 
 
 
 
    }
}