数据结构和算法--Java数组

本文将讲解数据结构的鼻祖-数组。有过编程语言基础朋友都知道，几乎所有的程序设计语言学习之初都有数组的身影，当然每种语言对数组的实现和处理也不相同，但是本质是都是用来存放数据的的结构。下面我将讲解下数组在Java中的实现。

数组的定义和使用

在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型(Object类型数组除外)，数组的元素类型和数组的大小都是确定的。

一、数组的声明

Java 中声明数组的语法有两种，如下：

① 第一种：

数据类型 []  数组名称 = new 数据类型[数组长度]; //首选
或
数据类型  数组名称[] = new 数据类型[数组长度];// 效果相同，但不是首选方法

举例：

int a[]=new int[3]; //推荐首选

int []a=new int[3];//实现效果一样，但不推荐

在java中，以上两个写法实现的效果都是一样的，但是我推荐使用第一种，这也符合 C/C++ 的写法。

②第二种：

声明数组并赋值

数组类型 [] 数组名称 = {元素1,元素2,....,元素n};//推荐
或
数组类型  数组名称[] = {元素1,元素2,....,元素n};

举例：

int a[]={1,2,3,4};
或
int []a={1,2,3,4};

二、数组的使用

① 数组的赋值和访问

数组是存在下标索引的，通过下标可以获取指定位置的元素，数组下标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。

上面数组第二种声明的时候就已经初始化了数组元素。下面我们看第一种，如下：

a:
    int arr[]=new int[4]; //声明一个长度为4的数组
    arr[0]=1;//数组第1个元素
    arr[1]=2;//数组第2个元素
    arr[2]=3;//数组第3个元素
    arr[3]=4;//数组第4个元素

b:
    int head=arr[0];//获取第1个元素
    int second=arr[1];//获取第2个元素
    .....

上面的a中我们声明了长度4的数组arr，并分别给每个元素赋值。b中我们通过下标的方式调取了数组中的元素。需要注意的是，一旦数组声明了长度L，数组的下标不能超出L长度，否则会出现数组下标越界异常。

② 数组的遍历

数组有个 length 属性，是记录数组的长度的，我们可以利用length属性来遍历数组。通常使用基本循环或者 foreach 循环来遍历数组，如下：

int arr[]={1,2,3,4,5,6,7};//声明并初始化数组，并给数组赋值

for(int i=0;i<arr.length;i++){
    
    system.out.println(arr[i]);//打印数组元素

}

 

三、多维数组

上面介绍的数组只有一个维度，称为一维数组，但是如果一维数组中的元素是一维数组，那么这个数组就构成了二维数组，因此对于 n 维数组来说，可以看作是存储有 (n-1) 维数组的一维数组。

• 数组在存储时有两种存储方式：

①、以列序为主(先列后行)

②、以行序为主(先行后列)

 图1

 

 图2

以上图1，图2分别是a[6][6]以列序存储和以行序存储。在java中，数组是以行序列存储的。

• 在n维数组中调取数据元素，需要知道以下因素：

①、数组存放的起始位置（也就是数组中第一个元素的存储位置）。

②、被调取元素在 n 维数组中的具体位置（例如，二维数组需要知道被调取元素 aij 在数组中的行标 i 和列标 j ）。

③、数组中单个数据元素占用的内存空间，一般用 L 表示（数组中存放的数据的类型都一样）。

如果在以行序存储的二维数组 a[n][m] 中查找某个数据元素 A[i][j] 的存储位置，方法是：LOC(i,j) = LOC (0,0) + (i*m+j)*L；同样，以列序存储的查找方法是：LOC(i,j) = LOC (0,0) + (i*n+j)*L；

举例：

public class Test {
    
