Java数组的总结

Java数组的总结
本文将对java数组做详细介绍：包括一维二维数组的定义，封装类Arrays和数组封装方法做一点介绍，
最后介绍几道数组的编程题目的解法。
 
一、数组的定义
一维数组
在Java中有两种数据：primitive类型和objects.

数组必须初始化后才可使用。

数组属于object类型，所以必须用new来创建数组，同时数组具备一下特性：

1. 数组创建之后就不能改变大小

2. 数组创建之后，若没有指定初始值，则依据数组类型的不同，会预设不同的初始值

  数组初始化方式：

 1、静态初始化：Int[] arr1= new int[]{1,2,3,4,5};或int[] arr1={1,2,3,4,5};

 2、动态初始化：Int[] arr1=new int[5];  // 创建一个可容纳5个元素的数组 

3. 数组有一个length属性，可以取回数组中元素的个数

int arrayLength = arr1.length;

 

二维数组
二维数组用数组“名称”与“两个索引”来指定存取数组中的元素。

其定义方式与一维数组类似:

 1、静态初始化：int[][] arr1= {{1,2,3}, {4,5,6}};

 2、动态初始化：int[][] arr1=new int[3][3];

注意length所代表的长度，数组名后直接加上length(如arr.length),所指的是数组有几行； 指定索引后加上length(如arr[0].length),指的是该行拥有的元素，也就是列的数目。

值得注意的是，数组的游标是从0 开始的，比如一位数组的第一个元素：arr1[0]=1; arr[4]=5;

二位数组中：arr2[0][0]=1;  arr2[2][2]=6;

 
二、数组封装类和方法的使用
数组的复制
1. 使用System.arraycopy()方法，可以赋值一个数组的部分值到另一个数组

   System.arraycopy(来源，起始索引，目的，起始索引，复制长度);

   例如：

   int[]arr1 = {1,2,3,4,5};

   int[]arr2 = new int[5];

  System.arraycopy(arr1, 0, arr2, 0, arr1.length);//之后数组2的值等于数组1的值

2. 在Java SE 6中，Arrays类新增了copyOf()方法，可以直接返回一个新的数组对象，而其中包括复制的内容

   例如：

   importjava.util.Arrays;

   int[]arr1 = {1,2,3,4,5};

   int[]arr2 = Arrays.copyOf(arr1,arr1.length);

   Arrays的copyOf()方法返回的数组是新的数组对象，所以改变返回数组中元素的值不会影响原来数组中元素的值。copyOf()方法中第二个变量指定新数组的长度，如果新数组的长度超过原来数组的长度，则多出来的元素会保留数组默认值。

   除了copyOf()方法外，还有copyOfRange()方法，可以指定来源数组以及要复制的索引范围：

   int arr1= {1,2,3,4,5};

   intarr2 = Array.copyOfRange(arr1,1,4);  // 复制索引1开始到索引4（但不包括索引4）的元素，arr2的元素会是2,3,4

 

Arrays类    //记得加s!
Array类位于java.util包中，它提供了几个方法可以直接使用：

sort() - 对指定数组排序，作用是快速排序法

使用方法：用一个例子就可以说清楚：int[] arr={1,4,6,3,9,7};

使用类里面的方法：Arrays.sort(arr);之后数组的值会从小到大排列 arr={1,3,4,7,9};

 

binarySearch() - 让你对已排序的数组进行二分查找，如果找到指定的值就返回该值所在的索引，否则就返回负值

使用方法介绍：也是用上面一个数组来说：intnum=Arrays.binarySearch(arr，6);那么num=2

需要注意的是：括号里面有两个参数：第一个是数组名称，第二个是要在数组中查找的元素，

如果数组中没有这个元素就返回一个负数，否则返回的值是数组元素游标的值

 

fill() - Arrays.fill()将已创建数组的默认值改为指定值

使用：Arrays.fill(arr,3);使用后arr数组里面的全部值都变成3了

 

Arrays.equals() - 比较两个数组中的元素值是否全相等，如果相等返回true,否则返回false

 boolean b=Arrays.equals(arr1,arr2);

 

Arrays.toString()- 可以一次输出数组的元素，每个元素之间用逗号相隔

System.out.println(Arrays.toString(arr));

 

Arrays类里面还有很多其他的封装的方法，如果有兴趣的话可以查看相关文档或浏览API；

 

foreach与数组
在Java SE 6中， foreach的语法为：

int[] arr ={1,2,3,4,5};

for(int element : arr){

System.out.println(element);

}

    结果将会依次输出数组arr里面的值

注意， element类型必须与数组元素类型相同

 

三、数组的编程题目
 

数组用于数字取位的一个应用：

比如输入一个4位数s：求它个十百千位的数字

Int[ ] arr=new int[ 4 ];

for(int i=3;i>=0;i--){

       arr[i]=s% 10;

       s= s / 10;

}

那么：arr[0] 、arr[1]、 arr[2] 、arr[3],分别是这个数的千、百、十、个位的数字 

 

数组遍历主要是搭配for循环使用的

下面的编程题目，除了第一题，其他几题逻辑性是有点强的

 

程序示例1

题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

程序分析：创建一个五位数数的数组，把输入数字的每位数的值赋值到数组里面  

      * 把输入 数字从个位起获取，并且每获取一次之后/10，这样就能分别获取十位百位千位了

      * 把数字打印出来就是题目所求了 

public class Programme24 {

