Java自定义长度可变数组的操作

时间:2022-09-27 14:37:25

我们都知道数组是线性的、类型固定、内存地址连续、定长的,主要是数组一旦被定义,那么它的长度也就定下来了,只能添加有限的数据。而长度可变的数组是要将这个长度打破,实现数组数据无限增加

那么定义长度可变的数组就可以用两个数组来实现数组长度的变化。为了避免每次增加数据或删除数据时都要重新开辟空间,我先设定原数组为固定长,在当数组放满时,一次增加一定的长度,这样 节省了开辟空间的时间

因为数组里的数据类型是不确定的,所以用泛型比较好

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MyList<E> {
 private int rongliang;//容量
 private int zengliang;//增量
 private int num;//数量
 
 //定义一个原数组
 //Object类包含所有的类型,所以定义数组是用Object类
 private Object[] src;
 
 //三个不同的构造方法
 public MyList(){
 this(10,10);
 }
 
 public MyList(int rongliang){
 this(rongliang,10);
 }
 
 public MyList(int rongliang,int zengliang){
 this.rongliang = rongliang;
 this.zengliang = zengliang;
 src = new Object[rongliang];
 }
}

在MyList中实现在数组中添加数据,要考虑到数组中的数据数量小于数组长度时,可以直接在数组为null处添加数据,但当数组的数量大于等于数组长度时,要先重新定义一个数组,长度是原数组加增量,然后再添加数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void add(E s){
 //判断数组中的数据数量num是否大于数组的长度(容量),超出则需扩容
 if(num>=src.length){
 //定义一个新的数组,长度是原有的长度加增量
 Object arr[] = new Object[src.length+zengliang];
 //拷贝数组数据
 System.arraycopy(arr, 0, arr, 0, src.length);
 src = arr;
 }
 //如果num不大于数组的长度,则不需扩容,直接加入
 //如果num大于等于数组长度,则需执行上面的if语句扩容,再加入数据
 //最后num++
 src[num++] = s;
 }

取出指定下标的数据,因为传入的是下标的参数,所以要判断数组的下标是否越界,抛出异常

?
1
2
3
4
5
6
7
8
public E get(int index){
 //抛出异常
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException("下标越界!index:"+index+",size:"+num);
 }
 //强制转换成E类型
 return (E)src[index];
 }

修改指定下标的数据,因为传入的是下标的参数,所以要判断数组的下标是否越界,抛出异常

?
1
2
3
4
5
6
7
public void modify(int index,E s){
 //抛出异常
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException("下标越界!index:"+index+",size:"+num);
 }
 src[index] = s;
 }

删除指定下标的数据,当数组中null值的长度大于等于增量时,要将数组的容量减小,防止浪费

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void delete(int index){
 //抛出异常
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException("下标越界!index:"+index+",size:"+num);
 }
 //将>index的数据依次向前移动一位
 System.arraycopy(src, index+1, src, index, num-index-1);
 num--;
 //减少容量的方法
 if(src.length-num>=zengliang){
   //定义一个新的数组,长度是原先数组的长度减去增量
     Object arr[] = new Object[src.length-zengliang];
   //拷贝数组
     System.arraycopy(src, 0, arr, 0, num);
   src = arr;
 }
 }

将指定下标处的数据改为指定的数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void insert(int index,E s){
 //抛出异常
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException("下标越界!index:"+index+",size:"+num);
 }
 //判断数组中的数据数量num是否大于数组的长度(容量),超出则需扩容
 if(num>=src.length){
   //定义一个新的数组,长度是原有的长度加增量
   Object arr[] = new Object[src.length+zengliang];
   //拷贝数组数据
   System.arraycopy(src, 0, arr, 0, src.length);
   src = arr;
 }
 //将>index的数据依次向后移动一个位置
 //arraycopy()是可以将数据自己拷贝给自己
 System.arraycopy(src, index, src, index+1, num-index);
 //插入数据
 src[index] = s;
 num++;
 }

