java基础-数组

Posted 2020-11-25 社会主义虫不胖

1、数组是什么

    数组是具有相同数据类型的一组数据的集合。例如，球类的集合——足球、篮球、羽毛球等；电器集合——电视机、洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作是一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组……

2、一维数组的创建和使用

 

    数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型，即声明数组，声明一维数组有两种形式，语法如下所示：

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

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

    数组元素类型：决定了数组的数据类型，它可以是Java中任意的数据类型，包括基本数据类型和非基本数据类型。

    数组名字：为一个合法的标识符

    符号“[ ]”：指明该变量是一个数组类型变量，单个“[ ]”表示要创建的数组是一维数组

    

    数组可以与基本数据类型一样进行初始化操作，数组的初始化可分别初始化数组中每个元素。数组的初始化有两种形式。

    两种方法初始化一维数组，示例代码如下所示：

    int arr[] = new int[]{1,2,3,5,25};//第一种初始化方式

    int arr2[] = {34,23,12,6};//第二种初始化方式

    数组的初始化方式是：把数据类型包括在大括号之内，中间用逗号分开数组元素的值，系统自动为数组分配一定的空间。第一种初始化方式，创建5个元素的数组，其值依次为1、2、3、5、25；第二种初始化方式，创建4个元素的数组，其值依次为34、23、12、6。

3、一个实例：遍历显示12月都有多少天

public class Example3 {
    public static void main(String[] args) {
        int[] month = new int[]{31,28,31,30,31,30,31,31,30,30,30,31};
        for(int i = 0 ; i < 12; i++){
            System.out.println((i+1)+"月份的天数是"+month[i]+"天");
        }
    }
}

 

 

4、数组操作==遍历

    遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解。

    遍历二维数组要比遍历一维数组要麻烦一些，需使用双层for循环，还要通过数组的length属性获得数组的长度。

public class Trap {
    public static void main(String[] args) {
        int b[][] = new int[][]{{0},{1,2,3},{4,5,6}};
        for(int i = 0 ; i < b.length ; i++){
            for(int k = 0 ; k < b[i].length ; k++){
                System.out.print(b[i][k]);
            }
            System.out.println();
        }
    }
}

 

 

5、二维数组的创建

    声明二维数组的方法有两种，语法如下所示：

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

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

    数组元素类型：决定了数组的数据类型，它可以是Java中任意的数据类型，包括基本数据类型和非基本数据类型。

    数组名字：为一个合法的标识符

    符号“[ ]”：指明该变量是一个数组类型变量，两个“[ ]”表示要创建的数组是二维数组。

    

    二维数组的初始化同一维数组初始化类似，同样可以使用大括号完成二维数组的初始化。语法如下所示：

    type arrayname[][] = {value1,value2…valuen};

    type：数组数据类型

    arrayname：数组名称，一个合法的标识符

    value：数组中各元素的值

6、数组操作==填充和替换

    数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。fill()方法有两种参数类型。下面以int型数组为例介绍fill()方法的使用方法。

（1）fill(int[],int value)：这个方法可以指定int的值分配给int型数组的每个元素。

    语法如下：fill(int[] a,int calue)

    a:要进行替换元素的数组

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

  （2）fill(int[] a,int fromIndex,int toIndex,int value):将指定的int值分配给int型数组指定范围的每个元素，填充范围从索引formIndex(包括)到索引toIndex(不包括)。如果formIndex=toIndex，则填充范围为空。

    语法：

    fill(int[] a,int formIndex,int toIndex,int value)    

    a:要填充的数组

    fromIndex:要使用指定值填充的第一个元素的索引（包括）

    toIndex:要使用指定值填充的最后一个元素的索引（不包括）

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

实例1：

import java.util.Arrays;
public class Swap {
    public static void main(String[] args) {
        int[] a = new int[5];
        Arrays.fill(a,8);
        for(int i = 0 ; i < a.length ; i++){
            System.out.println("第"+i+"个元素是" + a[i]);
        }
    }
}

运行结果：

 

 

 

实例2：