    public static void main(String[] args) {

       System.out.println("请输入一个不大于5位数的数字：");

       Scanner scanner=new Scanner(System.in);

       int num=scanner.nextInt();//获取输入

       int[] arr=new int[5];//创建5位数的数组

       int i=0;

       //循环取位

       do{     

            arr[i]=num%10;

            num=num/10;

            i++;

       }while (num!=0);//只剩下一位时，说明获取完毕，跳出循环

       System.out.println("输入数字串的是"+i+"位数的");

       System.out.println("逆序输出：");

       //打印出数组

       for (int j = 0; j < i;j++) {

           System.out.print(arr[j]+"  ");

       }

       scanner.close();

    }

}

 

 

 

程序示例2

题目：对10个数进行排序

程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。

最后打印出来的数组就是从小到大排列的数组了

 

public class Programme28 {

    public static void main(String[] args) {

       System.out.println("请输入10个数（用空格隔开）：");

       int[] arr=new int[10];

       Scanner scanner=new Scanner(System.in);

       for (int i = 0; i < 10; i++) {

           arr[i]=scanner.nextInt();

       }

       //对数组进行排序

       int temp=0;//交换数

       for (int i = 0; i < 9; i++) {

           for (int j = i+1; j < arr.length; j++) {

              if (arr[i]>arr[j]) {   //如果第一个数比后面的数大就交换

                  temp=arr[i];

                  arr[i]=arr[j];

                  arr[j]=temp;

              }

           }

       }

//对数组排序也可以用封装的方法：Arrays.sort(arr);

       System.out.println("排列后的数组："+Arrays.toString(arr));//Arrays类的包装方法！

    }

}

 

 

 

程序示例3

题目：打印出杨辉三角形（要求打印出10行如下图）

程序分析：

    1

   1 1

    1 2 1

1 3 3 1

 1 4 6 4 1

1 5 10 10 5 1

1、二维数组的使用

2、第一列的数都是1

3、使用两个for循环，i控制行，j控制列；

从第二行第二列起arr[i][j]=arr[i-1][j-1]+arr[i-1][j]

public class Programme33 { 

public static void main(String[] args) {

        int[][] arr=new int[10][10];

        for (int i = 0; i < arr.length; i++) {

            arr[i][0]=1;//控制第一列的数等于1

       }

       for (int i = 1; i < arr.length; i++) {

           for (int j=1; j < arr.length; j++) {

              arr[i][j]=arr[i-1][j-1]+arr[i-1][j];//赋值

           }

       }

       //打印结果

       for (int i = 0; i < arr.length ; i++) {

           for (int k = arr.length-i;k>0; k--) {//空格的控制，为了好看

              System.out.print("  ");

           }

           for (int j = 0; j < arr.length; j++) {//打印出数组的数字

              if (arr[i][j]!=0) {//把把没赋值的零去掉

                  System.out.print(arr[i][j]+"   ");

              }

           }

           System.out.println();//控制换行

       }

    }

}

 

 

程序示例4

题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

关键问题是怎么移除》？:布尔值确定，如果被选中被赋值为false

     * 从第一个人开始判断，如果他在圈内，那么报数，再判断他报的数是否是3，如果是的话移出圈外

     * 接着判断下一个人，是否到了最末，如果是的话，从零开始

     * 不断循环，直到最后剩下1个人

    public static void main(String[] args) {

       System.out.print("请输入一个整数：");

       Scanner scan = new Scanner(System.in);

       int n = scan.nextInt();

       scan.close();

       //定义数组变量标识某人是否还在圈内

       boolean[] isIn = new boolean[n];

       for(int i=0;i<isIn.length;i++){

             isIn[i] = true;

       }

       int inCount = n;//定义圈内人数

       int countNum = 0;//定义报数

       int index = 0;//定义索引

       while(inCount>1){//最后一人时退出循环

           if(isIn[index]){//判断下一个人是否在圈内

              countNum++;//在的话报数

              if(countNum==3){//如果这个数等于3

                  isIn[index] = false;//把他定义为出圈

                  countNum = 0;//报数清零，下一个好从1开始

                  inCount--;//圈内人数减一

              }

           }

           index++;//下一人的位置索引值

           if(index==n){//当索引到最后之后再从头开始

               index = 0;

           }

       }

       for(int i=0;i<n;i++){

           if(isIn[i]){//最后只有一个符合条件的

              System.out.println("留下的是："+(i+1));

           }

       }

    }

}

 

 

程序示例5

题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。

1、创建两个数组，如果插入的数字比数组最后一个都大，那么插入的数放在新数组最后就可以

      * 2、如果插入的不是最大，那么和数组前面的数逐一比较，比较到比插入的数大就break

      *  比如第i个符合条件，那么arrB[i-1]=arrA[i-1],arrB[i]=num,arrB[i+1]=arrA[i]

    public static void main(String[] args) {

       System.out.println("请输入一个数字：");

       Scanner scanner=new Scanner(System.in);

       int num=scanner.nextInt();

       int[] arrA={3,5,15,36,84,99};

       int[] arrB=new int[arrA.length+1];

       if (num>arrA[arrA.length-1]) {

           for (int i = 0; i < arrA.length; i++) {

              arrB[i]=arrA[i];

           }

           arrB[arrB.length-1]=num;

       }else {

           for (int i = 0; i < arrA.length; i++) {

              if (num<arrA[i]) {

                  for (int j = 0; j < i; j++) {

                     arrB[j]=arrA[j];

                  }

                  arrB[i]=num;

                  for (int j = i; j < arrA.length; j++) {

                     arrB[j+1]=arrA[j];

                  }

                  break;//这个很重要

              }

           }

       }

       System.out.println("插入一个数后的数组为："+Arrays.toString(arrB));

       scanner.close();

    }

}
--------------------- 
作者：峥嵘life 
来源：CSDN 
原文：https://blog.csdn.net/wenzhi20102321/article/details/52277668