Java基础第二遍-05-数组-排序

数组

1. 定义：
   1. 一个存放数据的容器
   2. 同一种数据类型的集合
   3. 对存储的数据自动建立索引（下标）下标从0开始
2. 创建
   1. 格式：
      1. 数据类型[] 数组名=new 数据类型[元素个数，或数组长度]；
      2. 数据类型[] 数组名=
      3. 数据类型[] 数组名=new int[]
      4. 数据类型 数组名[]=new 数据类型[元素个数，或数组长度]；
      5. 数据类型 数组名[]=
      6. 数据类型 数组名[]=new int[]
3. 数组的加载机制-引用数据类型（Java称为引用，C称为指针）
   1. 
4. 打印实体
   1. @左边的中括号代表此实体为数组，I代表为Int类型，@右边可以理解为实体的内存地址
5. 两个方法操作同一个数组，不需要对这个数组进行返回，因为参数传递过去之后，他们操作的是同一片内存空间中的数组

数组基本操作

1. 获取最大值

//获取最大值
public class Demo01 {
    public static void main(String[] args) {
        int[] a={1,3,4,5,232,32,5,65,756,86543,7,8768};
        //元素方法
        int maxElement=a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i]>maxElement){
                maxElement=a[i];
            }
        }
        System.out.println("最大值为："+maxElement);
        //角标方法
        int maxIndex=0;
        for (int i = 0; i < a.length; i++) {
            if(a[i]>a[maxIndex]){
                maxIndex=i;
            }
        }
        System.out.println("最大值为："+a[maxIndex]);
    }
}

2. 选择排序

//选择排序
public class Demo03 {
    public static void main(String[] args) {
        int[] a={1,3,4,5,232,32,5,65,756,86543,7,8768};
        //拿到一个值和后面的每一个值都比一下，最后一个值不用比较，必然是最小或最大
//        for (int i = 0; i < a.length-1; i++) {
//            //因为左边的数是经过选择的数，可以排除所以j=i+1（相当于选择第i个数，永远与i+1到a.length区间的数进行比较）
//            for (int j = i+1; j < a.length; j++) {
//                if (a[i]>a[j]){
//                    int temp=0;
//                    temp=a[j];
//                    a[j]=a[i];
//                    a[i]=temp;
//                }
//            }
//        }
//        System.out.println(Arrays.toString(a));

        //对选择排序进行优化---减少数组元素置换次数
        /*
        * 思路：定义两个变量，记录最大值num，和最大值的下标index，最后进行一次置换操作
        * */
        int num;
        int index;
        for (int i = 0; i < a.length-1; i++) {
            index=i;
            num=a[i];
            for (int j = i+1; j < a.length; j++) {
                if (num<a[j]){
                    num=a[j];
                    index=j;
                }
            }
            if (index!=i){
                int temp = a[i];
                a[i]=a[index];
                a[index]=temp;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

3. 冒泡排序

//冒泡排序
public class Demo02 {
    public static void main(String[] args) {
        int[] a={1,3,4,5,232,32,5,65,756,86543,7,8768};
        int temp=0;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                if (a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

4. 二分查找

//折半查找---有前提：需要是顺序的
public class Demo04 {
    public static void main(String[] args) {
        int[] a={1,3,4,5,232,32,5,65,756,86543,7,8768};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(halfSearch(a, 7));
    }
    public static int halfSearch(int[] a,int key){
        //定义三个变量
        int min=0;
        int max=a.length-1;
        int mid=(min+max)/2;//这里会自动丢失精度
        while (a[mid]!=key){
            if (key>a[mid]){
                //就将min向数大的那一方移动
                min=mid+1;
            }else if(key<a[mid]){
                //将max向数小的那一方移动
                max=mid-1;
            }else {
                return mid;
            }
            mid=(min+max)/2;
            if (max<min){
                return -1;
            }
        }
        return mid;
    }
}

数组应用之进制转换

package com.bixiangdong.arr;

import java.util.Arrays;

//进制转换
//将10进制转为16、8、2等进制
public class Demo05 {
    public static void main(String[] args) {
        to16(13);
        to8(13);
        to2(13);
    }
    //转换为16进制
    public static void to16(int num){
        trans(num,15,4);
    }
    //转换为8进制
    public static void to8(int num){
        trans(num,7,3);
    }
    //转换为2进制
    public static void to2(int num){
        trans(num,1,1);
    }
    //进制转换工具类
    public static void trans(int num,int count,int offSet){
        //如果num=0
        if (num==0){
            return;
        }
        //定义字符表
        char[] chrs = {'0','1','2','3',
                        '4','5','6','7',
                        '8','9','A','B',
                        'C','D','E','F'};

        //建立数组存储转换的进制数
        char[] temp=new char[32];
        int pos=temp.length-1;
        //3个二进制数可以看成一个八进制数
        //4个二进制数可以看成一个十六进制数
        //1个二进制数就是一个二进制数

        //！！！核心
        while (num!=0){
            temp[pos--]=chrs[num&count];
            num = num >>> offSet;
        }

        for (int i = pos; i<temp.length; i++) {
            System.out.print(temp[i]);
        }
        System.out.println();
    }
}

二维数组

1. 创建
	1. 格式：第一个[]的意思是，可以拥有一维数组的个数；第二个[]的意思是，一维数组的长度

int[][] a=new int[1][1];
int[][] b={{},{}};
int[][] c=new int[][]{{},{}};
int a1[][] =new int[1][1];
int b1[][]={{},{}};
int c1[][]=new int[][]{{},{}};

2. 二维数组的内存加载
	1. ![image](https://img2020.cnblogs.com/blog/2225033/202110/2225033-20211024184755304-756517322.png)
	2. 先在堆内存中创建一个一维数组A，数组A为引用类型默认值为null，然后创建其他的一维数组BCD等（BCD等为具体数组类型），将BCD数组内存地址存入A的数组空间中，然后再将A数组内存地址赋值给栈内存中的变量arr

内存的划分

1. 内存分为几个区域，每个区域的数据处理方式不同
   1. 寄存器：cpu处理
   2. 本地方法区：系统相关
   3. 方法区
   4. 栈内存
      1. 存储的都是局部变量（方法内变量）
      2. 变量所属的作用域一旦结束，变量就自动释放
   5. 堆内存
      1. 存储数组和对象（数组就是对象），通过new建立的都存在堆中
      2. 堆内存每一个变量会进行默认初始化（空数组），初始化的值根据数据类型的不同而不同。
      3. Java的垃圾回收机制进行内存释放
2. 数组的加载示例：
   1. arr=null;时切断引用联系，堆内存中的数据，将被JVM进行回收