数据结构---------数组

清疚 2022-05-03 00:58 227阅读 0赞

## 1.Java数组介绍 ##

1.  概念：同一种类型的集合，其实数组就是一个容器
2.  使用优点：可以自动给数组中的元素从0开始编号，方便操作这些元素。
3.  声明的方式：
    
    1.  元素类型\[\] 数组名=new 元素类型\[元素个数或数组长度\]  
        例：int\[\] arr=new int\[5\];
    2.  元素类型\[\] 数组名 =new 元素类型\[\]\{元素，元素，......\}  
        例：int\[\] arr=new int\[\]\{3,5,8,6\};  
               int\[\] arr=\{3,5,6,8\};
    3.  数组的遍历  
         
        
            public static void main(String[] args) {
            
                int[] x = { 1, 2, 3 };
            
                for (int y = 0; y < x.length; y++) {
            
                    System.out.println(x[y]);
                
                    // System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;
            
                } // 那么这就是数组的第一个常见操作.遍历
             
            }
    4.  常见异常
        
        1.  NullPointerException 空指针异常  
            引发原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法
        2.  ArrayIndexOutOfBoundsException 索引值越界  
            引发原因：访问了不存在的索引值。
    5.  内存分析  
        ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU3OTA5_size_27_color_FFFFFF_t_70][]

## 2.自己手写一个数组代码测试，具备以下功能 ##

1.  插入一条新的数据项
2.  寻找特定数据项
3.  删除某一特定数据项
4.  迭代的访问各个数据项，以便进行显示或其他操作
5.  MyArray类  
    ps:假设操作人是不会添加重复元素的，这里没有考虑重复元素，如果添加重复元素了，后面的查找，删除，修改等操作只会对第一次出现的元素有效。  
     
    
        package com.lsl.array;
        
        public class MyArray {
            //定义一个数组intArray,数组的实际长度elems,数组的最大长度。
            private int[] intArray;
            private int elems;
            private int length;
        
            //默认构造一个长度为50的数组
            public MyArray(){
                elems=0;
                length=50;
                intArray=new int[length];
            }
        
            //构造函数传参时创建一个长度为length的数组
            public MyArray(int length){
                elems=0;
                this.length=length;
                intArray=new int[length];
            }
        
            //1.创建获得数组有效长度的方法
            public int getSize(){
                return elems;
            }
        
            //2.遍历元素,打印元素值
            public void display(){
                for (int i=0;i<elems;i++){
                    System.out.print(intArray[i]+" ");
                }
                System.out.println();
            }
        
            //3.添加元素
            public boolean add(int value){
                if (elems==length){
                    return false;
                }else{
                    intArray[elems]=value;
                    elems++;
                }
                return true;
            }
        
            //4.根据下标获取元素
            public int get(int i){
                if (i<0||i>elems){
                    System.out.println("访问下标越界！");
                }
                return intArray[i];
            }
        
            //5.查找元素下标
            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;
            }
        
            //6.删除元素
            public boolean delete(int value){
                int k=find(value);
                if (k!=-1){
                    if (k==elems-1){
                        elems--;
                    }else{
                        for(int i=k;i<elems-1;i++){
                            intArray[i]=intArray[i+1];
                        }
                        elems--;
                    }
                }else{
                    return false;
                }
                return true;
            }
        
            //7.修改数据
            public boolean modify(int oldValue,int newValue){
                int k=find(oldValue);
                if (k!=-1){
                    intArray[k]=newValue;
                }else{
                    System.out.println("修改的数据不存在！");
                    return false;
                }
                return true;
            }
        }
6.  MyArrayTest类  
     
    
        package com.lsl.array;
        
        public class MyArrayTest {
            public static void main(String[] args){
                //创建自定义封装数组结构，数组大小为4
                MyArray array = new MyArray(4);
                //添加4个元素分别是1,0,2,4
                array.add(1);
                array.add(0);
                array.add(2);
                array.add(4);
                //显示数组元素
                array.display();
                //根据下标为0的元素
                int i = array.get(0);
                System.out.println(i);
                //删除4的元素
                array.delete(0);
                //将元素3修改为33
                array.modify(2, 345);
                array.display();
            }
        }
7.  运行结果
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU3OTA5_size_27_color_FFFFFF_t_70 1][]

## 3.分析总结 ##

数组能实现数据结构所有功能，那为什么实际中我们不用它进行所有数据存储呢？

数据局限性：

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

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

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

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

很显然，数组虽然插入快，但是查找和删除都比较慢，而且扩展性差，所以我们一般不会用数组来存储数据，那有没有什么数据结构插入、查找、删除都很快，而且还能动态扩展存储个数大小呢，答案是有的，但是这是建立在很复杂的算法基础上，后面会详细讲述。

[https://me.csdn.net/qq\_39657909][https_me.csdn.net_qq_39657909]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU3OTA5_size_27_color_FFFFFF_t_70]: /images/20220503/11523567dbfd4f68be3562c0f6cefdb8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjU3OTA5_size_27_color_FFFFFF_t_70 1]: /images/20220503/2749a4497aef43cabeb5ccb4fd3bd3ff.png
[https_me.csdn.net_qq_39657909]: https://me.csdn.net/qq_39657909