第五章数组总结

1. 数组的概念

数组是具有相同数据类型的一组数据的集合，在程序设计中引入数组可以更有效地管理和处理数据。数组是具有相同数据类型的一组数据的集合，例如，球类的集合--足球、篮球、羽毛球等;器集合--电视机、洗衣机、电风扇等。数组中的每个元素具有相同的数据类型。在 Java 中同样将数看作是一个对象，虽然基本数据类型不是对象由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。我们经常使用的数组包括一维数组和二维数组等。

1.2一维数组

当在程序中需要处理一组数据， 或者传递一组数据时，就可以使用数组实现。

1.2.3创建一维数组

arr：数组名。length：数组长度属性，返回int值

声明一维数组有两种方式: 数组元素类型 数组名字[];

数组元素类型[] 数组名字;

声明一维数组，语法如下:
int arr[]; //声明int型数组，数组中的每个元素都是int数值

要使用数组还得分配空间，需要指明数组长度，为数组分配空间语法如下：

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

1. 在Java中，一维数组是最常见的一种数据结构。下面的实例是使用一维数组将1~12月份各月份的天数输出。

代码例题

package shuzhu;

public class Shuzzz {

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

}

如果改成i<13

这里我们开了12个数组,但是却从1到12遍历了13次,就是数组越界。

方法一：防止越界可以使用length。

方法二:foreach循环循环遍历数组

int []arr=new int [] {
                5,13,96
        };//for循环遍历数组
        for(int i=0;i<arr.length;i++) {
            int temp =arr[i];
            System.out.println(temp);
            
        }
        //foreach循环遍历数组
        for (int temp:arr) {
            System.out.println(temp);
            
        }
        
        
    }
}

1.2.4初始化一维数组

数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化组中的每个元素。数组的初始化有以下方式:1.int arr[]new int[]{1,2,3,5,25}

1.int arr[]new int[]{1,2,3,5,25}

2.int arr2[]={34,23,12,6}

分配内存
数组名 =new 数组元素的类型[ 行数] [列数];

设置初始值
数组名= new 数组元素的类型[ ] [ ]{{值1，值2，...},{值1，值2，...},{值1，值2，...}};

数组元素赋值
数组名[行号] [列号]=值；

1.2.5二维数组

二维数组常用于表示表，表中的信息以行和列的形式表示，第一个下标代表元素所在的行，第二个下标代表元素所在的列。

创建二维数组

二维数组有两种声明方式:
数组元素类型数组名字[][]; 数组元素类型[][]数组名字;

声明二维数组:
int a[][];

同一维数组一样,二维数组在声明时也没有分配内存空间，同样要使用关键字new 来分配内存，然后才可以访问每个元素。

a=new int[2][4]
第二种分配方式
a=new int[2][];
a[0]=new init[2];
a[1]=new int[3];

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

int a=new int [2][4]

例题输出一个3行四列所有元素都为零的矩阵

            int a[][]=new int[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();
            }                                             
        }
    }

1. 数组的基本操作

1.2 遍历数组

遍历数组就是获取数组中的每个元素，通常遍历数组都是使用for循环来实现的，遍历一维数组很简单，也很好理解，遍历二维数组需使用双层for循环，通过数组的Length属性可获得数组的长度。

例题:定义二维数组,将二维数组中的元素梯形输出

int b[][] = new int[][] { { 1 }, { 2, 3 }, { 4, 5, 6 } }; // 定义二维数组 
          for (int k = 0; k < b.length; k++) {//循环遍历二维数组中的每个元素
           for (int c = 0;c < b[k].length;c++){ //循环遍历二维数组中的每个元素
           System.out.print(b[k][c]); //将数组中的元素输出
           }
           System.out.println();//输出换行
           }
    }
 
}

在遍历数组时使用forech语句遍历二维数组案例

int arr2[][] = {{4, 3}, {1, 2}};
        System.out.println("数组中的元素是:");//提示信息
        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 + "、");//输出信息
        }
        }
    }
}

1.3 填充替换数组元素

数组中的元素定义完成后，可通过 Arrays类的静态方法 fill0来对数组中的元素进行分配，可以起到填充和替换的效果。fill()方法有两种参数类型，下面以 int型数组为例介绍 fill()方法的使用。

1. fill(intl a , int value)

该方法可将指定的int值分配给int型数组的每个元素。语法如下:

Arrays.fill(int[] a, int value) a:要进行元素分配的数组。

value:要存储数组中所有元素的值

例题:通过fill()方法填充数组元素,最后将各个元素输出

import java.util.Arrays;

public class LT59 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int arr[] = new int[5];//创建int型数组
      Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
      for (int i = 0; i < arr.length; i++) {// 循环遍历数组中的元素
          //将数组中元素依次输出
      System.out.println("第"+i+"个元素是:"+arr[i]);//输出"第"+i+"个元素是:"+arr[i]

          }
    }

}