import java.util.Arrays;
public class Displace {
    public static void main(String[] args) {
        int arr[] = new int[]{45,12,25,23};
        Arrays.fill(arr,1,2,3);
        for(int i = 0 ; i < arr.length ; i++){
            System.out.println("第"+i+"个元素是" + arr[i]);
        }
    }
}

运行结果：

 

 

7、数组操作==排序

    通过Arrays类的静态sort()方法可实现对数组排序，sort()方法提供了许多种重载形式，可对任意类型数组进行升序排序。语法如下所示：

    Arrays.sort(object)

    object：指进行排序的数组名称

    返回值：排序后的数组

import java.util.Arrays;
public class Taxis {
    public static void main(String[] args) {
        int arr[] = new int[]{15,8,2,23,36};
        Arrays.sort(arr);
        for(int i = 0 ; i < arr.length ; i++){
            System.out.println("第"+i+"个元素是" + arr[i]);
        }
    }
}

运行结果：

 

8、数组操作==复制

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

   （1） copyOf()方法是复制数组至指定长度，

    语法：

    copyOf(arr,int newlenth)

    arr:要进行复制的数组

    newlenth：int型常量，复制后新数组的长度。如果新数组长度大于数组arr长度，用0填充。如果小于，就从数组arr第一个元素开始截取至满足新数组长度为止。

   （2）copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

    语法：copyOfRange(arr,int formIndex,int toIndex)

    arr：要进行复制的数组对象

    formIndex:指定开始复制数组的索引位置。formIndex必须在0至整个数组长度之间。新数组包括索引是formIndex的元素

    toIndex：要复制范围的最后索引位置，可大于数组arr长度，新数组不包括索引是toIndex的元素。

实例1：

import java.util.Arrays;
public class Copy {
    public static void main(String[] args) {
        int arr[] = new int[]{15,8,2,236};
        int newarr[] = Arrays.copyOf(arr,5);

        for(int i = 0 ; i < newarr.length ; i++){
            System.out.println("第"+i+"个元素是" + newarr[i]);
        }
    }
}

运行结果：

 

实例2：

import java.util.Arrays;
public class repeact {
    public static void main(String[] args) {
        int arr[] = new int[]{15,8,2,236};
        int newarr[] = Arrays.copyOfRange(arr,0,3);

        for(int i = 0 ; i < newarr.length ; i++){
            System.out.println("第"+i+"个元素是" + newarr[i]);
        }
    }
}

运行结果：

 

 

9、数组操作==数组查询

    Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

    （1）binarySearch(Object[].Object key)

    语法：binarySeach(Object[] a,Object key)

        a:要搜索的数组

        key:要搜索的值

    （2）binarySearch(Object[].,int fromIndex , int toIndex,Object key)

 

     语法：

        binarySearch(Object[] a,int formIndex,int toIndex,int value)    

        a:要检索的数组

        fromIndex:指定范围的开始处索引（包括）

        toIndex:指定范围的结束处索引（不包括）

        value:要搜索的值

实例1：

import java.util.Arrays;
public class Example4 {
    public static void main(String[] args) {
        int arr[] = new int[]{15,8,2,236};
        Arrays.sort(arr);
        int index = Arrays.binarySearch(arr,15);
        System.out.println("2的索引位置是："+index);
    }
}

运行结果：

 

 

实例2：

import java.util.Arrays;
public class Rakel {
    public static void main(String[] args) {
        String str[] = new String[]{"b","ff","cccc","aa"};
        Arrays.sort(str);
        int index = Arrays.binarySearch(str,0,2,"b");
        System.out.println("ff的索引位置是："+index);
    }
}

 

 

10、排序算法-冒泡排序

    在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序和快速排序等。本节将介绍冒泡排序方法，它以简洁的思想与实现方法而备受青睐，是广大学者最先接触的一个排序算法。

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

11、直接选择排序

    直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法，是初学者应该掌握的。

12、反转排序

    顾名思义，反转数组就是以相反的顺序把原有数组的内容重新排序。反转排序算法在程序开发中也经常用到。