数组与数组队列

一、数组

        数组是属于数据结构中一种线性的数据结构。

        数组对象在内存中的存储方式是一个连续的存储空间。一维数组在内存中的存储方式是一整块连续的空间，多维数组在内存中的存储方式是多块连续的存储空间，这些块不一定连在一起。

        数组定义的方式有：

                 1、数据类型 [] 数组名 = new 数据类型[长度];

                 2、数据类型 [] 数组名 = {数据,...};

                 3、数据类型 [] 数组名 = new 数据类型[]{数据,...};

        延伸的定义方式有：

                 4、数据类型 [] 数组名;

                         数组名 = new 数据类型[长度];

                 5、数据类型 [] 数组名;

数组名 = new 数据类型[]{数据,...};

        多维数组定义的方式有：

                 1、数据类型 [][] 数组名 = new 数据类型[行][列];

                 2、数据类型 [][] 数组名 = {{数据,...},...};

        数组是一个类，提供了属性和方法。但数组只有一个唯一的length属性，该属性是用来获取数组长度

        方法有：

        1、获取或设置一维数组中某一个位置的数据：数组名[下标]

        2、获取一维数组能存储多少个元素：数组名.length

        获取或设置二维数组中某一个位置的数据：数组名[行下标][列下标]

        获取二维数组的行数：数组名.length

        获取二维数组的列数：数组名[行下标].length

        获取二维数组能存储多少个元素：

                 1、数组名.length*数组名[行下标].length

                 2、数组名[行下标].length+...

                

        注：除了0可以直接给数字之外，其他的都通过length来获取

                数组下标只会从0开始。

                

二、数组队列

        1.数组的优点和缺点

                 优点：

                         存取数据是所有数据结构中速度最快的一种，在获取或设置数据时，可以直接通过下标定位。

                 缺点：

                         （1）如果要存储的数据不确定时，数组在创建时需要给予的长度就是缺点。创建数组小了，存储不下数据。创建数组大了，浪费内存空间。

                         （2）如果在特定情况下只能存储一种数据类型或者需要存储N种数据类型，这样数组在创建时需要指定固定的类型就会是缺点。

                        

        2.数组队列的实现

                 数组队列的实现原理：借助于数组名中存储的是数组对象在内存中的首地址。

                 interface MyArrayList.java   父接口，定义数组中所需要实现的方法

package tvjivo.datastruct0810;

 

public interface MyArrayList<E>{

    /**

     * 添加元素到数组队列中的方法

     * @param e要添加的元素

     */

    public void add(E e);

   

    /**

     * 向数组队列中指定的位置插入一个新的元素

     * @param index要插入元素的所在的索引位置

     * @param e要插入的新元素

     * @return返回true表示插入成功，返回false表示插入失败

     */

    public boolean add(int index,E e);

   

    /**

     * 根据指定的索引位置，从数组队列中移除一个元素

     * @param index要移除元素所在的索引位置

     * @return返回null表示移除失败，否则会返回移除的元素

     */

    public E remove(int index);

   

    /**

     * 移除指定的元素

     * @param e要移除的元素

     * @return返回值true表示执行成功，返回false表示执行失败

     */

    public boolean remove(E e);

   

    /**

     * 修改指定索引位置的元素

     * @param index要修改元素的位置

     * @param e新的元素

     * @return返回值true表示执行成功，返回false表示执行失败

     */

    public boolean update(int index,E e);

 

    /**

     * 修改指定元素的内容

     * @param oldE要修改的元素

     * @param e新的元素

     * @return返回值true表示执行成功，返回false表示执行失败

     */

    public boolean update(E oldE,E e);

   

    /**

     * 获取数组队列中存储的元素总数

     * @return返回数组队列中存储的元素总数属性

     */

    public int size();

   

    /**

     * 获取指定索引位置的元素

     * @param index要获取元素的索引位置

     * @return返回null表示获取失败，否则会返回获取到的元素

     */

    public E get(int index);

}

 

                 class MyArrayListImpl.java    子类，实现接口中所有的抽象方法。

package tvjivo.datastruct0810;

 

public class MyArrayListImpl<E> implements MyArrayList<E> {

    // 声明一个数组名

        private Object[]array;

        // 声明一个记录存储元素总数的属性名

        private int size;

 

        /**

         * 构造方法

         */

        public MyArrayListImpl() {

           array = new Object[1];

        }

 

        // public MyArrayListImpl(inti){

        // array = new String[i];

        // }

 

        /**

         * 添加元素到数组队列中的方法

         *

         * @param e要添加的元素

         */

