第五章总结

数组

数组的概念：数组是具有相同数据类型的一组数据的集合

一维数组：

一维数组是一组相同数据类型数据的线性集合

数组的声明：

数组元素的类型[] 数组名；

数元素的类型数组名 []；

数组的内存分配：

要真正的使用数组还要为它分配内存空间，在为数组分配内存空间之必须指明数组的长度。

数组名字 = new 数组元素的类型[数组元素的个数]；
 

arr = new int[5];

声明的同时为数组分配内存：

数组元素的类型 数组名 = new 数组元素的类型[数组元素的个数]；

int month[] = new int[12];

初始化一维数组：

有两种初始化数组的方法：

int arr[] = new int[]{1,2,3,4,5,25}   //第一种初始化方法
int arr2[] = {34,23,12,6}             //第二种初始化方法

使用一维数组

例题5.1

 
public class liti5_1 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int day[] = new int[] {31,28,31,30,31,30,31,30,31,31,30,31}; 
        //创建一个int类型的一维数组day
        for (int i = 0;i < day.length; i ++) {        //循环输出
            System.out.println((i +1) + "月有"+ day[i] + "天");    //输出
        }
    }
 
}

结果：

 二维数组

数组的声明：

数组元素的类型[][] 数组名；

数元素的类型数组名 [][]；

数组的内存分配：

第一种是直接为每一维分配空间：

第二种是分别为每一维分配空间：

a = new int[2][4];
----------------------
a = new int[2][0];
a[0] = new int[2];
a[1] = new int[3];

声明的同时为数组分配内存：

int myarr[][] = {{12,0},{45,10}};

初始化二维数组：

例题5.2

 
public class liti5_2 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a[][] = new int[3][4];    //定义一个int型的二维数组a指定3行4列
        for (int i = 0; i < a.length; i ++) {    //循环找到每个一维数组的地址
            for (int j = 0; j < a[i].length; j ++) {    //循环输出每个一维数组中的值
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
 
}

结果：

 

 

使用foreach代码：

1.  

    
   public class liti5_4 {
    
       public static void main(String[] args) {
           // TODO Auto-generated method stub
           int arr2[][] = {{4,3},{1,2}};    //定义二维数组
           System.out.print("数组中的元素是");    //提示信息
           int i = 0;        //外层循环计数器变量
           for(int x[] : arr2) {    //外层循环变量为一维数组
               i++;        //外层计数器递增
               int j = 0;    //内层循环计数器变量
               for(int e : x) {    //循环遍历每一个数组元素
                   j ++;    //内层计数器递增
                   if(i == arr2.length && j == x.length) {    //判断变量是二维数组中的最后一个元素
                       System.out.print(e);        //输出二维数组的最后一个元素
                   }else        //如果不是二维数组中的最后一个元素
                       System.out.print(e + "·-");//输出信息
               }
           }
       }
    
   }

   结果：

   填充替换数组元素：

   数组中的元素定义完后，可以跳过Array类的静态方法fill()来对数组中的元素进行替换，fill()方法有两种参数
   填充替换语法：

   fill(数组名,值)

 代码：

import java.util.Arrays;
 
public class liti5_5 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[5]; //定义一个数组
        Arrays.fill(arr, 8);    //使用同一个值队数组进行填充
        for (int i = 0; i < arr.length; i ++) {    //循环遍历数组中的元素
            System.out.println("第"+ i +"个元素是："+ arr[i]);    //将数组中的元素逐个输出
        }
    }
 
}

 结果：

  填充替换部分元素语法：（前改后不改）

fill(数组名,前索引，后索引，值)

代码：

import java.util.Arrays;
 
public class liti5_6 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] {45,12,2,10};//定义一个二维数组
        Arrays.fill(arr, 1,2,8);    //使用fill()方法替换数组中指定范围的元素
        for(int i=0; i < arr.length; i++) {//遍历循环数组中的元素
            System.out.println("第"+ i +"个元素是："+ arr[i]);//输出数组中的元素
        }
    }
 
}

结果：

对数组进行排序：

通过Array类的静态方法sort()可以对数组进行排序

语法：

Array.sort(数组名)

代码：

import java.util.Arrays;
 
public class liti5_7 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] {23,42,12,8};//定义一个二维数组
        Arrays.sort(arr);        //使用sort()方法对数组进行排序
        for(int i=0; i < arr.length; i++) {//遍历循环数组中的元素
            System.out.println(arr[i]);//循环输出数组中的元素
        }
    }
 
}

结果：

复制数组：

Array中的copyOf()方法与copyOfRange()方法可以实现对数组的复制

复制语法：（空位补0，溢出去掉）

copyOf(数组名,复制的长度)

代码：

import java.util.Arrays;
 
public class liti5_8 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] {23,42,12};//定义一个二维数组
        int newarr[] = Arrays.copyOf(arr, 5);//使用copyOf对数组进行复制
        for(int i=0; i < newarr.length; i++) {//循环遍历数组中的元素
            System.out.println(newarr[i]);//循环输出数组中的元素
        }
    }
 
}

结果：

部分复制语法：（前在后不在）

 copyOfRange(数组名,前索引,后索引)

代码：

import java.util.Arrays;
 
public class liti5_9 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] {23,42,12,43,21,11};//定义一个二维数组
        int newarr[] = Arrays.copyOfRange(arr,0,3);
        //使用Array。copyOfRange对指定的数组范围进行复制
        for(int i=0; i < newarr.length; i++) {//循环遍历数组元素
            System.out.println(newarr[i]);//循环输出数组元素
        }
    }
 
}

