Java-数组队列

java-数组队列

1、为何要创建一个数组队列？

　　数组的优点和缺点：

　　　　优点：访问速度是所有数据结构中最快的一种。

　　　　缺点：大小固定，如果要存储的数据个数不确定的时候？
   　　　　  　　数组空间不够，导致越界异常发生
   　　　　  　　如果空间太大了，数据不够，就会浪费内存空间
 　　　　　　　插入、删除数据，的操作非常麻烦。　

　　可见数组虽然有访问速度快的优点，但是数组的大小是固定了的，经常会出现空间不够或者数组越界的情况，并且删除和插入数据特别麻烦，因此就引入了数组队列的概念

 

2、数组队列的实现原理

　  数组的大小是根据你要添加的数据来决定的。
  　根据添加、删除数据的个数，来创建新的数组。
  　数组名中存储的是数组对象在堆内存空间的首地址。
  　新数组名中存储了新数组对象的首地址。
  　把这个首地址给原来数组名。
  　原来的数组对象，jvm（java虚拟机）的垃圾回收机制，会销毁对象，释放内存空间。

 

3、数组队列的具体实现方法

 

  数组队列：定义类，封装对数组的操作。

 

  数组队列的要求：
  在特殊情况，数组队列中只能存储某一种数据类型，如果存储其他的数据就报错。
  在特殊情况，数组中可以存储任意一种数据类型的数据
  上面两种情况的实现需要用到泛型<e>、<k、v>、<t>、...
   　　①泛型不是java中的一种数据类型。
   　　②只是一个特殊的符号，可以在你不确定要存储什么类型的数据时，用这个符号代替java中所有的数据类型。
   当你使用的时候，你可以用对应的数据类型来代替这个符号，这样
   就只能存储你指定的这一种数据类型；
   如果你不指定，则任意一种数据类型都可以存储。

 

4、自己定义一个数组队列的类

