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

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. 内存分析

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. 运行结果

3.分析总结

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

    数据局限性:

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

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

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

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

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

 

 

版权声明:本博客为记录本人自学感悟,内容大多从网上学习与整理所得,若侵权请告知!

https://me.csdn.net/qq_39657909

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页