Finding all the subsets in an array of integers that sum to a given target

Violations of general good practices

• Using String.substring to extract single characters is odd. Use String.charAt instead next time
• Parsing single character strings using Integer.parseInt is odd. Use String.charAt(index) - '0' instead
• allSubsets should be declared as Set instead of HashSet (use interface types instead of implementations)
• Method names should be camelCase
• No need to write JavaDoc for private methods, simple comments are good enough, if needed at all

Strange way to collect integers

The way you collect integers in a String is strange in many ways:

• The program will not work for numbers > 9
• Appending digits to a string one by one, and then finally parsing them from the string one by one is strange.

You could use a Set instead. Sure, maybe it seems a bit strange and inefficient to clone the set in each recursive call, but I still think it would be better. It would also solve the problem you found, with the duplicate sequences in the results. Probably there is an even better way, but I have no more time now.

Strange static and non-static variables

allSubsets is static, but input and target are not. It would make more sense to either make all of these static, or none of them.

Not suggested implementation

I can't say I suggest this implementation, but it solves some issues with yours:

private void find(int[] input, int target, Set<Integer> ramp, int index) {
    if (index > input.length - 1) {
        if (getSum(ramp) == target) {
            allSubsets.add(toString(ramp));
        }
        return;
    }

    find(input, target, updatedSet(ramp, input[index]), index + 1);
    find(input, target, ramp, index + 1);
}

private Set<Integer> updatedSet(Set<Integer> ramp, int integer) {
    Set<Integer> updated = new HashSet<Integer>();
    updated.addAll(ramp);
    updated.add(integer);
    return updated;
}

private String toString(Set<Integer> ramp) {
    StringBuilder builder = new StringBuilder();
    for (Integer integer : ramp) {
        builder.append(integer);
    }
    return builder.toString();
}

private static int getSum(Set<Integer> integers) {
    int sum = 0;
    for (Integer integer : integers) {
        sum += integer;
    }
    return sum;
}

@janos has covered a bunch of my concerns, except the algorithm you use.

I like the recursion, it makes sense, but I would make it a whole lot more efficient by doing two things....

1. sort the data first
2. recurse applying large values first, using binary searches as you go, if needed.

This way you can reduce the number of values in the set as you get close to the end.

Taking on most of the advice from janos, and applying the above, I would get something like:

private static Collection<int[]> findTargetSubSets(int[] n, int target) {
    int[] data = IntStream.of(n).sorted().toArray();
    List<int[]> results = new ArrayList<>();
    int[] partial = new int[data.length];
    recurseFor(data, data.length, partial, 0, target, results);
    return results;
}

private static void recurseFor(final int[] data, final int limit, final int[] partial, 
        final int psize, final int target, final List<int[]> results) {
    if (target == 0) {
        // found exact match.
        results.add(Arrays.copyOf(partial, psize));
        return;
    }
    if (limit == 0 || target < 0) {
        return;
    }
    int pos = Arrays.binarySearch(data, 0, limit, target);
    if (pos < 0) {
        pos = -pos - 1;
        pos--;
    }
    for (int i = 0; i <= pos; i++) {
        partial[psize] = data[i];
        recurseFor(data, i, partial, psize + 1, target - data[i], results);
    }

}