Ten-TwelveDay_java 数组及其排序查找算法

//tenDay

1、finalize()方法

1> 在object中的源码是：

protected void finalize() throws Throwable{ }（已过时）

2> finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的

3> 这个方法不需要程序员手动调用，JVM的垃圾回收机制负责调用它，它只需要重写，重写完程序自动调用。

4> finalize()方法的执行时机：

当一个java对象即将被垃圾回收机制回收的时候调用。

5> 作用：如果希望在对象被销毁时机执行一段代码的话，这段代码就可以写在finalize()方法中

6> 由于垃圾过少或者时间不到，垃圾回收器不一定会启动，全看运气~~。

7> System.gc() ,可以提高垃圾回收器启动概率（只是概率，还是不一定启动~~！）

public class Finalize01 {
    protected void finalize() throws Throwable{
        System.out.println("销毁！");//在这个方法体里可以记录对象销毁时间点。
    }
​
    public static void main(String[] args) {
        Finalize01 f=new Finalize01();
        f=null;
        System.gc();
    }
}

2、hashCode()

/*
在object中的源码：
public native int hashCode();//不是抽象对象，带有native关键字，底层调用C++程序
返回值是哈希码：Java对象的内存地址经过哈希算法得出的一个值。
 */
public class HashCode {
    public static void main(String[] args) {
        HashCode h=new HashCode();
        int hc=h.hashCode();
        System.out.println(hc);//509886383 这个值等同于内存地址
    }
}

//elevenDay

1、mian方法的String数组

public static void main(String[] args) {
    System.out.println("jvm调用main的String数组，长度为："+args.length);//0,说明它是个空数组{}
}

这个数组是留给用户的，用户可以在控制台上输入参数，参数自动转换为“String[] args”。

例如：在控制台上输入：java ElevenDay（这个是我创建的包）abc bac cab ,则jvm会自动以空格分离abc bac cab 放到String[] args中。转换成字符串为：{"abc","bac","cab"}

在idea中可以在run中进入Edit configuration 在program arguments写入元素abc bca cab 然后保存 运行就行了。

2、引用数据类型做数组元素

public class AnimalClass {
    public static void main(String[] args) {
        Animal[] ans={new cat(),new fish()};//猫与鱼继承了动物类，皆属于动物，则可进入动物数组中
        for (int i = 0; i < ans.length; i++) {
            ans[i].move();//可能是猫也可能是鱼在动。
            //想要猫或鱼执行eat()方法，则需要强制转换。因为ans[i]是Animal类型的
            if(ans[i] instanceof cat){
                cat c=(cat) ans[i];//如果是cat类型，则转换成cat类型
                c.eat();//调用猫吃鱼
            }else if (ans[i] instanceof fish){
                fish f=(fish)ans[i];//如果是fish类型，则转换成fish类型
                f.eat();//调用大鱼吃小鱼
            }
        }
​
    }
}
//Animal类
class Animal{
    public void move(){
        System.out.println("移动！");
    }
}
//cat类继承Animal类
class cat extends Animal{
    public void move() {
        System.out.println("猫在跳！");
    }
    public void eat(){
        System.out.println("猫在吃鱼！");
    }
}
//fish类继承Animal类
class fish extends Animal{
    public  void move(){
        System.out.println("鱼在游泳");
    }
    public void eat(){
        System.out.println("大鱼吃小鱼！");
    }
}

运行结果：

猫在跳！

猫在吃鱼！

鱼在游泳

大鱼吃小鱼！

3、数组扩容

当一个数组已经装满，不够用了，则就在创建一个大的数组，把小数组里的数据拷贝到大数组里

拓展：数组扩容效率很低，是因为需要拷贝，所以在工作当中尽量减少数组拷贝。

使用方法:System.arraycopy();参数列表有五个。

public static native void arraycopy(

　　　　　　　　　　　　Object src(拷贝源),

　　　　　　　　　　　　 int srcPos(源开始下标),　

　　　　　　　　　　　　 Object dest(目标),

　　　　　　　　　　　　int destPos(目标开始下标),

　　　　　　　　　　　　int length(需要拷贝的长度)

　　　　　　　　　　　　);

