Find the value nearest to k in the sorted array

Are you allowed to use java.util.Arrays.binarySearch ? If you don't need to detect whether or not the array is sorted, this will give you the one or two closest elements quickly.

public static int getClosestK(int[] a, int x) {
    int idx = java.util.Arrays.binarySearch(a, x);
    if ( idx < 0 ) {
        idx = -idx - 1;
    }

    if ( idx == 0 ) { // littler than any
      return a[idx];
    } else if ( idx == a.length ) { // greater than any
      return a[idx - 1];
    }

    return d(x, a[idx - 1]) < d(x, a[idx]) ? a[idx - 1] : a[idx];
}

private static int d(int lhs, int rhs) {
  return Math.abs(lhs - rhs);
}

A minor thing to consider is caching values you lookup, for example, in each step of your while you calculate a.length - 1, since this value does not change you could have create a
int last = a.length - 1; which would make the following fractionally faster and more readable:

        // test upper case <- unfortunate choice of comment ? upper bound perhaps?
        if (mid == last) {
            return a[last];
        }

I would also consider caching a[mid] and a[mid+1] into well named variables.

Finally, this:

if (a.length == 1) {
  return a[0];
}

Belongs in front of the while loop.

Your solution is complex because you are trying to mix at least two different problems in a single algorithm. Sorry my examples are in C++, but I hope you get the algorithmic idea.

Here is what a standard binary search looks like:

/**
 * \brief Find the first non-zero element of an ordered array
 *
 * @param a array to search in
 * @param s offset to start searching from
 *
 * @return offset of the first non-zero element, \e a.size() if none found
 */
template <class A>
size_t binary_search(const A& a, size_t s = 0)
{
    size_t from = s, to = a.size(), mid;
    while (from != to) {
        mid = (from + to) / 2;
        if (a[mid]) to = mid;
        else from = mid + 1;
    }
    return from;
}

If a is in ascending order, you will need to find the position pos of its first element that is greater than x, i.e. substitute

a[mid] > x

for a[mid], where x can be made an additional input parameter:

template <class A, class T>
size_t binary_search(const A& a, const T& x, size_t s = 0)

(in a more generic design, a would really be a customizable function object to be called by a(mid)).

Having found pos:

• if pos == 0 (all elements > x), return 0 (this includes the case of a being empty);
• if pos == a.size() (not found; all elements <= x), return a.size() - 1 (last element);
• otherwise, return one of the two positions pos - 1 and pos depending on which element of a is closer to x.

That is:

template <class A, class T>
size_t find_closest(const A& a, const T& x)
{
    size_t pos = binary_search(a, x);
    return pos == 0 ? 0 :
           pos == a.size() ? a.size() - 1 :
           x - a[pos - 1] < a[pos] - x ? pos - 1 : pos;
}

Note that due to known ordering, you don't need Math.abs. Also note that in case of ambiguities (equalities), this approach returns the rightmost possible position of all equivalent ones.

This is clear, O(log n), and does not mess with Math.abs or anything problem-specific during the critical search process. It separates the two problems.

The function object approach could be

size_t pos = binary_search([&](size_t p){return a[p] > x;});

using a lambda in C++11, and leaving binary_search as originally defined, except for changing a[mid] to a(mid).