Your question isn't very clear. From your own answer, I can tell better what you are trying to do:

public static String[] removeElements(String[] input, String deleteMe) {
    List result = new LinkedList();

    for(String item : input)
        if(!deleteMe.equals(item))
            result.add(item);

    return result.toArray(input);
}

NB: This is untested. Error checking is left as an exercise to the reader (I'd throw IllegalArgumentException if either input or deleteMe is null; an empty list on null list input doesn't make sense. Removing null Strings from the array might make sense, but I'll leave that as an exercise too; currently, it will throw an NPE when it tries to call equals on deleteMe if deleteMe is null.)

Choices I made here:

I used a LinkedList. Iteration should be just as fast, and you avoid any resizes, or allocating too big of a list if you end up deleting lots of elements. You could use an ArrayList, and set the initial size to the length of input. It likely wouldn't make much of a difference.

1. I recommend to do the System.out.println in a separate method (or simply use Arrays.toString(..)
2. I recommend to use != instead of !(....=)...)
3. I recommend to return an array with the size matching the new number of entries.

4. even if a.length might be cheap to compute, you should avoid computing the same over and over again in the loop-condition.

   public static int[] sbSample(int a[], int i) {
       // Idea: store the not deleted elements in a temporary array
       // and at the end create on with the fitting size and return it.
       int len = a.length;
       int size = 0;
       int temp[] = new int[len];
       for (int k = 0; k < len; k++) {
           if (a[k] != i) {
               temp[size++] = a[k];
           }
       }
       int[] result = new int[size];
       System.arraycopy(temp, 0, result, 0, size);
       return result;
   }