Get int array Werte von INT-Bit Basis 2 Wert

Question

I haben Bitdarstellung wie unten

Bit 0(2^0 .= 1) - 1 
Bit 1(2^1 .= 2) - 2 
Bit 2(2^2 .= 4) - 4 
Bit 3(2^3 .= 8) - 8 
Bit 4(2^4 .= 16) - 16 

Ein Wert von 7 heißt, wir haben 1+2+4. Aber wie bekomme ich dieses Array programmgesteuert?

Answer 1

Stufenlos durch 2 und speichern den Rest

int n = 7; 
StringBuilder sb = new StringBuilder(); 
while(n>0) { 
    sb.append(n%2); 
    n = n/2; 
} 
System.out.println(sb.reverse().toString()); 

Sie können es speichern wie man will. Momentan wird es als String gespeichert (Binäre Darstellung von 7).

Um wieder aus dem String in binären zu konvertieren, beginnen LSB und durch Potenzen von 2 der Bit-Position hinzufügen, wenn der Bit-Wert 1 ist

Answer 2

habe ich unten zu arbeiten, aber für Werte unter 31 auf vorschläge Wie kann man irgendeinen Wert erlauben?

public static void Main(string[] args) 
    { 
     Console.WriteLine(); 
     Console.WriteLine("[{0}]", string.Join(", ", log3(100))); 
    } 

    static int[] log3(int x) { 
     List<int> pow = new List<int>(); 

     int val=x; 

     do{ 
      if(x>= 1 << val){ 
       if(1<<val>0){ 
        pow.Add(1<<val); 
       } 
       x-=1<<val; 
      } 
      val-=1; 
     }while(val>=0); 

     return pow.ToArray(); 
    } 

Answer 3

einfache Logik, arbeitet bis zu IntMax (Sehr einfach nur durch Ändern Typ max lange zu ändern :))

public static void main(String[] args) { 
    int originalInt = 127; 
    toIntegerArray(originalInt); 
} 

private static List<Integer> toIntegerArray(int originalInt) { 
    String bits = Integer.toBinaryString(originalInt); 

    // Reversed, for easier logic when building string 
    StringBuilder s = new StringBuilder(bits).reverse(); 

    char[] bitArray = s.toString().toCharArray(); 

    List<Integer> result = new ArrayList<>(); 
    for (int i = 0; i < bitArray.length; i++) { 
     if (bitArray[i] == '1') { 
      result.add((int) Math.pow(2, i)); 
     } 
    } 

    System.out.println("Original int: " + originalInt); 
    System.out.println("Bit pattern: " + bits); 
    System.out.println(result); 

    return result; 
} 

Answer 4

Hier ist eine rekursive Streaming-Option:

import java.util.List; 
import java.util.stream.Collectors; 
import java.util.stream.IntStream; 

public class Class { 
    private static IntStream intToBinaryParts(final int input, final int count) { 
    int powerOf2 = (int) Math.pow(2, count); 
    if (count < 0) { 
     return IntStream.empty(); 
    } else if (input < powerOf2) { 
     return intToBinaryParts(input, count - 1); 
    } else { 
     return IntStream.concat(intToBinaryParts(input - powerOf2, count - 1), IntStream.of(powerOf2)); 
    } 
    } 

    public static List<Integer> intToBinaryParts(final int input) { 
    return intToBinaryParts(input, (int) Math.ceil(Math.log(input)/Math.log(2))) 
     .mapToObj(Integer::new) 
     .collect(Collectors.toList()); 
    } 

    public static void main(String... args) { 
    System.out.println(intToBinaryParts(7)); 
    System.out.println(intToBinaryParts(8)); 
    System.out.println(intToBinaryParts(100)); 
    System.out.println(intToBinaryParts(1234567890)); 
    } 
}