最后在写个获取数组中数据的个数,而不是数组的长度

?
1
2
3
public int size(){
   return num;
 }

写个测试类,来测试这个长度可变的数组是否可行

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class test {
 
 public static void main(String[] args) {
 //创建一个MyList对象
 // 在创建对象时明确类型
 MyList<String> list = new MyList<String>();
 
 //添加数据
 list.add("a");
 list.add("b");
 list.add("c");
 list.add("d");
 list.add("e");
 list.add("f");
 list.add("g");
 list.add("h");
 list.add("i");
 list.add("j");
 
 //遍历数组
 for(int i=0;i<list.size();i++){
 String s = list.get(i);
 System.out.print(s+" ");
 }
 
 System.out.println("");
 int n = list.size();
   System.out.println("数据个数为:"+n);
 System.out.println("**********************************************");
 
 //修改指定位置的数据
 list.modify(1, "QQ");
 
 //遍历数组
 for(int i=0;i<list.size();i++){
 String s = list.get(i);
 System.out.print(s+" ");
 }
 
 System.out.println("");
 int m = list.size();
 System.out.println("数据个数为:"+m);
 System.out.println("**********************************************");
 
 //删除指定位置的数据
 list.delete(2);
 
 //遍历数组
 for(int i=0;i<list.size();i++){
 String s = list.get(i);
 System.out.print(s+" ");
 }
 
 System.out.println("");
   int k = list.size();
   System.out.println("数据个数为:"+k);
 System.out.println("**********************************************");
 
 //在指定位置插入指定的数据
 list.insert(3, "zr");
 list.insert(3, "qi");
 
 //遍历数组
 for(int i=0;i<list.size();i++){
 String s = list.get(i);
 System.out.print(s+" ");
 }
 
 System.out.println("");
 int h = list.size();
   System.out.println("数据个数为:"+h);
 System.out.println("**********************************************");
 }
 
}

最终数组的结果为:

?
1
2
3
4
5
6
7
8
9
10
11
12
a b c d e f g h i j
数据个数为:10
**********************************************
a QQ c d e f g h i j
数据个数为:10
**********************************************
a QQ d e f g h i j
数据个数为:9
**********************************************
a QQ d qi zr e f g h i j
数据个数为:11
**********************************************

补充:在Java中创建一个自定义长度的数组并输入每个元素

用到知识点:数组、方法、Scanner、for循环。

作业:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package Array;
import java.util.Scanner;
public class InputArray {
public static void main(String[] args) {
shuzu();//方法调用
 }
 //方法定义
 public static void shuzu() {
 
 //将输入的数字作为数组的长度
 Scanner sz = new Scanner(System.in);
 System.out.println("请输入数组长度:");//提示可以操作
 int[] cd = new int[sz.nextInt()];//数组初始化完成
 System.out.println("当前数组长度定义为:"+cd.length);//再提示一下结果
 
 //用for循环为每一个元素赋值
 for (int i = 0; i < cd.length; i++) {
  int q = i+1;//这里q用作提示,避免提示出第0个元素。
  System.out.println("请输入第"+q+"个元素的值:");
  cd [i] = sz.nextInt();
  System.out.println("第"+q+"个元素定义为"+cd[i]+"。");
  }
  sz.close();
  
  //数组内各元素已经完成赋值,但是再用for循环遍历一次
 System.out.print("数组内元素全部完成赋值:");//继续提示一下
 for (int i2 = 0; i2 < cd.length; i2++) { 
  if(i2 == cd.length-1) {
  System.out.print(cd[i2]+"。");
  }else {
  System.out.print(cd[i2]+"、");
  }
 }
 return;//方法结束,rentun;
 }
 
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持服务器之家。如有错误或未考虑完全的地方,望不吝赐教。

原文链接:https://blog.csdn.net/miss_rong/article/details/60967501