	public static void main(String[] args) {
        int[][] arr=new int[2][3];//声明一个2行3列的二维数组
		
		//第一行元素赋值
		arr[0][0]=1;//第1列
		arr[0][1]=2;//第2列
		arr[0][2]=3;//第3列
		
		//第2行元素赋值
		arr[1][0]=4;//第1列
		arr[1][1]=5;//第2列
		arr[1][2]=6;//第3列
		
		
		int el_1_1=arr[0][0];//访问第1行第1列元素
		int el_1_2=arr[0][1];//访问第1行第2列元素
		
		//访问第i行第j列元素
		//int el_i_j=arr[i][j];
		
		for(int i=0;i<arr.length;i++){
			//System.out.println("第"+(i+1)+"行：");
			for(int j=0;j<arr[0].length;j++){
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
		
    }
	
}

测试的打印结果如下：

 

类封装实现数组的数据结构

　　我们之前了解过数据结构的基本功能功能无非就是对数据元素的增删改查操作，而我们知道了数组的简单用法，现在用类的思想封装一个数组来实现。

public class ArrayOperation {
    
    private int [] intArray;//声明一个数组
    
    private int elems;//定义数组的实际有效长度
    
    private int length;//定义数组的最大长度
     
    //默认构造一个长度为50的数组
    public ArrayOperation(){
        elems = 0;
        length = 100;
        intArray = new int[length];
    }
	
    //构造函数，初始化一个长度为length 的数组
    public ArrayOperation(int length){
        elems = 0;
        this.length = length;
        intArray = new int[length];
    }
     
    //获取数组的有效长度
    public int getSize(){
        return elems;
    }
     
    /**
     * 遍历显示元素
     */
    public void display(){
        for(int i = 0 ; i < elems ; i++){
            System.out.print(intArray[i]+" ");
        }
        system.out.println();
    }
     
    /**
     * 添加元素
     * @param value。
     * @return添加成功返回true,添加的元素超过范围了返回false
     */
    public boolean add(int value){
        if(elems == length){
            return false;
        }else{
            intArray[elems] = value;
            elems++;
        }
        return true;
    }
     
    /**
     * 根据下标获取元素
     * @param i
     * @return查找下标值在数组下标有效范围内，返回下标所表示的元素
     * 查找下标超出数组下标有效值，提示访问下标越界
     */
    public int get(int i){
        if(i<0 || i>elems){
            System.out.println("访问下标越界");
        }
        return intArray[i];
    }

    /**
     * 查找元素
     * @param searchValue
     * @return查找的元素如果存在则返回下标值，如果不存在，返回 -1
     */
    public int find(int searchValue){
        int i ;
        for(i = 0 ; i < elems ;i++){
            if(intArray[i] == searchValue){
                break;
            }
        }
        if(i == elems){
            return -1;
        }
        return i;
    }

    /**
     * 删除元素
     * @param value
     * @return如果要删除的值不存在，直接返回 false;否则返回true，删除成功
     */
    public boolean delete(int value){
        int k = find(value);
        if(k == -1){
            return false;
        }else{
            if(k == elems-1){
                elems--;
            }else{
                for(int i = k; i< elems-1 ; i++){
                    intArray[i] = intArray[i+1];
                   
                }
                 elems--;
            }
            return true;
        }
    }


    /**
     * 修改数据
     * @param oldValue原值
     * @param newValue新值
     * @return修改成功返回true，修改失败返回false
     */
    public boolean modify(int oldValue,int newValue){
        int i = find(oldValue);
        if(i == -1){
            System.out.println("数据不存在");
            return false;
        }else{
            intArray[i] = newValue;
            return true;
        }
    }
	
}


class Test{

    public static void main(String[] args) {
        //创建自定义封装数组结构，数组大小为3
        ArrayOperation array = new ArrayOperation(3);
        
        //添加3个元素分别是1,2,3
        array.add(1);
        array.add(2);
        array.add(3);
  
        //显示数组元素
        array.display();

        //根据下标为0的元素
        int el1 = array.get(0);
        System.out.println(el1);

        //删除3的元素
        array.delete(3);

        //将元素1修改为100
        array.modify(1, 100);
        array.display();
    }

}

测试的打印结果如下：

数组分析总结

通过上面的介绍结合实例，我们知道如何定义数组和使用数组，也知道数组能够实现数据结构的基本功能，虽然数组优势明显，但是也存在局限。

①、数组一旦创建后，大小就固定了，不能动态扩展数组的元素个数。如果初始化你给一个很大的数组大小，那会白白浪费内存空间，如果给小了，后面数据个数增加了又添加不进去了。

②、插入快，对于无序数组，上面我们实现的数组就是无序的，即元素没有按照从大到小或者某个特定的顺序排列，只是按照插入的顺序排列。无序数组增加一个元素很简单，只需要在数组末尾添加元素即可，但是有序数组却不一定了，它需要在指定的位置插入。

③、查找慢，当然如果根据下标来查找是很快的。但是通常我们都是根据元素值来查找，给定一个元素值，对于无序数组，我们需要从数组第一个元素开始遍历，直到找到那个元素。有序数组通过特定的算法查找的速度会比无需数组快，后面我们会讲各种排序算法。

④、删除慢，根据元素值删除，我们要先找到该元素所处的位置，然后将元素后面的值整体向前面移动一个位置。也需要比较多的时间。

　　很显然，数组虽然插入快，但是查找和删除都比较慢，而且扩展性差，所以我们一般不会用数组来存储数据，后面会继续为大家详解其他的数据结构。

这里顺带提一下，对于C的朋友来说，可能很疑惑，Java数组有没指针呢？答案是没有，Java是引用类型，因此java数组的引用相当于C的指针，但他们又有所区别：指针能进行加减运算，数组的引用只能赋值运算；数组的引用传送的是值，而指针则是地址。具体大家可以自行去了解，这里就不详细介绍。