ByteArrayOutputStream源代码中的移位操作

ByteArrayOutputStream.Java 的源代码如下所示

package java.io;

import java.util.Arrays;

// Referenced classes of package java.io:
// OutputStream, IOException, UnsupportedEncodingException

public class ByteArrayOutputStream extends OutputStream
{

public ByteArrayOutputStream()
{
this(32);
}

public ByteArrayOutputStream(int i)
{
if(i < 0)
{
throw new IllegalArgumentException((new StringBuilder()).append("Negative initial size: ").append(i).toString());
} else
{
buf = new byte[i];
return;
}
}

private void ensureCapacity(int i)
{
if(i - buf.length > 0)
grow(i);
}

private void grow(int i)
{
int j = buf.length;
int k = j << 1;
if(k - i < 0)
k = i;
if(k < 0)
{
if(i < 0)
throw new OutOfMemoryError();
k = 2147483647;
}
buf = Arrays.copyOf(buf, k);
}

public synchronized void write(int i)
{
ensureCapacity(count + 1);
buf[count] = (byte)i;
count++;
}

public synchronized void write(byte abyte0[], int i, int j)
{
if(i < 0 || i > abyte0.length || j < 0 || (i + j) - abyte0.length > 0)
{
throw new IndexOutOfBoundsException();
} else
{
ensureCapacity(count + j);
System.arraycopy(abyte0, i, buf, count, j);
count += j;
return;
}
}

public synchronized void writeTo(OutputStream outputstream)
throws IOException
{
outputstream.write(buf, 0, count);
}

public synchronized void reset()
{
count = 0;
}

public synchronized byte[] toByteArray()
{
return Arrays.copyOf(buf, count);
}

public synchronized int size()
{
return count;
}

public synchronized String toString()
{
return new String(buf, 0, count);
}

public synchronized String toString(String s)
throws UnsupportedEncodingException
{
return new String(buf, 0, count, s);
}

/**
* @deprecated Method toString is deprecated
*/

public synchronized String toString(int i)
{
return new String(buf, i, 0, count);
}

public void close()
throws IOException
{
}

protected byte buf[];
protected int count;
}

对于方法private void grow(int i) 而言，每次分配的空间是原来的两倍，这个两倍是通过移位操作来实现的。

JAVA移位运算符（转）

移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种：<<（左移）、>>（带符号右移）和>>>（无符号右移）。
　　在移位运算时，byte、short和char类型移位后的结果会变成int类型，对于byte、short、char和int进行移位时，规定实际移动的次数是移动次数和32的余数，也就是移位33次和移位1次得到的结果相同。移动long型的数值时，规定实际移动的次数是移动次数和64的余数，也就是移动66次和移动2次得到的结果相同。
　　三种移位运算符的移动规则和使用如下所示：
　　<<运算规则：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。
　　语法格式：
　　需要移位的数字 << 移位的次数
　　例如： 3 << 2，则是将数字3左移2位
　　计算过程：
　　3 << 2
　　首先把3转换为二进制数字0000 0000 0000 0000 0000 0000 0000 0011，然后把该数字高位（左侧）的两个零移出，其他的数字都朝左平移2位，最后在低位（右侧）的两个空位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 1100，则转换为十进制是12.数学意义：
　　在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。
　　>>运算规则：按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补符号位，即正数补零，负数补1.
　　语法格式：
　　需要移位的数字 >> 移位的次数
　　例如11 >> 2，则是将数字11右移2位
　　计算过程：11的二进制形式为：0000 0000 0000 0000 0000 0000 0000 1011，然后把低位的最后两个数字移出，因为该数字是正数，所以在高位补零。则得到的最终结果是0000 0000 0000 0000 0000 0000 0000 0010.转换为十进制是3.数学意义：右移一位相当于除2，右移n位相当于除以2的n次方。
　　>>>运算规则：按二进制形式把所有的数字向右移动对应巍峨位数，低位移出（舍弃），高位的空位补零。对于正数来说和带符号右移相同，对于负数来说不同。
　　其他结构和>>相似。
　　小结
　　二进制运算符，包括位运算符和移位运算符，使程序员可以在二进制基础上操作数字，可以更有效的进行运算，并且可以以二进制的形式存储和转换数据，是实现网络协议解析以及加密等算法的基础。

移位实验代码如下，

package xman.learning;

import org.junit.Test;

import junit.framework.Assert;

public class JavaShift {

@Test
public void leftShift(){
int value1=12;
value1=value1<<1;
Assert.assertEquals(12*2, value1);

int value2=-12;
value2=value2<<1;
Assert.assertEquals(-12*2, value2);
}

@Test
public void rightShift(){
int value1=-12;
value1=value1>>2;
System.out.println("value1="+value1);
Assert.assertEquals(-12/2/2, value1);

int value2=-12;
value2=value2>>>2;
System.out.println("value2="+value2);
Assert.assertEquals(1073741821, value2);

int value3=12;
value3=value3>>2;
System.out.println("value3="+value3);
Assert.assertEquals(12/2/2, value3);

int value4=12;
value4=value4>>>2;
System.out.println("value4="+value4);
Assert.assertEquals(12/2/2, value4);

}

}