欢迎访问悦橙教程（wld5.com），关注java教程。悦橙教程  java问答|  每日更新
页面导航 : > > 文章正文

Java数组归纳总结，

来源： javaer 分享于  点击 25551 次 点评：39

Java数组归纳总结，


目录
  • 一、一维数组
    • 1.创建方法
    • 2.初始化数组（一维数组）
  • 二、二维数组
    • 1.创建方法
    • 2.初始化二维数组
  • 三、遍历数组
    • 四、替换元素
      • 五、数组排序
        • 六、数组拷贝
          • 七、元素查询
            • 八、排序算法
              • 1.冒泡排序
              • 2.直接选择排序
              • 3.反转排序

            一、一维数组

            1.创建方法

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

            比如：

            int array[];//int 类型数组
String str[];//String类型数组

            我们还要给数组申请空间：

            数组名字 = new 数组元素的类型[数组元素的个数];
array = new int[10];//代表创建了一个有10个元素的整型数组
//注意

            当我们用new关键字为数组分配内存的时候，整型数组中各个元素初始值都为0

            综合上面两种方法，我们可以直接在声明数组的时候为其开辟内存空间：

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

            int array[] = new int[10]

            2.初始化数组（一维数组）

            常见的初始化方法如下：

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

            或者

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

            看一个栗子：

            public class Day {
    public static void main(String[] args) {
        int array[] = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        int i;
        for(i = 0;i<12;i++){
            System.out.println((i+1)+"月"+array[i]+"天");
        }
    }
}
//我们创建数组array来承接天数，然后循环将其输出。

            二、二维数组

            二维数组一般表示行列间的关系，也是要重点掌握的。

            1.创建方法

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

            代码如下：

            int array[][];
我们可以直接分配内存空间:
array = new int[2][5];
或者
也可以分别为每一维分配内存空间：
array = new int[2][];
array[0] = new int[2];
array[1] = new int[3];

            两种方法均可

            2.初始化二维数组

            type arrayname[][] = {value1,value2,value3....};
