jdk/src/share/classes/java/lang/Byte.java
changeset 11672 a5fa8c844b54
parent 11275 7cb0861d512f
child 11676 7e75ec031b97
equal deleted inserted replaced
11671:60fdf1412864 11672:a5fa8c844b54
     1 /*
     1 /*
     2  * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.  Oracle designates this
     7  * published by the Free Software Foundation.  Oracle designates this
   444     public static int compare(byte x, byte y) {
   444     public static int compare(byte x, byte y) {
   445         return x - y;
   445         return x - y;
   446     }
   446     }
   447 
   447 
   448     /**
   448     /**
       
   449      * Converts the argument to an {@code int} by an unsigned
       
   450      * conversion.  In an unsigned conversion to an {@code int}, the
       
   451      * high-order 24 bits of the {@code int} are zero and the
       
   452      * low-order 8 bits are equal to the bits of the {@code byte} argument.
       
   453      *
       
   454      * Consequently, zero and positive {@code byte} values are mapped
       
   455      * to a numerically equal {@code int} value and negative {@code
       
   456      * byte} values are mapped to an {@code int} value equal to the
       
   457      * input plus 2<sup>8</sup>.
       
   458      *
       
   459      * @param  x the value to convert to an unsigned {@code int}
       
   460      * @return the argument converted to {@code int} by an unsigned
       
   461      *         conversion
       
   462      * @since 1.8
       
   463      */
       
   464     public static int toUnsignedInt(byte x) {
       
   465         return ((int) x) & 0xff;
       
   466     }
       
   467 
       
   468     /**
       
   469      * Converts the argument to a {@code long} by an unsigned
       
   470      * conversion.  In an unsigned conversion to a {@code long}, the
       
   471      * high-order 56 bits of the {@code long} are zero and the
       
   472      * low-order 8 bits are equal to the bits of the {@code byte} argument.
       
   473      *
       
   474      * Consequently, zero and positive {@code byte} values are mapped
       
   475      * to a numerically equal {@code long} value and negative {@code
       
   476      * byte} values are mapped to a {@code long} value equal to the
       
   477      * input plus 2<sup>8</sup>.
       
   478      *
       
   479      * @param  x the value to convert to an unsigned {@code long}
       
   480      * @return the argument converted to {@code long} by an unsigned
       
   481      *         conversion
       
   482      * @since 1.8
       
   483      */
       
   484     public static long toUnsignedLong(byte x) {
       
   485         return ((long) x) & 0xffL;
       
   486     }
       
   487 
       
   488 
       
   489     /**
   449      * The number of bits used to represent a {@code byte} value in two's
   490      * The number of bits used to represent a {@code byte} value in two's
   450      * complement binary form.
   491      * complement binary form.
   451      *
   492      *
   452      * @since 1.5
   493      * @since 1.5
   453      */
   494      */