java语言学习第四篇（数组）

       本篇主要内容：     1、数组的定义   2、数组的操作  3、值传递与引用传递   4、数组的排序   5、数组元素的查找

数组的定义：

         首先我们为什么要定义数组，看下面的代码：

public double getInfo（）{
    double weight=95.5；
    double height=178；
    return weight，height；
}

       我们都知道java语言中的方法不能有多个返回值，因此上述定义的方法时不合理的。

       那我们在java语言中如何实现返回多个值的效果呢？          数组可以帮我们解决这个问题：

public double [] getInfo(){
    double [] info=new double [2];
    double weight =95.5;
    double height=1.69;
    info[0]=weight;
    info[1]=height;
    return info;
}

         将于返回的值放到数组中，就可以间接实现返回多个值的效果。

    接下来；                  问                  什么是数组？

          官方定义：数组是相同数据类型的数据按顺序组成的一种引用数据类型。

          1、基本数据类型元素构成的数组也是引用类型。2、这里的“相同数据类型”是指数据在内存中的数据类型。

int [] ageArray={22,34,45};//存放int类型数据的数组
double [] priceArray=new double[]{9.9,1};//存放double类型数据的数组
String [] nameArray=new String [3];//存放String类型数据的数组

这里引用下面的代码再强调一下顺序性：

public class ArrayTest{
    public static void main(String []args){
        String [] nameArray=new String [3];
        nameArray[0]="张三";
        nameArray[1]="李四";
        nameArray[2]="王五";
        system.out.println(nameArray[1]);
    }

}

然后是   声明数组：

      声明一维数组：数组元素类型 [ ] 数组名       

String [] countryArray;

   声明二维数组：数组元素类型 [ ] [ ] 数组名

Double [][]wageArray;

学会了声明数组接下来        实例化数组：

       声明数组仅仅给出了元素的数据类型和数组的名字，要使用数组就必须为它分配内存空间，即实例化数组。当实例化一个数组时就申请了一段连续的内存空间存储数组中的元素。

        实例化数组的两种方式：

          1、数组分配内存空间时指明数组长度，语法格式：数组名=new 数组元素数据类型[数组元素个数]

                  说明：这种方式实例化数组后系统会为数组中的元素赋默认值，例如float数组中的元素的默认值是0.0f，引用类型数组中的元素默认值是null。

                      一维数组：

public class ArrayTest{
    public static void main(String []args){
    String []nameArray;//声明数组
    nameArray=new String[3];//实例化数组
    system.out.println(nameArray[1]);//输出null
    }
}

                二维数组：

public class Arraytest{
    public static void main(String[]args){
        double[][]wageArrays;//声明数组
        wageArrays=new double[2][30];//实例化数组
        System.out.println(wageArrays[1][26]);//输出0.0
    }
}

   上面第四行代码的部分注解：第一的中括号表示该二维数组有多少个一维数组；第二个括号表示一个一维数组能存储多少个数据；该二维数组表示包含两个一维数组，每个一位数组可以存储30个数据。

public class ArrayTest{
    public static void main （String [ ]args）{
        int [][]array;//声明数组
        array=new int [2][];
        array[0]=new int[2];//设定二维数组中第一个一维数组可以存储2个数据
        array[1]=new int [30];//设定二维数组中第二个一维数组可存储30个数据
        array[1][24]=2;
        System.out.println(array[1][24]);
    }
}

         上面代码第四五六句执行完后数组实例化完成

第一个中括号表示该二维数组含有多少个一维数组，第二个中括号表示每个一维数组中存储个数待定：该二维数组中包含2个一维数组，第一个一维数组可以存储2个数据，第二个一维数组可以存储30个数据。

     2、采用穷举法实例化数组：

                                                      一位数组：

public class ArrayTest{
    public static void main（String []args）{
        int[]evenNumber={2,3,4,,5};
        System.out.println(evenNumber(2));//输出2
    }
}

                                     二维数组：

public class ArrayTest{
    public static void main(String[]args){
        int [][]scoreArray1={{92,34,45},{23,34,45}};//声明并实例化数组
        int [][]scoreArray2={{96，34，45}，{34，12，65}}；//声明并实例化数组
        System.out.println(scoreArray[1][2]);
        System.out.println(scoreArray[1][1]);
    }

}

           注意：采用穷举法实例化数组时，必须与声明数组代码放在一条语句中完成。

操作数组元素：

     数组中的元素通过数组名和数组下标来操作数据，下标从零开始：

             为元素赋值：

public class ArrayTest{
    public static void main(String[]args){
        int[]evenNumber=new int [4];
        evenNumber[0]=1;
        evenNumber[1]=2;
        evenNumber[2]=3;
        evenNumber[3]=4;
        System.out,println(evenNumber[1]);//输出4
    }
}

获取元素值：

public class ArrayTest{
    public static void main(String[]args){
        int[]evenNumber={2,3,4};
        System.out.println(evenNumber[1]);//输出3
    }
}

             遍历数组元素：由于数组内存空间是连续的且从下标0开始，所以可以使用for循环遍历：

               传统for循环遍历数组：

                                一维数组：