ill(int]a, int fromindex, int tolndex, int value)

该方法将指定的 int 值分配给int型数组指定范围中的每个元素。填充的范围从索引 fromIndex(包括)一直到索引toIndex(不包括)。如果fromIndex==toIndex，则填充范围为空。

语法如下:fill(int[] a,int fromlndex,int tolndex,int value)
如果指定的索引位置大于或等于要进行分配的数组的长度，则会报出 ArrayIndexOutOf-BoundsException(越界异常)异常。

例题使用fill()方法替换数组中的元素

import java.util.Arrays;

public class LT59 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] { 45, 12, 2, 10 };// 定义并初始化 int 型数组arr
          Arrays.fill(arr,1,2,8); //使用fill()方法对数组进行填充 
          for (int i = 0; i < arr.length; i++) {//循环遍历数组中的元素
           //将数组中的元素输出
          System.out.println("第" + i + "个元素是:" + arr[i]);//输出"第" + i + "个元素是:" + arr[i]
          }
    }

}

1.3.2对数组进行排序

使用sort()方法将数组排序后输出

int arr[] = new int[] { 23,42,12,8};// 定义并初始化 int 型数组arr
          Arrays.sort(arr); //将数组进行排序 
          for (int i = 0; i < arr.length; i++) {//循环遍历排序后的数组
          System.out.println( arr[i]);//将排序后的数组输出
          }
    }

}

1.4 复制数组

Arrarys 类的copyOf0方法与copyOfRange方法可实现对数组的复制。copyOf方法是复制数组

至指定长度，copyOfRangeO方法则将指定数组的指定长度复制到一个新数组中。

1. copyOf()方法

该方法提供了多种使用方式，用于满足不同类型数组的复制。语法如下: Arrays.copyof(arr,int newlength) y an:要进行复制的数组。

例题:在项目中创建cope类,在主方法中创建一维数组,实现将此数组复制得到一个长度为5的新数组

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[] = new int[] { 23, 42, 12 };// 定义数组
          int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
          for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
           System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
         }
    }

}

2、copyofRange（）方法

方法提供了多种使用方式，其常用语法如下:，

Arrays.copyofRange(arr,inf formIndexint toIndex)

arr:要进行复制的数组对象。 formIndex:指定开始复制数组的索引位置。formIndex必须在0至整个数组的长度之间。新

例题:创建一维数组,并将数组中索引位置是0-3的元素复制到新数组中

import java.util.Arrays;

public class LT59 {
    public static void main(String[] args) {
    int arr[] = new int[] { 23, 42, 12, 84, 10 }; // 定义数组
      int newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组 
      for (int i =0; i < newarr.length; i++){ //循环遍历复制后的新数组
       System.out.println(newarr[i]);// 将新数组中的每个元素输出
      }
 }

}

1.4.1查询数组

查询数组元素（先排序再查询）

语法如下:索引=Arrays.binarySearch(数组名，元素)；

例题:查找元素在数组中索引的位置

创建一维数组ai查找元素4在数组中索引位置

import java.util.Arrays;

public class LT59 {
    public static void main(String[] args) {
        int arr[]=new int [] {1,8,9,4,5};//定义数组
        Arrays.sort(arr);//对数组进行排序
        int i=Arrays.binarySearch(arr, 4);//找到数组中元素4的值
            
                System.out.println("4的索引位置是"+i);//输出
            
        }
     
    }
    

查询部分元素 （先排序再查询，前含后不含）

索引=Arrays.binarySearch(数组名，前索引，后索引，元素)；

public class LT59 {
    public static void main(String[] args) {
        String arr[]=new String []{"ab","cd","ef","yz"};//定义string型数组
        Arrays.sort(arr);//数组排序
        int i=Arrays.binarySearch(arr,1,3,"cd");//在指定范围内搜索元素"cd"的索引位置
            
                System.out.println("cd的索引位置是："+i);//输出
            
        }
     
    }
    

3数组排序算法

3.1排序算法

使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面(也就是交换两个元素的位置)，这样较小的元素就像气泡一样从底部上升到顶部。

例题:

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []array= {63,4,24,1,3,15};//定义数组
        LT sorter=new LT();//创建冒泡排序的对象
        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();
        }

        }

直接排序

将最大的数放到最后，固定不动，第二次再将最大的数放到最后，固定不动，往后继续。

直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法

int []array= {63,4,24,1,3,15};//创建数组,元素乱序
           LT sorter=new LT ();//创建直接排序类的对象
           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 static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {10,20,30,40,50,60};    //创建一个数组
        LT sorter = new LT();//创建反转排序的对象
        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();
    
    }
}