        public void add(E e) {

           if (size == 0)

               array[0] = e;

           else {

               // 根据所添加元素的的个数来创建新的数组，新数组的长度是size+1

               Object[] newArray = new Object[size + 1];

               // 将新元素str添加到newArray数组的末尾

               newArray[size] = e;

 

               // 将原始数组中的数据存入到新数组中

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

                   newArray[i] = array[i];

               }

 

               // 新数组的地址赋给原始数组

               array = newArray;

           }

           // 记录元素总数增加1.

           size++;

        }

 

        /**

         * 向数组队列中指定的位置插入一个新的元素

         *

         * @param index要插入元素的所在的索引位置

         * @param e要插入的新元素

         * @return返回true表示插入成功，返回false表示插入失败

         */

        public boolean add(int index, E e) {

           if(index<0||index>size){

               return false;

           }

           else{

               // 根据所添加元素的的个数来创建新的数组，新数组的长度是size+1

               Object[] newArray = new Object[size + 1];

               // 将新元素str添加到newArray数组

               newArray[index] = e;

               // 将原始数组中的数据存入到新数组中

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

                   newArray[i] = array[i];

               }

               for (int i = index; i <size; i++) {

                   newArray[i+1] = array[i];

               }

               // 新数组的地址赋给原始数组

               array = newArray;

               // 记录元素总数增加1.

               size++;

               return true;

           }

        }

 

        /**

         * 根据指定的索引位置，从数组队列中移除一个元素

         *

         * @param index要移除元素所在的索引位置

         * @return返回null表示移除失败，否则会返回移除的元素

         */

        public E remove(int index) {

           if(index<0||index>=size){

               return null;

           }

           else{

               // 根据所添加元素的的个数来创建新的数组，新数组的长度是size+1

               Object[] newArray = new Object[size - 1];

               // 将原始数组中的数据存入到新数组中

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

                   newArray[i] = array[i];

               }

               for (int i = index+1; i <size; i++) {

                   newArray[i-1] = array[i];

               }

               // 新数组的地址赋给原始数组

               array = newArray;

               // 记录元素总数减1.

               size--;

               return(E)array[index];

           }

        }

 

        /**

         * 移除指定的元素

         *

         * @param e要移除的元素

         * @return返回值true表示执行成功，返回false表示执行失败

         */

        public boolean remove(E e) {

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

               if(e==array[i]){

                   Object[] newArray = new Object[size - 1];

                   // 将原始数组中的数据存入到新数组中

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

                       newArray[j] = array[j];

                   }

                   for (int j = i+1; j <size; j++) {

                       newArray[j-1] = array[j];

                   }

                   // 新数组的地址赋给原始数组

                   array = newArray;

                   // 记录元素总数减1.

                   size--;

                   returntrue;

               }

           }

           return false;

        }

       

        public boolean removeAll() {

           if(size==0){

               return false;

           }

           else{

               Object[] newArray = new Object[0];

               // 新数组的地址赋给原始数组

               array = newArray;

               return true;

           }

        }

 

        /**

         * 修改指定索引位置的元素

         *

         * @param index要修改元素的位置

         * @param e新的元素

         * @return返回值true表示执行成功，返回false表示执行失败

         */

        public boolean update(int index, E e) {

           if(index<0||index>=size){

               return false;

           }

           else{

               array[index]=e;

               return true;

           }

        }

 

        /**

         * 修改指定元素的内容

         *

         * @param oldE要修改的元素

         * @param e新的元素

         * @return返回值true表示执行成功，返回false表示执行失败

         */

        public boolean update(E oldE, E e) {

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

               if(array[i]==oldE){

                   array[i]=e;

                   returntrue;

               }

           }

           return false;

        }

 

        /**

         * 获取数组队列中存储的元素总数

         *

         * @return返回数组队列中存储的元素总数属性

         */

        public int size() {

           returnsize;

        }

 

        /**

         * 获取指定索引位置的元素

         *

         * @param index要获取元素的索引位置

         * @return返回null表示获取失败，否则会返回获取到的元素

         */

        public E get(int index) {

           if (index < 0 || index >=size)

               return null;

           return(E)array[index];

        }

}

 

                Java中提供了一个数组队列类java.util.ArrayList。

        3.使用泛型。

                 泛型是Java中的一种特殊符号，不能把它当做任何一个种数据类型。但是它可以泛指Java所有的数据类型（基本数据类型，引用类型）。Java中的泛型有E（元素）、K(键)、V（值）。