Array is Balanced Array or Not

An alternative way could be using a map, the average lookup time should be O(1) so this algorithm would be O(n) on average.

public static boolean isBalanced(int[] a) 
{     
    Map<Integer, Integer> map = new HashMap<>();  
    for(int number : a)
    {   
        int key = Math.abs(number);
        Integer value = map.get(key);

        if(value == null)
            map.put(key, number);
        else if (value != number)
            map.put(key, 0);
    }   
    for (int v : map.values())
    {
        if(v != 0) return false;
    }

    return true;
}

A more readable version in java 8 ( Autoboxing and unboxing may hurt the performance a lot thought.)

 public static boolean isBalanced(int[] a) 
 {


       Map<Integer, Integer> map = Arrays.stream(a)
                                         .boxed()
                                         .collect(Collectors.toMap(
                                                 Math::abs,
                                                 Function.identity(),
                                                 (x, y) -> x.equals(y)? x: 0 )
                                         );
        return map.values()
                  .stream()
                  .allMatch(p -> p == 0);
 }

• Your boolean status is outside the loop and will remain true once set to true for any value that is balanced in the array so {2, 3, -2} also returns true from isBalanced since it is already set to true when iterating over the rest of the array for 2
  
• Also you don't need separate if conditions and loops for a[i] > 0 and a[i] < 0. You can use a single inner loop and check a[i] + a[k] == 0
  
• You can also get rid of the if else that checks the status at the end by having loop condition as i < a.length && status

The algorithm may have a square time complexity in the worst case. To make the job faster just sort the array with respect to absolute values; then perform a linear scan for groups of items with equal absolute value and test each group during the scan for the presence of 'minus the first item of a group'.

For example the array {-2, 3, 2, -3} might become {-2, 2, 3, -3}; the scan would then detect a group starting with -2, then find 2 equal -(-2) in this group; and similary item -3 which is 'minus the first item' for the group starting with 3.

On the other hand {-5, 2, -2} will become {2, -2, -5} or {-2, 2, -5} and the second group will fail the test, as it starts with -5 but it doesn't contain 5.

Here's a possible implementation of the scanning loop to detect groups and verify them:

    // ... once the array is sorted with respect to absolute values

    int groupLeader = a[0];
    int groupAbs = Math.abs(groupLeader);
    boolean groupDone = false;

    for(int i = 1; i < a.length; i++) {
        if (Math.abs(a[i]) == groupAbs) { // same group?
            if (a[i] == -groupLeader) {
                groupDone = true;
            }
        } else {                           // a new group
            if (!groupDone)    // test the previous group
                break;         // failed - return the answer

            groupLeader = a[i];    // the new group starts here
            groupAbs = Math.abs(groupLeader);
            groupDone = false;
        }
    }
    // on normal exit of the loop, groupDone contains a status
    // of the last group (and all former groups are OK)

    return groupDone;

May be checking the sum of two values equals to zero may be the better solution for the Balanced array.

public class BalancedArray {

public static void main(String args[]) {
    System.out.println("The result is: " + isBalanced(new int[]{-2, 3, 2, -3}));
}

public static boolean isBalanced(int[] a) {
    boolean status = false;
    for (int i = 0; i < a.length; i++) {
        for(int j = 0; j < a.length; j++) {
            if(a[i] + a[j] == 0) {
                status = true;
                break;
            } else {
                status = false;
            }

        }
        if(!status) {
            status =  false;
            break;
        }

    }

    return status;
}
}

If sum equals zero, break the loop and continue to next increment. Than, check for every status. If status is false, exit the loop and show false.