public class ArrayTest{
    public static void main(String[]args){
        int[]evenNumber={2,3,4,5,3,6};
        System.out.println(evenNumber.length);//输出6
        for(int i=0;i<evenNumber.length;i++){
            System.out.println(evenNumber[i]);
        }
    }
}

            二维数组：

public class ArrayTest{
    public static void main(String[]args){
        double[][]wagesArray={{1,2,3,4,5},{12,3,4,5,6,2}};
        for(int i=0;i<wagesArray.length;i++){
            double[]subWagesArray=wageArray[i];//遍历出来子数组
            for(int j=0;j<subWagesArray.length;j++){
                System.out.println(subWagesArray[j]);
            }
        }
    }
}

加强for循环遍历数组，其格式如下：

          for（集合中元素数据类型 元素名：数组名）{

}

                   一维数组：

public class ArrayTest{
    public static void main(String[]args){
        double[]wagesArray={2，3，4，5，6}；
        for(double evenNumber:wagesArray){
            System.out.println(evenNumber);
        }
    }
}

           二维数组：

public class ArrayTest{
    public static void main(String[]args){
        double[][]wagesArray={{100,2,300},{100,2,3,4,2}};//声明数组
        for(double [] subWagesArrays:wageArray){
            for(double wages:subWagesArray){
                System.out.println(Wages)    
            }
        }
    }
}

值传递与引用传递：

值传递是指在调用函数时将实际参数复制一份传递到传递到函数中，这样在函数中如果对参数进行修改将不会影响到实际参数。

引用传递是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

数组的排序：

冒泡排序法是最基本的排序方法之一：冒泡排序的运行机制是通过循环遍历数组元素并调整相邻元素的顺序来实现的一种简单排序方法。

public class ArrayTest{
    public static void main(String[]args){
        int []array={21,99,1024,16};//升序排列
        for(int loopTime=1;loopTime<array.length;looptime++){//只是控制内部for循环次数
            for(int i=0;i<array.length;i++){
                int currentData=array[i];//当前遍历出来的数据
                int nexyData=array[i+1];//当前数据下标对应的下一个元素的数据
                if(currentData>nexyData){//如果当前元素大于其后面的元素，则需要调换两个元素之间的位置
                    array[i]=nextData;
                    array[i+1]=currentData;
                }
            }
        }
    }
}

第一个for循环的作用：该for循环每循环一次就会将较大的数据放到适当的位置，比如looptime=1时；则将最大的数据放在最后；looptime=2；则将第二大数据倒数第二个元素的位置。

改进后：

public class ArrayTest{
    public static void main(String[]args){
        int []array={21,99,1024,16};//升序排列
        for(int loopTime=1;loopTime<array.length;looptime++){//只是控制内部for循环次数
            for(int i=0;i<array.length-looptime;i++){
                int currentData=array[i];//当前遍历出来的数据
                int nexyData=array[i+1];//当前数据下标对应的下一个元素的数据
                if(currentData>nexyData){//如果当前元素大于其后面的元素，则需要调换两个元素之间的位置
                    array[i]=nextData;
                    array[i+1]=currentData;
                }
            }
        }
        for(int data:array){
            System.out.println(data)
        }
    }
}

与前页代码的不同之处：array.length-looptime:从而提高了代码的性能，减少该循环“多余”的循环次数

插入排序：每循环一次都将一个待排序的元素对应的数据按其顺序大小插入到前面已经排序的序列的合适位置，直到全部插入排序完为止，其难点在前面已经排好序中找到合适的位置。该排序方法有很多，比如直接插入排序法、二分排序法、希尔排序法等。

public class ArrayTest{
    public static void main(String []args){
        int []array={1,2,4,3,7,6,5};//升序排列
        for(int i=1;i<array.length;i++){//i为待排序数据的下标，由于讲第一个元素是有序的，所以i从1开始；i<array；这样才能遍历完后续数组，进而实现全部排序；
            int willSortData=array[i];//将待排序数据保存到willSortData中
            int j=0;
            for(;j<i;j++){//和排序数据前面（i）的所有元素进行比较，以找到应该插入的下标位置。说明：不能这样写i<=j,因为无需自己和自己比。
                if(willSortData<array[j]){//如果条件成立待插入数据小于其前面的某个元素
                    break;//当if条件成立时就找到了待插入数据“应该”插入的下标位置，所以这时必须终止循环
                }
            }//for循环执行结束意味着找到了待插入数据应该插入的位置。
            for(int k=i;k>j;k--){//int k=i;待插入数据所在的位置就是元素后移开始的下标位置；k>j;待插入数据应该插入的位置(j);就是元素后移结束的位置。
                array[k]=array[k-1];//元素后置
            }
            array[j]=willSortData;
        }//该循环每循环完一次代表着本次插入的数据和前面的数据已经是有序的
    }
}

 

本篇完结！