How to add index to array in Ada, like append for array in Java?

You can use Vectors to do the something similar using the & operator. You can access the individual elements just like an array, though you use () instead of []. Or you can just use a for loop and get the element directly.

See the below example:

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Vectors;

procedure jdoodle is

    -- Create the package for a vector of integers
    package Integer_Vectors is new Ada.Containers.Vectors(Positive,Integer);
    
    -- Using subtype to make just the Vector type visible
    subtype Vector is Integer_Vectors.Vector;
    
    -- Make all the primitive operations of Vector visible
    use all type Vector;
    
    -- Create a variable
    V : Vector;
begin
    
    -- Add an element to the vector in each iteration
    for i in 1..10 loop
        V := V & i;
    end loop;
    
    -- Show the results
    for Element of V loop
        Put_Line(Element'Image);
    end loop;

    -- Print the 2nd element of the array
    Put_Line(Integer'Image(V(2)));
    
end jdoodle;

Ada arrays are first class types, even when the array type is anonymous. Thus a 2-dimensional array is a different type than a 3-dimensional array. Furthermore, arrays are not defined by directly specifying the number of elements in a dimension as they are in languages derived from C.

For instance, if you define a 2-dimensional array such as

type array_2d is array (Integer range 0..1, Integer range 1..2);

You have defined an array with a first range of 0..1 and a second range of 1..2. This would be a square matrix containing 4 elements.

You cannot simply add another dimension to an object of the type array_2d described above. Such an array must be of a different type.

Furthermore, one cannot change the definition of an array object after it is created.

Ok, so while this is a simple question it gets into the interesting details of design very quickly. The first thing is that an array "always knows its bounds" -- this language design element impacts the usage of the language profoundly: instead of having to pass the length of the array as a parameter, and possibly going out-of-sync, like in C you simply pass the array and let the "it knows its bounds" take care of the management.

Second, the Array is always static-length, meaning it cannot be changed once created. Caveat: Creating an array can be done in a "dynamic" setting, like querying user-input.

Third, if the subtype is unconstrained than it can have "variable" length. -- This means that you can have something like Type Integer_Vector is Array(Positive Range <>) of Integer and have parameters that operate on any size value passed in (and return-values that can be any size). This, in turn, means that your handling of such subtypes tends itself toward the more general.

Fourth, all of these apply and combine so that a lot of the 'need' for dynamically sized arrays aren't needed -- yes, there are cases where it is needed, or where it is more convenient to have a single adjustable object; this is what Ada.Containers.Vectors addresses -- but in the absence of needing a truly dynamically-sizing object you can use processing for achieving your goals.

Consider the following example:

Type Integer_Vector is Array(Positive range <>) of Integer;
Function Append( Input : Integer_Vector; Element : Integer ) return Integer_Vector is
  ( Input & Element );

X : Constant Integer_Vector:= (1,2);
Y : Integer_Vector renames Append(X, 3);

These three design choices combine to allow some intere