/*
type 是指数组数据的类型
arrayname 是指数组的名称
value 是指数组中各元素的值
*/

            我们看一个代码：

            int array[][] = {{2,5},{5,1}};

            我们应当注意初始化我们的二维数组后，应当注意数组的小标是在0开始的。
            对于数组赋值，我们也可以直接进行赋值：

            array[1][1] = 20;  

            我们写一个类Matrix，在主方法中编写代码实现输出一个3行4列且所有元素均为0的矩阵：

            public class Matrix {
    public static void main(String[] args) {
        int array[][] = new int[3][4];
        for(int i=0; i<array.length;i++){
            for(int j=0; j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
            System.out.println();
        }
    }
}

            和一维数组一样，创建成功后，系统会给每一个元素分配初始值 0。

            三、遍历数组

            我们一般使用for循环来实现遍历数组，我们重点看一下如何遍历二维数组，我们需要双重for循环。

            举个简单例子：

            public class Matrix {
    public static void main(String[] args) {
        int array[][] = new int[3][4];
        for(int i=0; i<array.length;i++){
            for(int j=0; j<array[i].length;j++){
                System.out.println(array[i][j]);
            }
            System.out.println();
        }
    }
}

            但是一般在JAVA里面，我们不会这么玩，我们使用 foreach 来实现数组遍历：

            public class Find {
    public static void main(String[] args) {
        int array[][] = {{4,3},{5,3}};
        int i = 0;
        for(int a[]: array){
            i++;
            int j=0;
            for(int b: a){
                j++;
                if(i==array.length && j==a.length){
                    System.out.println(b);
                }else{
                    System.out.println(b + ",");
                }
            }
        }
    }
}

            四、替换元素

            有时我们会遇到让我们替换数组里一些元素的情况，我们使用fill方法来实现：

            fill(int[] array,int value);

            使用指定的int值分配给int型数组的每个元素

            我们来看一个简单的栗子：

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

            上面的栗子，使得我们数组里面的每一个元素赋值均为6；

            但是我们一般想要的是指定一些位置，那么我们继续来看：

            fill(int[] array,int fromIndex,int toIndex,int value);
fromIndex 是要使用指定值填充的第一个元素的索引（被包括）
toIndex 是使用指定值填充的最后一个元素的索引（不包括）
value 是储存在数组所有元素中的值
//我们应当注意不要让索引位置越界，否则会出现数组越界异常
            import java.util.Arrays;

public class Fill{
    public static void main(String[] args) {
        int array[] = new int[]{1,2,3,4};
        Arrays.fill(array,1,2,6);//替换数组里第二个元素
        for(int i=0; i<array.length;i++){
            System.out.println("第"+i+"个元素是："+array[i]);
        }
    }
}

            五、数组排序

            在JAVA里面提供了很棒的排序方法，也就是sort( )方法。

            Arrays.sort(object);//object也就是数组的名称

            直接上代码：

            import java.util.Arrays;

public class A{
    public static void main(String[] args) {
        int array[] = new int[]{1,2,3,4};
        Arrays.sort(array);
        for(int i = 0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

            JAVA里面对于String类型数组的排序，遵循的原则是数字排在字母前面，大写字母排在小写字母前面。

            六、数组拷贝

            Java里面一般可以用copyOf() 和copyOfRange()来实现对数组的复制。
            我们先来看copyOf():

            copyOf(array,int newlength);
array 是要进行复制的数组
newlength 是复制后的新数组的长度，如果比原来大，那么空余的地方用0填充，如果小，那么就截取到满足条件为止。

            看一下代码:

            import java.util.Arrays;

public class Copy {
    public static void main(String[] args) {
        int array[] = new int[]{1,2,3};
        int newarray[] = Arrays.copyOf(array,5);
        for(int i=0; i<newarray.length; i++){
            System.out.println(newarray[i]);
        }
    }
}
/*
* 输出结果：
* 1
* 2
* 3
* 0
* 0
* */

            然后来看一下copyOfRange的方法：

            copyOfRange(array,int fromIndex,int toIndex)
            • array 是要进行复制的数组对象
            • fromIndex 开始复制数组的索引位置，需要包括
            • toIndex 是指要复制范围的最后索引位置，但是是不包括Index的元素
            import java.util.Arrays;

public class Copy{
    public static void main(String[] args) {
        int array[] = new int[]{1,2,3,4,5};
        int newarray[] = Arrays.copyOfRange(array,0,3);//前三个元素
        for(int i = 0;i<newarray.length;i++){
            System.out.println(newarray[i]);
        }
    }
}

            七、元素查询

            二分法想必大家都听说过，在JAVA里面也有二分的思想，也就是binarySearch( )方法，二分搜索方法来搜索数组，获取我们的指定对象，返回我们要搜索的元素的索引。
            与复制相似，也有两种类似写法：

            binarySearch(Object[ ],Object key) 和 binarySearch(Object[ ] ,int fromIndex, int toIndex ,Object key ) 先看第一个：

            binarySearch(Object[ ] array,Object key)
//array 是要进行搜索的数组
//key 是要进行搜索的值，如果这个key包含在数组里面，则返回搜索值得索引，否则返回 -1 或 " - "

            我们看一个栗子：

            int array[] = new int[]{4,16,10};
Arrays.sort(arr);
int index = Arrays.binarySearch(array,0,1,7);

            我们看一下上面这个程序，我们发现原来的数组里面是没有 7 的，我们在返回值前面加一个 “ - ” ，然后它索引在0~1，我们看 7 是不是应该在 16 前面，在4的后面，经过sort排序之后，我们的顺序是{4，10，16}，此时16的位置是 2 ，所以，我们搜索7的返回值index是 -2。

            对于这种方法，应当注意，我们要是找某个元素，那么一定是排顺序后，排序好的，如果没有提前排序，那么结果是无法确定的。

            我们再看一个可以查询到的：

            import java.util.Arrays;

public class B{
    public static void main(String[] args) {
        int array[] = new int[]{5,2,4,3,1};
        Arrays.sort(array);
        int index = array.binarySearch(array,4);
        System.out.println("4的索引位置是"+index);
    }
}
//返回值是 3 ，也就是 4 的索引位置

            我们再来看一下binarySearch(Object[ ] ,int fromIndex, int toIndex ,Object key )

             binarySearch(Object[ ] array,int fromIndex, int toIndex ,Object key)
            •  array要检索的数组
            •  fromIndex是指定范围的开始处索引
            •  toIndex 是指范围内的结束处索引
            •  key 是指要搜索的元素

            使用此方法依然要进行数组的排序

            举个栗子：

            import java.util.Arrays;

public class C{
    public static void main(String[] args) {
        String str[] = new String[]{"ab","cd","ef","gh"};
        Arrays.sort(str);
        int index;
        index = Arrays.binarySearch(str,0,2,"cd");
        System.out.println("cd的索引位置："+index);
    }
}
//cd的索引位置：1 

            八、排序算法

            笔者对于常见的排序算法有过详细的讲解： 小白学六大排序算法（C语言版），思想都是一样的，这里笔者就不再讲解，选取冒泡排序，直接选择排序，反转排序这三个方面来用JAVA实现一下 :

            1.冒泡排序

            public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {1,5,6,9,8,7};
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.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;
                    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();
    }

}

            2.直接选择排序

            public class SelectSort {
    public static void main(String[] args) {
        int array[] = {5,1,2,9,4,6,7};
        SelectSort selectSort = new SelectSort();
        selectSort.sort(array);
    }

    public void sort(int[ ] array){
        int index;
        for(int i = 1; i<array.length; i++){
            index = 0;
            for(int j=1;j<=array.length-i;j++){
                if(array[j]>array[index]){
                    index = j;
                }
            }
            int temp;
            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();
    }
}

            3.反转排序

            public class ReverseSort {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        ReverseSort reverseSort = new ReverseSort();
        reverseSort.sort(array);
    }
    public void sort(int[] array){
        System.out.println("原数组：");
        showArray(array);
        int temp;
        for(int i = 0; i<array.length/2; i++){
            temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp;
        }
        System.out.println("反转之后：");
        showArray(array);
    }

    public void showArray(int[] array){
        for(int i:array){
            System.out.print(" "+i);
        }
        System.out.println();
    }
}

            到此这篇关于Java数组归纳总结的文章就介绍到这了,更多相关Java数组归纳 内容请搜索3672js教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持3672js教程！

            您可能感兴趣的文章:
            • 带你了解Java数据结构和算法之数组
            • java mybatis如何操作postgresql array数组类型
            • java数组实现循环队列示例介绍
            • Java多维数组详解
            • java 数组实现学生成绩统计教程

            相关文章

            相关栏目：

            相关文章

            用户点评