public static void main(String[] args) {
    //拷贝源数组
    int[] array={1,23,45,34,2};
    //拷贝到的目标数组
    int[] arraycopy=new int[10];
    //调用JDK System类中的arraycopy方法（快捷键 ctrl+P 查看提示信息）
    //从array中的下标为1的元素开始拷贝4个元素到arraycopy数组中的下标为2的位置往后
    System.arraycopy(array,1,arraycopy,2,4);// 0 0 23 45 34 2 0 0 0 0 
    for (int i = 0; i < arraycopy.length; i++) {
        System.out.print(arraycopy[i]+" ");
    }
}

如果是引用型数组，则拷贝的是地址。

4、二维数组

二维数组是特殊的一维数组：每一个元素是一个一维数组。二维数组很少使用。

public static void main(String[] args) {
    int[][] a={{1,2},{3,4},{4,5}};//二维的静态初始化 三行两列
    int[][] b=new int[2][2];//二维的动态初始化 两行两列
    System.out.println(a.length);//3
    System.out.println(a[0].length);//2
    System.out.println(a[1][1]);//取出的是二维数组的第二行的第二个也就是数字4
    System.out.println("===================");
    //遍历二维数组
    for (int i = 0; i < a.length; i++) {
        for(int j=0;j< a[i].length;j++){
            System.out.println("第"+i+"行的第"+j+"列的元素："+a[i][j]);
        }
    }
}

//twelveDay

1、数组的优缺点：

优点：检索效率高（地址连续，占用空间大小一致）

缺点：随机增删效率低，无法存储大数据量

2、冒泡排序代码

public static void main(String[] args) {
    int[] nums={9,8,10,7,6,0,11};
    int temp;
    for (int i = 1; i < nums.length; i++) {
        for (int n = 0; n < nums.length-i; n++) {
            if(nums[n]>nums[n+1]){
                temp=nums[n];
                nums[n]=nums[n+1];
                nums[n+1]=temp;
            }
        }
    }
    for (int i = 0; i < nums.length; i++) {
        System.out.print(nums[i]+" ");
    }
​
}

 

3、选择排序代码

/*
选择排序
效率比冒泡的高
找到最小的，把最小的和最前面的交换位置，然后第一个位置不动，找后面中最小的数与第二个位置交换，
第二个位置不动，再找后面的数中最小的与第三个数交换位置.......
 */
public class ChooseSort {
    public static void main(String[] args) {
        int[] nums={3,1,5,8,2,0};
        for(int j=0; j<nums.length-1;j++) {
            int min=j;//默认最前面位置的数是最小的
            for (int i=j+1;i<nums.length;i++) {
                if(nums[min]>nums[i]) {
                    min = i;//后面若是有更小的 则把最小数的下标给min。
                }
            }
            //若是min与最开始默认下标不一样，说明需要交换，把最小数与前面的数交换位置
            if(min!=j){
                int temp;
                temp=nums[j];
                nums[j]=nums[min];
                nums[min]=temp;
            }
        }
        for (int num : nums) {
            System.out.print(num+" ");
        }
​
    }
}

4、二分查找代码

二分法查找建立在排序的基础上 效率高于穷举法查找

public class ArrayUtil {
    public static void main(String[] args) {
        int[] nums={1,3,5,7,9};
        int index=ArraySearch(nums,9);
        System.out.println(index);
    }
​
    private static int ArraySearch(int[] nums, int num) {
        int top=0;//开始下标
        int last=nums.length-1;//末尾下标
        while(top<=last) {     //只要开始下标小于等于结束下标 就继续循环
            int mid=(top+last)/2;//中间下标
            if (num == nums[mid]) //被查找数字与中间下标数字相等 则返回mid
                return mid;
            else if (num >nums[mid] ) //若查找数字大于中间数字 则向右半部分查找：开始下标变化
                top = mid + 1;
            else                //若查找数字小于中间数字，则向左半部分查找：末尾下标变化
                last=mid-1;
        }
        return -1; //找不到 返回-1
    }
}

//sun公司已经写好了二分查找法，只需类名.方法名即可 
// Arrays.binarySearch(数组,要查找的值);
int index1= Arrays.binarySearch(nums,5);
System.out.println(index1);//2