Найти позиции битов, которые точно установлены дважды в нескольких битовых полях

По сравнению с полным pos-popcount, здесь есть ярлык.

Вы можете узнать две вещи:

• какие биты установлены хотя бы дважды
• какие биты установлены минимум 3 раза

Затем вы можете найти биты, которые установлены ровно дважды, как пересечение битов, которые установлены как минимум дважды, с битами, которые не установлены как минимум 3 раза.

int set_a1 = 0;
int set_a2 = 0;
int set_a3 = 0;
for (int i : values) {
    set_a3 |= set_a2 & i;
    set_a2 |= set_a1 & i;
    set_a1 |= i;
}
int set_twice = set_a2 & ~set_a3;

Затем вы можете использовать Integer.numberOfTrailingZeros, чтобы получить позицию первого (начиная с младшего) бита, который был установлен дважды.

Вероятно, вы могли бы использовать Map для ведения счета. Большая часть изложенного ниже — это просто настройка и визуализация. Это именно то getExclusivePairs, что вам нужно:

import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.IntStream;
import java.util.stream.Collectors;

public class BitSets {
    public static void main(String[] args) {
        int[] bitSets = new int[9];
        final int MASK = 0b1_1111_1111;
        ThreadLocalRandom rand = ThreadLocalRandom.current();
        IntStream.range(0, bitSets.length).forEach(ix -> bitSets[ix] = rand.nextInt() & MASK);
        System.out.println("  8 7654 3210");
        System.out.println("-------------");
        for (int j = 0; j < bitSets.length; j++) {
            System.out.printf("%d %s%n", j, StringUtils.toBinaryStringGrouped(bitSets[j]).substring(28));
        }

        Map<Integer, List<Integer>> found = getExclusivePairs(bitSets); 
        found.entrySet().
            stream().forEach(e -> System.out.printf("Bit %d is set exactly twice in the following bitsets: %s%n", e.getKey(), e.getValue()));
    }

    private static Map<Integer, List<Integer>> getExclusivePairs(int[] bitSets) {
        Map<Integer, List<Integer>> counter = new HashMap<>();
        for(int ixBitset = 0;ixBitset < bitSets.length;ixBitset++) {  
            for(int ixBit = 0;ixBit < bitSets.length;ixBit++) {  
                boolean isSet = (bitSets[ixBitset] & (1 << ixBit)) > 0;
                if (isSet) {
                    counter.computeIfAbsent(ixBit, k -> new ArrayList<Integer>()).add(ixBitset);
                }
            }
        }
        return counter.entrySet().stream().filter(e -> e.getValue().size() == 2).collect(Collectors.toMap(Map.Entry::getKey,
                    Map.Entry::getValue));
    }
    private static class StringUtils {
        public static String toBinaryStringGrouped(int n) {
            return StringUtils.grouped(StringUtils.toBinaryString(n));
        }

        private static String grouped(String s) {
            StringBuilder sb = new StringBuilder(s);
            for (int i = sb.length() - 4; i >= 4; i -= 4) {
                sb.insert(i, '_');
            }
            return sb.toString();
        }

        public static String toBinaryString(int n) {
            StringBuilder sb = new StringBuilder("00000000000000000000000000000000");
            for (int bit = 0; bit < 32; bit++) {
                if (((n >> bit) & 1) > 0) {
                    sb.setCharAt(31 - bit, '1');
                }
            }
            return sb.toString();
        }
    }
}

Значения бит переменной b суммируются в переменной sum, но перенос после сложения не добавляется к старшему биту, а суммируется в переменной sumCarry.

Таким же образом мы можем далее суммировать переносы в других переменных, но нам достаточно зафиксировать лишь факт наличия очередного переноса в переменной anyCarry.

var sum = 0;
var sumCarry = 0;
var anyCarry = 0;

for (var b : values) {
    var c = sum & b;
    sum ^= b;
    anyCarry |= sumCarry & c;
    sumCarry ^= c;
}

var setTwice = ~sum & sumCarry & ~anyCarry;