Java - Bit Manipulation étrange

Question

par intérim J'ai actuellement la fonction simple

public static void convert() { 
    for (int i = 0; i < byteArray.length; i++) { 
     byteArray[i] = (byte) (byteArray[i] & ~(1 << 0)); 

     String s = ("0000000" + Integer.toBinaryString(0xFF & byteArray[i])).replaceAll(".*(.{8})$", "$1"); 
     System.out.println(s); 
    } 
} 

par étapes qui un tableau d'octets et modifie chacun des bits. Ce produit les éléments suivants:

11110110 
11000010 
11111010 

Là où ça devient étrange est cependant quand j'ajoute simple instruction if (cela ne change rien) autour des lignes dans la fonction, la sortie change complètement. Par exemple, si je change la fonction ci-dessus pour

public static void convert() { 
    for (int i = 0; i < byteArray.length; i++) { 

     if (5 > 3) { 
     byteArray[i] = (byte) (byteArray[i] & ~(1 << 0)); 

     String s = ("0000000" + Integer.toBinaryString(0xFF & byteArray[i])).replaceAll(".*(.{8})$", "$1"); 
     System.out.println(s); 
     } 
    } 
} 

il produit les éléments suivants à la place:

10100110 
00011000 
00010100 

Je suis vraiment confus pour expliquer pourquoi ce qui se passe. Merci.

La classe entière juste pour la référence:

public class LIB { 
static byte[] byteArray; 
static ArrayList<String> bitArray = new ArrayList<String>(); 
static String messageToDecode = "001010110"; 
static char[] mtdChar = messageToDecode.toCharArray(); 
static ArrayList<String> FinalBitArray = new ArrayList<String>(); 

public static void main(String[] args) throws IOException { 
    // TODO Auto-generated method stub 
    imageToBits(); 
    convert(); 

} 

public static void imageToBits() throws IOException { 
    //get image bytes 
    byteArray = Files.readAllBytes(new File("/Users/2020shatgiskessell/Desktop/url.jpg").toPath()); 
    for (int i = 0; i < byteArray.length; i++) { 

     String s = ("0000000" + Integer.toBinaryString(0xFF & byteArray[i])).replaceAll(".*(.{8})$", "$1"); 
     bitArray.add(s); 

    } 
} 


public static void convert() { 
    for (int i = 0; i < byteArray.length; i++) { 

     if (5 > 3) { 
     byteArray[i] = (byte) (byteArray[i] & ~(1 << 0)); 

     String s = ("0000000" + Integer.toBinaryString(0xFF & byteArray[i])).replaceAll(".*(.{8})$", "$1"); 
     System.out.println(s); 
     } 
    } 
} 

Answer 1

Je commence à me demander au sujet de plaisanterie le jour du poisson d'Avril qui @LittleSanti mentionné. Si c'est le cas, c'est méchant.

J'ai écrit ce qui suit: J'ai éliminé l'assignation dans le tableau source, et j'ai mis la condition 'comportement étrange' dans la boucle au lieu de faire deux passages séparés pour que nous puissions voir les résultats plus facilement. Il n'y a pas un tel comportement étrange dans les expressions (certes étranges) que vous avez ici.

package bitplay; 

import java.io.File; 
import java.io.IOException; 
import java.nio.file.Files; 
import java.util.ArrayList; 

public class Bitplay 
{ 
// public class LIB { 
    static byte[] byteArray; 
    static ArrayList<String> bitArray = new ArrayList<String>(); 
    static String messageToDecode = "001010110"; 
    static char[] mtdChar = messageToDecode.toCharArray(); 
    static ArrayList<String> FinalBitArray = new ArrayList<String>(); 

    public static void main(String[] args) throws IOException { 
     fakeRoutine(); 
    } 

    private static void fakeRoutine() 
    { 
     byte[] array = new byte[] { (byte)0b11110111, 
            (byte)0b11000011, 
            (byte)0b11111010 
           }; 
     for (int i=0; i<3; i++) 
     { 
     String s = ("0000000" + Integer.toBinaryString(0xFF & array[i])).replaceAll(".*(.{8})$", "$1"); 
     System.out.println("1: " + s); 

     byte clearedOne = (byte) (array[i] & ~(1 << 0)); 
     s = ("0000000" + Integer.toBinaryString(0xFF & clearedOne)).replaceAll(".*(.{8})$", "$1"); 
     System.out.println("2: " + s); 

     if (5 > 3) 
     { 
      clearedOne = (byte) (array[i] & ~(1 << 0)); 
      s = ("0000000" + Integer.toBinaryString(0xFF & clearedOne)).replaceAll(".*(.{8})$", "$1"); 
      System.out.println("3: " + s); 
     } 
     } 

    } 
} 

absence de toute modification simultanée du tableau quelque part ailleurs, la seule explication qui me vient à l'esprit la différence de sortie est une différence dans l'entrée, et je ne peux pas vous aider.

La sortie que je reçois de ce qui précède est:

1: 11110111 
2: 11110110 
3: 11110110 
1: 11000011 
2: 11000010 
3: 11000010 
1: 11111010 
2: 11111010 
3: 11111010 

comme prévu. Si jamais vous posez une question plus précise, allez-y et posez la, mais j'en ai fini avec cette question.