Java Custom Length Variable Array Operation

We all know that arrays are linear, fixed in type, continuous in memory address and fixed in length. Mainly, if the array 1 is defined, its length will be fixed, and only limited data can be added. The variable length array is to break this length and realize the infinite increase of array data

Then defining an array with variable length can use two arrays to realize the change of array length. In order to avoid re-opening space every time data is added or deleted, I first set the original array as a fixed length, and when the array is full, I increase the length by 1 fixed at a time, which saves the time of opening up space

Because the data type in the array is indeterminate, it is better to use generics

public class MyList<E> {
 private int rongliang;// Capacity 
 private int zengliang;// Increment 
 private int num;// Quantity 
 
 // Definition 1 Original array 
 //Object Class contains all types, so the array is defined using the Object Class 
 private Object[] src;
 
 //3 Different construction methods 
 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];
 }
}

In MyList, add data to the array. When the number of data in the array is less than the length of the array, you can add data directly to the null, but when the number of arrays is greater than or equal to the length of the array, you should first redefine an array, the length is the original array plus increment, and then add data

public void add(E s){
 // Determine the amount of data in the array num Is it larger than the length (capacity) of the array, and if it exceeds it, it needs to be expanded 
 if(num>=src.length){
 // Definition 1 New array, the length is the original length plus increment 
 Object arr[] = new Object[src.length+zengliang];
 // Copy array data 
 System.arraycopy(arr, 0, arr, 0, src.length);
 src = arr;
 }
 // If num If it is not larger than the length of the array, it does not need to be expanded and is directly added 
 // If num Is greater than or equal to the array length, the above if Statement expansion, and then add data 
 // Finally num++
 src[num++] = s;
 }

Take out the specified subscript data, because the subscript parameter is passed in, so it is necessary to judge whether the subscript of the array is out of bounds and throw an exception

public E get(int index){
 // Throw an exception 
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException(" Subscript out of bounds! index:"+index+",size:"+num);
 }
 // Cast to E Type 
 return (E)src[index];
 }

Modify the specified subscript data, because the subscript parameter is passed in, so it is necessary to judge whether the subscript of the array is out of bounds and throw an exception

public void modify(int index,E s){
 // Throw an exception 
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException(" Subscript out of bounds! index:"+index+",size:"+num);
 }
 src[index] = s;
 }

Delete the specified subscript data. When the length of null value in the array is greater than or equal to the increment, reduce the capacity of the array to prevent waste

public void delete(int index){
 // Throw an exception 
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException(" Subscript out of bounds! index:"+index+",size:"+num);
 }
 // Will >index The data of moves forward in turn 1 Bit 
 System.arraycopy(src, index+1, src, index, num-index-1);
 num--;
 // Methods to reduce capacity 
 if(src.length-num>=zengliang){
   // Definition 1 A new array whose length is the length of the original array minus the increment 
     Object arr[] = new Object[src.length-zengliang];
   // Copy array 
     System.arraycopy(src, 0, arr, 0, num);
   src = arr;
 }
 }

Change the data at the specified subscript to the specified data

public void insert(int index,E s){
 // Throw an exception 
 if(index<0 || index>=num){
 throw new IndexOutOfBoundsException(" Subscript out of bounds! index:"+index+",size:"+num);
 }
 // Determine the amount of data in the array num Is it larger than the length (capacity) of the array, and if it exceeds it, it needs to be expanded 
 if(num>=src.length){
   // Definition 1 New array, the length is the original length plus increment 
   Object arr[] = new Object[src.length+zengliang];
   // Copy array data 
   System.arraycopy(src, 0, arr, 0, src.length);
   src = arr;
 }
 // Will >index The data of moves backward in turn 1 Position 
 //arraycopy() You can copy the data to yourself 
 System.arraycopy(src, index, src, index+1, num-index);
 // Insert data 
 src[index] = s;
 num++;
 }

Finally, write an array to get the number of data in the array, not the length of the array

public int size(){
   return num;
 }

Write a test class to test whether this variable-length array is feasible

public class test {
 
 public static void main(String[] args) {
 // Create 1 A MyList Object 
 //  Clarify the type when creating an object 
 MyList<String> list = new MyList<String>();
 
 // Add data 
 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"); 
 
 // Traversing an array 
 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(" The number of data is: "+n);
 System.out.println("**********************************************");
 
 // Modify the data at the specified location 
 list.modify(1, "QQ");
 
 // Traversing an array 
 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(" The number of data is: "+m);
 System.out.println("**********************************************");
 
 // Delete data at a specified location 
 list.delete(2);
 
 // Traversing an array 
 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(" The number of data is: "+k);
 System.out.println("**********************************************");
 
 // Inserts the specified data at the specified location 
 list.insert(3, "zr");
 list.insert(3, "qi");
 
 // Traversing an array 
 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(" The number of data is: "+h);
 System.out.println("**********************************************");
 }
 
}

The result of the final array is:

a b c d e f g h i j 
 The number of data is: 10
**********************************************
a QQ c d e f g h i j 
 The number of data is: 10
**********************************************
a QQ d e f g h i j 
 The number of data is: 9
**********************************************
a QQ d qi zr e f g h i j 
 The number of data is: 11
**********************************************

Add: Create an array of 1 custom length in Java and enter each element

Knowledge points used: array, method, Scanner, for loop.

Homework:

package Array;
import java.util.Scanner;
public class InputArray {
public static void main(String[] args) {
shuzu();// Method invocation  
 }
 // Method definition 
 public static void shuzu() {
 
 // Take the number entered as the length of the array 
 Scanner sz = new Scanner(System.in);
 System.out.println(" Please enter the length of the array :");// Prompt can be operated 
 int[] cd = new int[sz.nextInt()];// Array initialization complete 
 System.out.println(" The current array length is defined as: "+cd.length);// Prompt again 1 Next result 
 
 // Use for Loop for each 1 Element assignment 
 for (int i = 0; i < cd.length; i++) {
  int q = i+1;// Here q Used as a prompt to avoid prompting the 0 Elements. 
  System.out.println(" Please enter the "+q+" The value of the elements: ");
  cd [i] = sz.nextInt();
  System.out.println(" No. 1 "+q+" Elements are defined as "+cd[i]+" . "); 
  }
  sz.close();
  
  // The elements in the array have been assigned, but the for Cyclic traversal 1 Times 
 System.out.print(" All elements in the array are assigned: ");// Continue prompt 1 Under 
 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;// Method ends, rentun ; 
 }
 
}