代码如下：

 

  1 package com.cyt.myarraylist0126;
  2 
  3 public class myarraylist<e> {
  4     // 定义一个object类型的数组
  5     private object[] array = null;
  6     // 定义这个数组中已经添加的元素个数
  7     private int size = 0;
  8 
  9     // 通过构建函数初始化object数组
 10     public myarraylist() {
 11         array = new object[0];
 12     }
 13 
 14     public myarraylist(int length) {
 15         array = new object[length];
 16     }
 17 
 18     // 定义了一个往队列末尾添加元素的方法
 19     public void add(e stu) {
 20         if (array.length == 0 || array.length == size) {
 21             object[] newarray = new object[array.length + 1];
 22             for (int i = 0; i < array.length; i++) {
 23                 newarray[i] = array[i];
 24             }
 25             newarray[array.length] = stu;
 26             array = newarray;
 27             size++;
 28         } else {
 29             array[size++] = stu;
 30         }
 31     }
 32     //定义了一个通过下标往队列数组里面插入元素的方法
 33     public boolean add(int index, e stu) {
 34         if (index < 0 || index >= array.length)
 35             return false;
 36         else {
 37             object[] newarray = new object[array.length + 1];
 38             for (int i = 0; i < array.length; i++) {
 39                 newarray[i] = array[i];
 40             }
 41             array = newarray;
 42             for (int i = array.length - 1; i > index; i--) {
 43                 array[i] = array[i - 1];
 44             }
 45             array[index] = stu;
 46             size++;
 47             return true;
 48 
 49         }
 50 
 51     }
 52 
 53     //定义了一个往队列数组通过下标添加队列数组的方法
 54     // c++的移动（需要经常复习）
 55     public boolean add(int index, myarraylist<e> mal) {
 56         if (index < 0 || index >= array.length)
 57             return false;
 58         else if (array.length - size >= mal.size) {
 59 
 60             for (int i = size + mal.size - 1; i >= index + mal.size; i--) {
 61                 array[i] = array[i - mal.size];
 62             }
 63             for (int i = index; i < index + mal.size; i++) {
 64                 array[i] = mal.get(i - index);
 65             }
 66             size += mal.size;
 67             return true;
 68         } else {
 69             object[] newarray = new object[mal.size + size];
 70             for (int i = 0; i < size; i++) {
 71                 newarray[i] = array[i];
 72             }
 73             array = newarray;
 74             for (int i = size + mal.size - 1; i >= index + mal.size; i--) {
 75                 array[i] = array[i - mal.size];
 76             }
 77             for (int i = index; i < index + mal.size; i++) {
 78                 array[i] = mal.get(i - index);
 79             }
 80             size += mal.size;
 81             return true;
 82         }
 83 
 84     }
 85 
 86     //定义了一个通过下标移除队列数组已有元素的方法
 87     public e remove(int index) {
 88         if (index < 0 || index >= size)
 89             return null;
 90         // 获取要移除的数据
 91         object stu = array[index];
 92         int i;
 93         // 把index位置后的数据都往前移一位
 94         for (i = index + 1; i < size; i++)
 95             array[i - 1] = array[i];
 96         array[i - 1] = null;
 97         size--;
 98         return (e) stu;
 99     }
100 
101     //定义了一个移除队列元素中特定元素的方法
102     public boolean remove(e stu) {
103         int index = 0;
104         for (index = 0; index < array.length; index++) {
105             if (array[index] == stu) {
106                 break;
107             }
108         }
109         if (index < 0 || index >= array.length)
110             return false;
111         else {
112             // 获取要移除的数据
113             object stu2 = array[index];
114             // 把index位置后的数据都往前移一位
115             for (int i = index + 1; i < size; i++)
116                 array[i - 1] = array[i];
117             size--;
118             return true;
119         }
120     }
121     //定义了一个移除队列中所有指定对象的方法
122     // 非常易错的地方
123     public int removeall(e stu) {
124         boolean a = true;
125         while (a) {
126             a = false;
127             for (int i = 0; i < array.length; i++) {
128                 if (array[i] == stu) {
129                     a = true;
130                     int j;
131                     for (j = i; j < array.length - 1; j++) {
132                         array[j] = array[j + 1];
133                     }
134                     // 关键点
135                     array[j] = null;
136                     size--;
137                     break;
138                 }
139             }
140         }
141 
142         return 0;
143     }
144     //定义了一个通过下标更新元素的方法
145     public boolean update(int index, e stu) {
146         if (index < 0 || index >= array.length)
147             return false;
148         else {
149             array[index] = stu;
150             return true;
151         }
152     }
153     //定义了一个更新所有指定对象的方法
154     public int updateall(e stu, e newstu) {
155         for (int i = 0; i < array.length; i++) {
156             if (array[i] == stu) {
157                 array[i] = newstu;
158             }
159         }
160         return 0;
161     }
162     //定义了一个获取数组中特定下标元素的方法
163     public e get(int index) {
164         if (index < 0 || index >= size)
165             return null;
166         return (e) array[index];
167     }
168     //定义了一个获取队列数组中已有元素个数的方法
169     public int size() {
170         return size;
171     }
172     //定义了一个获取队列数组的方法
173     public e[] getarray() {
174         return (e[]) array;
175     }
176 }

 

 

5、测试自己创立的队列数组

代码如下

①首先创立了一个学生类

 

 1 public class students {
 2     private string name;
 3     private int credit;
 4     private int age;
 5     public students(string name,int credit,int age){
 6         this.name = name;
 7         this.credit = credit;
 8         this.age  =age;
 9     }
10     
11     public void setname(string name){
12         this.name = name;
13     }
14     public string getname(){
15         return name;
16     }
17     public void setcredit(int credit){
18         this.credit = credit;
19     }
20     public int getcredit(){
21         return credit;
22     }
23     public void setaage(int age){
24         this.age = age;
25     }
26     public int getage(){
27         return age;
28     }
29     public void show(){
30         system.out.println("name "+ name+" credit " + credit+ " age "+ age+"\n");
31     }
32 }

 

 

②在主方法里面随机建立学生对象添加到队列数组里面

 

 1     public static void main(string[] args) {
 2         myarraylist<students> array = new myarraylist();
 3         int size;
 4         string name = "";
 5         int credit;
 6         int age;
 7         random random = new random();
 8         // students stu3 = new students("cyt",5,18);
 9         // array.add(stu3);
10         size = random.nextint(5) + 1;
11         for (int i = 0; i < size; i++) {
12             credit = random.nextint(5);
13             age = random.nextint(5) + 18;
14             for (int j = 0; j < 4; j++) {
15                 name += (char) (random.nextint(26) + 97);
16             }
17             array.add(new students(name, credit, age));
18             name = "";
19         }
20         // array.add(stu3);
21 
22         system.out.println("人数：" + size + "\n");
23         system.out.println("人员信息:" + "\n");
24         for (int i = 0; i < array.size(); i++) {
25             students stu = array.get(i);
26             stu.show();
27         }

 

结果显示：