数组的基本认识

数组概述：具有相同数据类型的一组数据。数组中每个元素类型相同。基本数据类型不是对象但由其组成的数组是。

一维数组 

创建一维数组：数组作为对象可以使用new关键字分配内存。使用数组前必须先定义数组变量所属的类型。

声明数组：int   arr［］；

/ int   arr0［］，arr1［］；

int［］ arr；

/int［］arr0，arr1；

//声明的数组没有长度

声明后，不能立即访问其中的元素，声明只是给了数组名字和类型；使用数组要分配空间并且必须指明数组长度。

arr   =   new   int［le］；

//使用new关键字必须指定数组类型和长度。

//new为数组分配内存时，整形数组个元素是0。

int   arr［］=   new   int ［le］；

//声明并且分配数组

初始化一维数组：

int   arr［］=new   int［］｛0，1｝；

int   arr［］=｛0，1，2，3｝；

二维数组

二维数组用于表示表，表由行和列组成。

［行］［列］

声明二维数组：

int   arr［］［］；

int［］［］  arr；

分配内存：

直接分配  a=new   int ［行］［列］；

//行表示有几个一维数组，列表示每个数组中的元素个数。

分别分配 

a=new   int［2］［］；

a［］=new   int［2］；

a［］=new   int［3］；

//使用new分配内存必须指定长度。

声明并且分配二维数组：

int   arr［］［］=｛. . . ｝;

初始化：

int   arr［］［］=｛｛...｝，｛...｝｝；

//｛｝行，...列

遍历数组：

public   class   Traversal｛

     public static void main（String［］args）｛

           int  b［］［］=new  int［］［］｛｛1｝，｛2，3｝，｛4，5，6｝｝；//定义二维数组

        for（int i=0；i<b.lenght；i++）｛

                for（int j=0；j<b［i］.lenght；j++）｛   //循环遍历二维数组中的元素并且输出

         System.out.print（b［i］［j］）;

                          ｝
         System.out.println（）;                      //输出空格



            ｝

   ｝

｝

结果  

1

23

456

foreach语句遍历数组：

public   class   Traversal{

public   static    void   main(String[]  args){

            int   arr[][]={{4,3},{1,2}};            //定义二维数组

            System.out.println("数组中的元素是：");

            int   i=0;

            for(int  x[]: arr){                        //外层循环变量为一维数组

                  i++;                                    //外层计数器递增

                  int  j=0;                               //内层循环计数器

                  for(int   e:x){                       //循环遍历每一个数组元素

                         j++;                              //内层计数器递增

                         if(i==arr.length && j==x.length){          //判断变量是二维数组中的最后一个元素

                              System.out.print(e);                        //输出二维数组的最后一个元素

                             }else                    //如果不是二维数组中的最后一个元素

                               System.out.print(e + " ")： //输出信息

                  }

          }

    }

}

结果

数组中的元素是：

4 3 1 2 

填充替换数组元素：

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

   fill(int[] a,int value);  //该方法可将指定的int的值分配给int型数组中的每个元素

a: 要进行元素替换的数组；value：要存储数组中的所有元素的值

import java.util.Arrays;                //导入Java.util.Arrays类
public class Swap{                      //创建类
       public static void main(String[] args){      //主方法
             int arr[]=new int[5];                  //创建int型数组
             Arrays.fill(arr,8);                    //使用同一个值对数组进行填充
             for(int i=0;i<arr.length;i++){         //循环遍历数组中的元素
                 System.out.println("第"+i+"个元素是:"+arr[i]);
                 //将数组中的元素依次输出
          }
  }
}
#结果
第0个元素是：8
第1个元素是：8
第2个元素是：8
第3个元素是：8
第4个元素是：8

fill(int[] a,int fromlndex,int tolndex,int value);

a：要填充的数组；fromlndex：第一个填充元素的索引（包括）；tolndex：最后一个填充元素的索引；value：要存储数组中的所有元素的值

注意：指定的长度不可以超过数组长度。

import java.util.Arrays;   //导入类
public class Displace{     //创建类
     public static void main(String[] args){         //主方法    
          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]); //输出数组中的元素
      }
  }
}

第0个元素是:45
第1个元素是:8
第2个元素是:2
第3个元素是:10

对数组进行排序：

通过Arrays类的静态sort()方法可以实现对数组的排序，sort()方法提供多种重载形式，可以对任意数组进行升序排序。

Arrays.sort(arr);  arr:数组名

（数字排在字母前，大写字母排在小写字母前）

import java.util.Arrays;
public class Taxis{
     public static void main(String[] args){
          int arr[] = new int[]{23,42,12,8};       //声明数组
          Arrays.sort(arr);                        //将数组排序
          for(int i=0;i<arr.length;i++){           //遍历排序后的数组
             System.out.println(arr[i]);           //输出元素
          }
     }
 }

8
12
23
42

复制数组：

Arryas类的copyOf()方法与copyOfRange()方法可以实现 对数组的复制。copyOf()方法是复制数组到指定长度，copyOfRange()方法则将指定长度的数组复制到新的数组中。

copyOf(arr,int newlength);

arr:数组名;newlength:复制后新数组的长度。如果新数组长度大于原来数组长度，整型用0填充，char型用null填充；如果新数组小于原来数组，则会从数组的第一个元素开始截至满足新数组长度为止。

import java.util.Arrays;
public class Cope{
    public static void main(String[] args){
        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(newarr[i]);
        }
   } 
}
23
42
12
0
0

 copyOfRange(arr,int fromIndex,int toIndex);

arr:数组对象；fromIndex:指定数组开始索引的位置。必须在0到数组长度之间，并且包括fromIndex的元素。toIndex:要复制范围最后的索引。可以大于数组长度但不包括toIndex的元素。

import java.util.Arryas;
public class Repeat{
    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]);
    }
 }
}
23
42
12

 

数组查询：

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

binary Search(Object[] a,Object key);

a:要搜索的数组;key:要搜索的值。