求达人解代码

Question

//该函数主要实现截屏功能，但我想知道其实现的原理以及步骤。
//RobotPeer和ComponentFactory是什么类呢？为什么在文档中查不到它的使用方法？
private static int[] createScreenCapture(Rectangle screenRect) 
    {
        try
        {
            if (peer == null)
            {
                try
                {
                    Toolkit toolkit = Toolkit.getDefaultToolkit();
                    if (toolkit instanceof ComponentFactory)
                    {
                        peer = ((ComponentFactory) toolkit).createRobot(new Robot(),
                                GraphicsEnvironment
                                        .getLocalGraphicsEnvironment()
                                        .getDefaultScreenDevice());
                    }
                }
                catch (Exception e)
                {
                }
            }
            return  peer != null ? peer.getRGBPixels(screenRect) : null;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }
    
//想知道这段方法实现的是什么功能？
    private int[] proMinPixels(int[] newPixel, int[] oldPixel, int width, int height)
    {
        if (oldPixel == null || newPixel.length != oldPixel.length)
        {
            realNum = newPixel.length + HEADER_LEN;
            buffer = new int[realNum];
            buffer[0] = width;
            buffer[1] = height;
            buffer[4] = width;
            buffer[5] = height;
            System.arraycopy(newPixel, 0, buffer, HEADER_LEN, newPixel.length);
            return buffer;
        }
        int len = newPixel.length;
        int minX = Integer.MAX_VALUE;
        int minY = Integer.MAX_VALUE;
        int maxX = 0;
        int maxY = 0;
        for (int i = 0; i < len; i++)
        {
            if (newPixel[i] != oldPixel[i])
            {
                int x = i % width;
                int y = i / width;
                if (x < minX)
                {
                    minX = x;
                }
                if (x > maxX)
                {
                    maxX = x;
                }
                if (y < minY)
                {
                    minY = y;
                }
                if (y > maxY)
                {
                    maxY = y;
                }
            }
        }
        if (minX == Integer.MAX_VALUE)
        {
            return null;
        }
        int resultWidth = maxX - minX + 1;
        int resultHeight = maxY - minY + 1;
        
        realNum = resultWidth * resultHeight + HEADER_LEN;
        if (buffer.length < realNum)
        {
            buffer = new int[realNum];
        }
        
        buffer[0] = width;
        buffer[1] = height;
        buffer[2] = minX;
        buffer[3] = minY;
        buffer[4] = maxX + 1;
        buffer[5] = maxY + 1;
        int resultIndex = HEADER_LEN;
        for (int i = 0; i < resultHeight; i++)
        {
            System.arraycopy(newPixel, (minY + i) * width + minX, buffer, resultIndex, resultWidth);
            resultIndex += resultWidth;
        }
        return buffer;
    }
    
    /**
     * 压缩数据
     * @param data 需要压缩的数据
     * @param x 这块数据的X坐标
     * @param y 这块数据的Y坐标
     * @param width 这块数据的宽度
     * @param height 这快数据的高度
     * @return 开头是x, y, width, height的压缩数据
     */
//该函数实现数据的压缩，但我想知道其实现的原理
    private int[] compressData(int[] data)
    {
        if (data == null)
        {
            return null;
        }
        int compressIndex = HEADER_LEN;
        int i = HEADER_LEN; 
        while (i < realNum)
        {
            int j = i;
            int p = data[i];
            while (++i < realNum && p == data[i]);
            j = i - j;
            if (j > 1)
            {
                buffer[compressIndex++] = j;
            }
            buffer[compressIndex++] = p;
        }
        
        if (compressIndex < buffer.length)
        {
            int[] temp = new int[compressIndex];
            System.arraycopy(buffer, 0, temp, 0, compressIndex);
            return temp;
        }
        return buffer;
    }
    
    
    private void writeImage(ObjectOutputStream output, int[] data) throws Exception
    {
        if (data == null)
        {
            return;
        }
        output.writeObject(data);
        output.flush();
        output.reset();
    }
    
    
    private static int[] tempTest; 
    private int realNum;
    private int[] buffer;
    private static final int HEADER_LEN = 6;
    private int[] oldPixels;
    private ObjectOutputStream output;
    private Socket socket;
    private static RobotPeer peer;
    private BufferedImage image;
}
以上代码是从网上下载的，但不能很好的理解其中的原理以及步骤，在线等达人解！非常感谢！