Dynamic arrays vs Variable-length arrays - arrays

Question

What is the differences between Dynamic Arrays and Variable-length Arrays?
There are two separate sheets in Wikipedia about this:
1) Regarding Dynamic arrays:
https://en.wikipedia.org/wiki/Dynamic_array
2) Regarding Variable-length Arrays:
https://en.wikipedia.org/wiki/Variable-length_array
But it is not very clear the differences.
Could you give an example in some programming language the Dynamic Array which is not Variable-length one and vice versa.

Answer 1

There are four kind of arrays:
1) Dynamic Arrays
2) Variable-length Arrays
3) Fixed-length Array
4) Static array
Let's consider the four arrays in more details.
1) Dynamic array
In this case there is an API in array which alter length variable.
It can be a method that directly modifies the length
setSize(int newLength)
or a methods that modify it indirrectly:
add(Object newElement)
remove(Object toBeRemoved)
Both of these methods modify the length after adding/removing an element.
Example in Java that emulates Dynamic array:
java.util.ArrayList
2) Variable-length array
Variable-length array is a special case of Dynamic array.
In this case length is read-only and there is no API in array which modifies this variable.
But this variable can be changed by the system the other ways.
Example in Java that emulates Variable-length array - regular java arrays like int[].
Lets consider the example:
int[] a = new int[5]; System.out.println(a.length);
a = new int[10]; System.out.println(a.length);
In this case length variable is changed but we cannot modify it directly like
a.length = 20;
3) Fixed-length array
Fixed-length array is a special case of Variable-length array.
In this case once assigned a value to the length, we cannot modify it anymore.
But it is important to note that length variable is still determined at runtime
Example in Java that emulates this behaviour: final array variables like final int[].
Lets consider the example:
final int[] a;
if (someVar > 0) { a = new int[100]; } else { a = new int[200]; }
In this case a.length is either 100 or 200 and still determined at runtime.
4) Static array
Static array is a special case of Fixed-length array.
In this case length not only can be changed but also can be determined at runtime.
Example of such array in Java can be the following construction:
{1, 2, 3, 100, 200, 500}
This constuction can be assigned to a variable only while its initialization
int[] a = {1, 2, 3};
But if we try reassignment like
a = {1, 2};
we get compilation error.
Example in Java that emulates such an array:
final int[] a = {1, 2, 3};

Answer 2

Variable-length arrays have variable sizes that are set once during runtime.
Dynamic arrays are also variable length arrays, but they can also re-size (re-dimension) after they are created. This allows the array to grow to accommodate additional elements above its original capacity. If using an array, you would have to manually resize the array or overwrite existing data.
For example in C#, arrays (like int[]) are variable-length arrays. Lists (like List<int> or ArrayList) are a dynamically re-sizing arrays. A list hides some of the re-sizing in its .Add() method so the developer doesn't have to worry about it on their own.