I think I inartfully expressed what I mean.
I meant it like, the JVM maybe already recognises that there's a variable used in a multithread system. So it's updating it in a way you won't get problems because of the caching (like MESI does on a physical multicore system). But yep, the reordering-problem still exists.

Yep, I have one:

class Clazz extends Runnable
{
   private volatile boolean stop = false;
   
    public void stop()
    {
        stop = true;
    }
 
    @Override
    public void run()
    {
        while( !stop )
        {
            // do Something
        }
    }
}
Why does the variable stop have to be volatile?

Oh, sorry I've misread your code snippet..
Initially I wanted BigIntegers also to save the value, but I think with your method I will just use the given byte-array as it is.

Thank you all for you help!

Thank you, but that wasn't my problem. My problem was to understand why I need to do this logic operationm, but I have a solution to this question now.
It is because normaly byte is signed in Java. If we do such an operation it will be casted to an also signed int and will be interpreted as two's complement. But what we want in this case is an unsigned byte and don't want to lose our byte pattern. To save the byte pattern, we can make the logic operation somebyte & 0xff.
So my mistake was to not consider that we have a signed variable here.

It's correct.

It returns false.
Because we're using an instance of HashSet<> as Set; and this HashSet uses the methods hashCode() and equals() to check if two items given to the Set are equal or not.
Since we haven't implemented an extra hashCode method, it uses the standart hashCode() from Object and there we will get two different codes for those two objects.

// Edit: added the explanation

Example to get true:
   
import java.util.HashSet;
import java.util.Set;
     
public class Name
{
      private final String first, last;
   
      public Name( String first, String last )
      {
            this.first = first;
            this.last = last;
       }
     
        @Override
        public boolean equals( Object o )
        {
              if ( !( o instanceof Name ) )
                      return false;

              Name n = (Name) o;
              return n.first.equals( first ) && n.last.equals( last );
        }
       
        @Override
        public int hashCode()
        {
             return( first.hashCode() + last.hashCode() ); // this isn't a good hashCode method! Don't do it in real but here it works
        }
     
        public static void main( String[] args )
       {
              Set<Name> s = new HashSet<Name>();
               s.add( new Name( "Mickey", "Mouse" ) );
              System.out.println( s.contains( new Name( "Mickey", "Mouse" ) ) );
        }
}