What two steps are needed to create an array?

Answer 1

For example we have a class :

public class Test()

{

public void print()

{

System.out.println("Hello");

}

}

So, if you want to create array from Test type. You can try something like this :

Test[]myTestArray=new Test[2];

myTestArray[0]=new Test();

myTestArray[1]=new Test();

I hope it will help.

Answer 2

Step 1) Declaration

Step 2) Instantiation

Declaration in Java

int[] array;

Instantiation in Java

array = new int[size];

Declaration and Instantiation in Java

int[] array = new int[size];

Declaration in C

int* array;

Instantiation in C

array = malloc(sizeof(int) * size);

Declaration and Instantiation in C

int array[size];

Answer 3

When you have more than one data-element.

Example: second parameter of function main, called argv, is an array of strings.

When you want to refer to a series of memory locations with same name and access them using an index, we use array

Answer 4

It really depends on which program you write in, if you are writing a program that displays days, and months, you need string arrays.

However, if you write programs that deal with numbers(test marks, prices of products, etc), you will need an int array.

Answer 5

You use an array when all you really need is a sequence of data of the same type. Arrays also offer constant-time random access, making them the ideal container for sorting algorithms. The downside to arrays is that inserting new elements may require the entire array to be re-allocated to new memory. This can be alleviated by allocating more memory than you need. Moreover, inserting anywhere but at the end of the array also requires all elements that follow the insertion point to be right-shifted by one element to make room for the new element. Similarly, when extracting elements, all elements that follow must be left-shifted to remove the gap.

As a rule of thumb, you should consider an array to be the default sequence container unless you have good reason to use another type of container. For instance, if you plan on performing a lot of insertions into the middle of a sequence or at the beginning of a sequence, a linked list might be a better option. Access will be slower due to the need to dereference node pointers and you will lose constant-time random access to all but the head (or tail) of the list. Similarly, if you wish to maintain a sequence in sorted order, a binary tree or ordered map (red/black tree) might be better options.

Note that there is no single container type that is ideally suited to every task and every algorithm you might perform upon a container. Your choice of container is often a compromise between performance and memory consumption but, where there is a choice available, testing is the only way to determine which, if any, is the most appropriate container.

Answer 6

Arrays are declared by stating the type of element the array will hold, which can be an object or a primitive, followed by square brackets to the left or right of the identifier.

Declaring an array of primitives:

int[] Values; // brackets before name (recommended)

int Values []; // brackets after name (legal but less readable)

// spaces between the name and [] legal, but bad

Declaring an array of object references:

Ferrari[] Ferraris; // Recommended

Ferrari Ferraris[]; // Legal but less readable

When declaring an array reference, you should always put the array brackets immediately after the declared type, rather than after the identifier (variable name). That way, anyone reading the code can easily tell that, for example, Values is a reference to an int array object, and not an int primitive.

We can also declare multidimensional arrays, which are in fact arrays of arrays. This can be done in the following manner:

String[][][] occupantName; // recommended

String[] ManagerName []; // Real bad coding practice, but legal

The first example is a three-dimensional array (an array of arrays of arrays) and the second is a two-dimensional array. Notice in the second example we have one square bracket before the variable name and one after. This is perfectly legal to the compiler, but if you write code like this, anyone who is going to manage your code in future is sure going to curse you badly.

It is never legal to include the size of the array in your declaration. Yes, before you ask me, let me admit that you can do that in some other languages, which is exactly why you might see a question or two that include code similar to the following:

int[5] races;

The preceding code won't make it past the Java compiler. Remember, the JVM doesn't allocate space until you actually instantiate the array object. That's when size matters and not when you declare the array variable.

Answer 7

You use an array to efficiently store data sequences with constant-time random-access.