结果：

查询数组：

Array中的binarySearch()方法，可以用二分搜索法来搜索指定数组，以获得指定对象，它有两种方法

查询语法：（先排序再查询）

binarySearch(数组名,值)

代码：

import java.util.Arrays;
 
public class liti5_10 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] {1,8,9,4,5};//定义一个一维数组
        Arrays.sort(arr);        //将数组排序
        int index = Arrays.binarySearch(arr, 4);
        //使用binarySearch查询数组中指定的元素
        System.out.print("4的索引位置是："+ index);//将查询到的元素输出
    }
 
}

结果：

查询部分语法：（先排序在查询，前含后不含）

binarySearch(数组名,前索引,后索引,要搜索的值)

代码：

import java.util.Arrays;
 
public class liti5_11 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str[] = new String[] {"ab","cd","ef","yz"};//定义一个一维数组并赋值
        Arrays.sort(str);        //进行排序
        int index = Arrays.binarySearch(str,0,2,"cd");//使用binarySearch搜索指定值
        System.out.print("cd的索引位置是："+ index);//将搜索到的值输出
    }
 
}

结果：

改为前索引后的结果：

  改为后索引后的结果：可以得出结论，前索引在搜索范围内，而后索引不在。

数组排序算法

冒泡排序：

是最常用的数组排序算法之一，它排序数组元素的过程总是将小的数往前放，较大的往后放，类似水中冒泡往上升的动作，所以叫冒泡排序

基本思想：

比较相邻的元素，把较小的元素移动到数组前面，把较大的元素放到数组后面，这样较小的元素就像气泡一样从底部上升到顶部

算法示例：

冒泡排序由双层循环实现，外层循环用于控制层数，一般要循环数组长度减一次才能保证完成排序，内层循环主要用于对比数组中每个相邻的元素大小判断是否交换位置

算法实现：

 
public class liti5_12 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {63,4,24,1,3,15};    //创建一个数组，元素是乱的
        liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
        sorter.sort(array);        //调用排序方法，对数组排序
        }
    public void sort(int[] array) {
        for(int i=1; i < array.length;i ++) {
            for(int j=0; j < array.length - i;j++) {
                if(array[j] > array[j + 1]) {
                    int temp = array[j];    //把第一个元素值保存到临时变量中
                    array[j] = array[j+1];    //把第二个元素值保存到第一个元素单中
                    array[j+1] = temp;    //把临时变量（第一个元素原值）保存到第二个元素单中
                }
            }
        }
        showArray(array);//把输出冒泡排序后的数组元素
    }
    public void showArray(int[] array) {
        for(int i: array) {        //遍历数组
            System.out.print(">"+ i); //输出每个数组元素值
        }
        System.out.println();
    }
}

结果：

直接选择排序：

属于一种选择排序，排序速度要比冒泡排序快点，也是常用的排序，初学者应该掌握

基本思想：

将指定排序位置元素与其他数组元素对比，如果满足条件就交换元素值，直接排序并不是和冒泡排序一样交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换

算法示例：

挑出元素中最小或者最大的一个元素，顺序的放在已排序好的数列的最后，直到全部待排序的数据元素排列完

算法实现：

 
public class liti5_13 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {63,4,24,1,3,15};    //创建一个数组，元素是乱的
        liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
        sorter.sort(array);        //调用排序方法，对数组排
    }
    public void sort(int[] array) {
        int index;
        for(int i = 1; i < array.length; i ++) {
            index = 0;
            for(int j = 0; j < array.length - i; j ++) {
                if(array[j] > array[index]) {
                    index = j;
                }
            }
            int temp = array[array.length - i];//把第一个元素值保存到临时变量中
            array[array.length - i] = array[index];//把第二个元素值保存到第一个元素单中
            array[index = temp;        //把临时变量（第一个元素原值）保存到第二个元素单中
        }
        showArray(array);        //输出直接选择排序后的数组元素
    }
    public void showArray(int[] array) {
        for(int i: array) {        //遍历数组
            System.out.print(">"+ i); //输出每个数组元素值
        }
        System.out.println();
    }
}

结果：

反转排序：

以相反的顺序把原有数组的元素重新排序，也是经常用到的一种排序方法

基本思想：

将数组最后一个元素和第一个元素交换，倒数第二个元素和第二个元素交换，以此类推，直到把所有元素反转替换

算法示例：

反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如果数组长度位奇数，例如数组长度为7，那么只会循环3次，中间的数不变

算法实现：

 
public class liti5_14 {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {10,20,30,40,50,60};    //创建一个数组
        liti5_14 sorter = new liti5_14();//创建反转排序的对象
        sorter.sort(array);        //调用排序对象方法，将数组排序
    }
    public void sort(int[] array) {
        System.out.println("数组原有内容：");
        showArray(array);        //输出排序前的数组元素
        int temp;
        int len = array.length;
        for(int i = 0;i < len / 2;i++) {
            temp = array[i];
            array[i] = array[len - 1 - i];
            array[len - 1 - i] = temp;
        }
        System.out.println("数组反转后内容");
        showArray(array);        //输出排序后的数组元素
    }
    public void showArray(int[] array) {
        for(int i: array) {        //遍历数组
            System.out.print("\t"+ i); //输出每个数组元素值
        }
        System.out.println();
    
    }
}

结果：