java array exact length

I set an array of integer like below

int[] a = new int[11111];
 //if I set
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;

I want a method such that it gives me 4 but 11111. Is there any method w开发者_如何学运维hich I can use?

You should look into using an ArrayList

ArrayList<Integer> myList=new ArrayList<Integer>();
myList.add(1);
myList.add(2);
myList.add(3);

System.out.println("Size:"+myList.size());

Well, the following method will do what you asked for:

public int m() {
    return 4;
}

On the assumption that you want a method that takes an array, and returns the greatest index that has been populated - you're right that the a.length only tells you the size of the array, i.e. the number of cells allocated.

This is going to be harder than you might expect, especially with an int array. Those unassigned cells are initialised to a value of 0. If you might actually use zero values in your array, then there is absolutely no way to tell whether the value in a cell is the "default" zero or one that you've set yourself.

If the array can't have zero values in it, then you'd need to loop over its entire length, checking for the highest index with a corresponding non-zero value; something like this:

public int dynamicLength(int[] a) {
   int max = -1;
   for (i = 0; i < a.length; i++) {
       if (a[i] != 0) max = i;
   }
   return max;
}

Even then this might not be ideal, since arrays can be sparsely populated. Do you want the count of assigned indices, or the index of the highest assigned index?

The short answer is almost certainly "use an ArrayList".

When you do

int[] a = new int[11111]

It creates an array with 11111 elements and as it is int it will assign it to default value that is 0 so you have array with all values set.

You should move to List

You should use an ArrayList if the size of the array is changing. There is little performance difference.

See here for how to use one. See here for the API also.

I understand that you only want the assigned elements to be counted but it would be safer at runtime and simpler to use an ArrayList. The ArrayList class just wraps a Java array and handles the changing size for you. You can get the size by calling the size() method on the ArrayList.

See this example using a for-each loop if you want to iterate over the elements:

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1); //size is 1
list.add(2); //size is 2
list.add(3); //size is 3
list.add(4); //size is 4

for(Integer n : list)
    System.out.println(n);

An ArrayList uses an iterator and the for-each loop uses it to iterate over the ArrayList. Makes life much simpler.

As suggested above, using a List is probably the right answer. However, in the interest of solving the original problem, you could try this instead:

Integer[] foo = new Integer[11111];
foo[0] = new Integer(1);
foo[1] = new Integer(2);
foo[2] = new Integer(3);
foo[3] = new Integer(4);

and create a method that counts non-null values:

public static int countItems(Integer[] array) {
  int count = 0;

  for (Integer i : array) {
    if (i != null) {
      count++;
    }
  }

  return count;
}

Of course, this will be a pain to manage as you would need to nullify any items no longer needed. It also raises the question of whether you would accept "holes" in your array, e.g. null values amongst non-null values. My example counting function above would accept such holes.

So, yes. Use a List.

You can create a method which calculates the non-0 elements of the array using a for/while loop.