Java学习12 2020-02-17

内容

1.一维数组
2.一维数组和多态综合使用
3.数组作为参数的传递方式
4.拷贝数组
5.二维数组
6.选择排序和冒泡排序
7.二分法查找

数组是一种引用类型

Java的数组和c/c++有很多相通之处

一.一维数组

1.静态初始化一维数组

类型 [] 名称 = {元素};

比如

int[] a1 = {1,2,3};

2.小知识

①a1.length
就是元素个数，这里是length属性，不是length方法

3.动态初始化一维数组

比如

int[] a1 = new int[4];

注意：动态初始化一维数组，会先在堆内存中分配这个数组，并且数组中每一个元素都采用默认值。

2.小知识(续)

②如果o是一个空指针(空引用)
那么

System.out.println(o);
System.out.println(o.toString());

下面那一行会报空指针异常错误，而上面的输出null。
③初始化的时候是c++的形式也可以，但是不建议写成c++形式

二.一维数组和多态综合使用示例

public class 测试程序 {
    
 public static void main(String[] args){
     
     //动态初始化一维数组
     Animal[] Ani = new Animal[4];
     
     //分别创建两个狗对象和两个猫对象
     Dog d1 = new Dog();
     Dog d2 = new Dog();
     Cat c1 = new Cat();
     Cat c2 = new Cat();
     
     //给数组中的每个元素赋值
     Ani[0] = d1;
     Ani[1] = d2;
     Ani[2] = c1;
     Ani[3] = c2;
     
     //需求：遍历数组，取出每个对象，如果是Dog就执行Eat方法，如果是Cat就执行Move方法
     for(int i = 0;i < Ani.length;i++) {
         //先转换到父类
         Animal temp = Ani[i];
         
         //调用toString方法
         System.out.println(temp);
         
         //强制类型转换(向下转型)
         if(temp instanceof Dog) {
             Dog dog = (Dog)temp;
             dog.Eat();
         }else if(temp instanceof Cat) {
             Cat cat = (Cat) temp;
             cat.Move();
         }
     }
 }
}
//定义一个动物类
 class Animal{
     
 }
 
//定义一个狗类,继承动物类
 class Dog extends Animal{
     //吃方法
     public void Eat() {
         System.out.println("Dog eat!!!");
     }
 }
 
 //定义一个猫类，继承动物类
 class Cat extends Animal{
     //移动方法
     public void Move(){
         System.out.println("Cat move!!!");
     }
 }

输出结果为：

对象.Dog@15db9742
Dog eat!!!
对象.Dog@6d06d69c
Dog eat!!!
对象.Cat@7852e922
Cat move!!!
对象.Cat@4e25154f
Cat move!!!

三.数组作为参数的传递方式

代码示例

public class 测试程序 {
        
     public static void main(String[] args){
         int[] a = {1,2,3};
         
         //传递数组参数的第一种方式
         Arraywatch(a);
         
         //传递数组参数的第二种方式
         Arraywatch(new int[] {4,5,6});
         //主要是这种方式没见过
         
    }
     
    //遍历数组的一个方法
     public static void Arraywatch(int[] a) {//注意这里要把方法定义为静态的
         for(int i = 0;i < a.length;i++) {
             //输出数组每个元素
             System.out.println(a[i]);
         }
     }
}

四.拷贝数组

1.语法

System.arraycopy(源数组，源数组下标，目标数组，目标数组下标，元素个数);

2.使用示例

public class 测试程序 {
        
     public static void main(String[] args){

         //定义源数组
         int[] src = {1,2,3,4,5};
         
         //定义目标数组
         int[] dest = {10,11,12,13,14,15,16,17};
         
         //要求把源数组2 3 4拷贝到目标数组的13 14 15
         System.arraycopy(src, 1, dest, 3, 3);
    
         //遍历目标数组
         for(int i = 0;i < dest.length;i++) {
             System.out.println(dest[i]);
         }
     }
     

}

五.二维数组

1.静态初始化二维数组

示例：

int[][] a = {
                      {},
                      {},
                      {}
                      };

2.动态初始化二维数组

示例

int[][]b = new int[3][4];

六.选择排序和冒泡排序

由于冒泡排序在c语言博客已经写过，这里就不再赘述

选择排序

知识点全在代码里面

public class 测试程序 {
        
     public static void main(String[] args){
         
         //定义数组
         int[] a = {3,1,6,2,5};
         
         //选择排序
         //是经过每一次循环，选出最小的，把最小的放在最左边
         //先模拟执行过程
         /*
          * ①1 3 6 2 5
          * ②1 2 6 3 5
          * ③1 2 3 6 5
          * ④1 2 3 5 6
          * 总共执行四次，
          * 第一次是从第一个开始找，即下标是0
          * 2 1
          * 3 2
          * 4 3
          */
         
         //选择排序
         for(int i = 0;i < a.length - 1;i++) {//执行了四次，所以是元素个数-1
             
             //先假定每一轮最开始的那个元素是最小的
             //赋值最小值下标
             int min = i;
             
             for(int j = i+1;j < a.length;j++){//注意这里是i+1而不是j=i
                 //如果有比a[min]更小的数，则把min重新赋值
                 if(a[min] > a[j]) {
                     //注意，这里和冒泡排序就不一样了，不先交换位置，而是把min重新赋值
                     /*int temp = a[min];
                     a[min] = a[j];
                     a[j] = temp;*/
                     min = j;
                 }
             }   
                
             //如果不是最开始那个min了，说明上面那个if条件曾经成立过，然后就把每一轮最开始的数换成最小的
             //考虑互换
             if(min != i) {
                 int temp = a[min];
                 a[min] = a[i];
                 a[i] = temp;
             }
         }
    
         //输出这个数组
         for(int i = 0;i < a.length;i++) {
             System.out.println(a[i]);
         }
     }
     

}

七.二分法查找

注意：二分法查找是建立在已经排序的数组的基础之上的

知识点全在代码里面

public class 测试程序 {
        
     public static void main(String[] args){
       
         //1,2,3,9,11,13,56共七个元素
         //找13，即下标是5
         /* int begin = 0;
          * int end = 6;
          * int mid = (0+6)/2 = 3
          * 下标是3的这个元素值小于13，所以13在它的右边
          * 所以begin = mid + 1 = 4;
          * mid = (4+6)/2 = 5
          * 5对应的元素正好是13
          * 这就是二分法查找
          */
         
         //定义一个已经排好序的数组
         int [] a = {1,3,4,5,7,8,9,10,23,25,29}; 
         
         //定义并初始化目标元素，比如我要找29这个元素的下标
         int destElement = 29;
         
         //使用方法查找，如果找不到这个元素，就返回-1
         int index = binarySearch(a,destElement);
         
         //输出目标元素的下标
         System.out.println(index);
     }
     
     //定义二分法查找数组元素的方法
     public static int binarySearch(int[] a,int destElement) {
         //先定义开始和结束位置
         int begin = 0;
         int end = a.length - 1;
         
         //使用while循环
         while(begin <= end) {//注意这里是<=而不是<
             //每一次循环都需要求出中间下标
             int  mid = (begin + end)/2;
             
             if(a[mid] == destElement) {
                 return mid;
             }else if(a[mid] > destElement) {//目标元素在中间元素的左边
                 end = mid - 1;
             }else if(a[mid] < destElement) {//目标元素在中间元素的右边
                 begin = mid + 1;
             }
         }
         
         //如果没找到，就返回-1
         return -1;
     }
}