新人菜菜的问题,大家请进。

下了本手机小说，里面有个类如下：
public class Book
{
    private String file;
    private String name;
    private int length;
    private Stack stkPages; ////////////////////////////这个变量是做什么的？
    private final int STACK_SIZE = 7;
    private Vector vctCache;////////////////////////////这个变量是做什么的？
    private final int CACHE_SIZE = 5;
    private DataInputStream disBook;
    private int currentStreamPosition;
    private Page currentPage;
    private boolean bEof;
    private int pageMaxBytes;
    private int pageRows;
    private int pageCols;

    public Book(BookItem bookitem)
    {
        file = bookitem.file;
        name = bookitem.name;
        length = bookitem.length;
        disBook = null;
        bEof = false;
        currentStreamPosition = 0;
        currentPage = null;
        stkPages = new Stack();
        stkPages.ensureCapacity(8);
        vctCache = new Vector();
        vctCache.ensureCapacity(6);
        pageMaxBytes = 10;
        pageRows = 1;
        pageCols = 10;
    }
    .......
}
请问这个类是做什么的，还有上面注释的2个变量是做什么的？

15 个解决方案

#1

public boolean open()
    {
        try
        {
            refreshStream();
        }
        catch(IOException ioexception)
        {
            return false;
        }
        stkPages.removeAllElements();////////////////这里
        vctCache.removeAllElements();////////////还有这里
        currentPage = new Page();
        currentPage.position = 0;
        currentPage.length = 0;
        currentPage.text = Language.getString(1);
        return disBook != null;
    }
这也是其中的一个方法,请问注释的2行完成了什么功能？

#2

Vector和Stack都是一种数据结构。在java.util包中可以找到，其中Stack又是Vector的子类，而Vector直接继承于Object。

不知道你可用过J2SE中的ArrayList，Vector和ArrayList类似。唯一不同的是Vector是线程安全的（你可以翻编译一下JDK中的包，可以看到Vector中的一些写方法都带有synchronized的同步关键字）

这两个类的用途你可以试想成他们是一个容器。就比如说你家的垃圾桶，你可以放任和东西到里面去。对于Vector来说，这个垃圾桶会把你放进去的东西都编个号(1,2,3...)，有天你要从里面拿东西出来的时候，可以按照编号把曾经放进去的东西取出来。其实Vector内部就是一个Object[]对象来保存东西的，不过他可以自动的调节这个数组的大小，当这个数组满了他会自动地去增大它。vctCache.removeAllElements();这个函数用来清空Vector中保存的所有对象。

吃饭，Stack稍后分解... ...

#3

呵呵，谢谢哟。我等你来。

#4

Yeah，I am come back...
补充一下：Vector的线程安全。你可以这么理解，Vector这个垃圾箱有两个口，一个用来放东西，一个用来拿东西，放东西的那个口同时只能容纳一只手，所以放东西的时候一次只能一个人放，其他人必须等这个人放完了才能放。而拿东西的那个口很大，好多人可以同时从里面拿东西。

下面说Stack,这个偶也没用过，刚才查了一下帮助文档。其实看名字就可以知道Stack类似于一个栈，所以采用后进先出（LIFO）原则。举个例子，如果你买过一桶羽毛球应该知道装羽毛球的那个桶吧，你从桶里面拿出来的羽毛球一定是最后一个被放进去的。vctCache.removeAllElements();这句话也是清空Stack中的所有元素。

#5

嘿嘿，，我也学习一下！！

#6

to luckycat(潘鑫):
sorry,来晚了，你应该见过这个类吧？
Stack和Vector在这个类当中起什么作用？

#7

在你给的这两段代码上，这两个类都没有什么作用，因为没有放置任何值到这两个实例中，你看看代码的其他地方是不是用到了

#8

import java.io.*;
import java.util.Stack;
import java.util.Vector;

public class Book
{
    private String file;
    private String name;
    private int length;
    private Stack stkPages;
    private final int STACK_SIZE = 7;
    private Vector vctCache;
    private final int CACHE_SIZE = 5;
    private DataInputStream disBook;
    private int currentStreamPosition;
    private Page currentPage;
    private boolean bEof;
    private int pageMaxBytes;
    private int pageRows;
    private int pageCols;

    public Book(BookItem bookitem)
    {
        file = bookitem.file;
        name = bookitem.name;
        length = bookitem.length;
        disBook = null;
        bEof = false;
        currentStreamPosition = 0;
        currentPage = null;
        stkPages = new Stack();
        stkPages.ensureCapacity(8);
        vctCache = new Vector();
        vctCache.ensureCapacity(6);
        pageMaxBytes = 10;
        pageRows = 1;
        pageCols = 10;
    }

    public void setPageParameters(int i, int j, int k)
    {
        pageRows = i;
        pageCols = j;
        pageMaxBytes = k;
    }

    public String file()
    {
        return file;
    }

    public String name()
    {
        return name;
    }

    public int length()
    {
        return length;
    }

    public int currentPosition()
    {
        return currentPage.position;
    }

    public boolean opened()
    {
        return disBook != null;
    }

    public boolean eof()
    {
        return bEof;
    }

    public Page getNextPage()
    {
        try
        {
            Page page = getCachedPageAt(currentPage.position + currentPage.length);
            if(currentPage != null && currentPage.text.length() > Language.getString(15).length())
            {
                stkPages.push(new Integer(currentPage.position));
                for(; stkPages.size() > 7; stkPages.removeElementAt(0));
            }
            currentPage = page;
            return page;
        }
        catch(IOException ioexception)
        {
            return null;
        }
    }

    public Page getPrevPage()
    {
        int i;
        if(!stkPages.empty())
        {
            i = ((Integer)stkPages.pop()).intValue();
        } else
        {
            i = currentPage.position - ((pageRows * pageCols) / 2) * 2;
            if(i < 0)
                i = 0;
        }
        try
        {
            currentPage = getCachedPageAt(i);
            return currentPage;
        }
        catch(IOException ioexception)
        {
            return null;
        }
    }

    public Page getPageAt(int i)
    {
        if(i < 0)
            i = 0;
        else
        if(i >= length)
            i = length - 2;
        i >>= 1;
        i <<= 1;
        stkPages.removeAllElements();
        try
        {
            currentPage = getCachedPageAt(i);
            return currentPage;
        }
        catch(IOException ioexception)
        {
            return null;
        }
    }

    private Page getCachedPageAt(int i)
        throws IOException
    {
        Page page = findPageInCache(i);
        if(page != null)
            return page;
        if(disBook == null)
        {
            refreshStream();
            skipBytes(i);
        } else
        if(i != currentStreamPosition)
            if(i > currentStreamPosition)
            {
                skipBytes(i - currentStreamPosition);
            } else
            {
                refreshStream();
                skipBytes(i);
            }
        page = readPageFromStream();
        savePageToCache(page);
        return page;
    }

#9

private Page findPageInCache(int i)
    {
        boolean flag = false;
        Page page = null;
        for(int j = 0; j < vctCache.size(); j++)
        {
            page = (Page)vctCache.elementAt(j);
            if(page.position != i)
                continue;
            flag = true;
            break;
        }

        if(flag)
            return page.copy();
        else
            return null;
    }

    private void savePageToCache(Page page)
    {
        if(vctCache.size() >= 5)
        {
            int i = findIndexAfterPositon(currentStreamPosition);
            if(i < 0)
            {
                i = findIndexMinPosition();
                if(i >= 0)
                    vctCache.removeElementAt(i);
            } else
            {
                vctCache.removeElementAt(i);
            }
        }
        vctCache.addElement(page.copy());
    }

    private int findIndexMinPosition()
    {
        int i = -1;
        int j = 0x7fffffff;
        for(int k = 0; k < vctCache.size(); k++)
        {
            Page page = (Page)vctCache.elementAt(k);
            if(page.position < j)
            {
                j = page.position;
                i = k;
            }
        }
        return i;
    }

    private int findIndexAfterPositon(int i)
    {
        int j = -1;
        int k = 0x7fffffff;
        for(int l = 0; l < vctCache.size(); l++)
        {
            Page page = (Page)vctCache.elementAt(l);
            if(page.position > i && page.position < k)
            {
                k = page.position;
                j = l;
            }
        }
        return j;
    }

    public boolean open()
    {
        try
        {
            refreshStream();
        }
        catch(IOException ioexception)
        {
            return false;
        }
        stkPages.removeAllElements();
        vctCache.removeAllElements();
        currentPage = new Page();
        currentPage.position = 0;
        currentPage.length = 0;
        currentPage.text = Language.getString(1);
        return disBook != null;
    }

    private void refreshStream()
        throws IOException
    {
        if(disBook != null)
            disBook.close();
        InputStream inputstream = getClass().getResourceAsStream(file);
        if(inputstream == null)
            disBook = null;
        else
            disBook = new DataInputStream(inputstream);
        bEof = false;
        currentStreamPosition = 0;
    }

    private void skipBytes(int i)
        throws IOException
    {
        int l;
        for(int j = i; j > 0; j -= l)
        {
            int k = j <= 2000 ? j : 2000;
            l = (int)disBook.skip(k);
        }
        currentStreamPosition += i;
    }

    public void close()
    {
        stkPages.removeAllElements();
        try
        {
            if(disBook != null)
                disBook.close();
        }
        catch(Exception exception) { }
    }

    private Page readPageFromStream()
        throws IOException
    {
        Page page = new Page();
        page.position = currentStreamPosition;
        byte abyte0[] = new byte[pageMaxBytes];
        int i = 0;
        for(int j = 0; i < pageMaxBytes && j < pageRows;)
        {
            boolean flag = false;
            int k = 0;
            while(i < pageMaxBytes && k < pageCols - 1)
            {
                try
                {
                    byte byte0 = disBook.readByte();
                    byte byte1 = disBook.readByte();
                    page.length += 2;
                    if(byte0 == 13 && byte1 == 0)
                        continue;
                    abyte0[i++] = byte0;
                    abyte0[i++] = byte1;
                    k++;
                    if(byte1 != 0)
                        k++;
                    if(byte0 != 10 || byte1 != 0)
                        continue;
                    if(k == 1)
                        flag = true;
                }
                catch(EOFException eofexception)
                {
                    bEof = true;
                }
                break;
            }
            if(!flag)
                j++;
            if(bEof)
                break;
        }
        currentStreamPosition += page.length;
        page.text = UnicodeString.byteArrayToString(abyte0, i);
        if(bEof)
            page.text += Language.getString(15);
        return page;
    }

    private void pushByteToArray(byte byte0, byte abyte0[])
    {
        for(int i = 1; i < abyte0.length; i++)
            abyte0[i - 1] = abyte0[i];
        abyte0[abyte0.length - 1] = byte0;
    }

    private byte[] readBytes(DataInputStream datainputstream, int i)
        throws IOException, EOFException
    {
        byte abyte0[] = new byte[i];
        for(int j = 0; j < i; j++)
        {
            abyte0[j] = datainputstream.readByte();
            currentStreamPosition++;
        }

        return abyte0;
    }

    private boolean byteArrayEquals(byte abyte0[], byte abyte1[])
    {
        boolean flag = true;
        for(int i = 0; i < abyte0.length; i++)
        {
            if(abyte0[i] == abyte1[i])
                continue;
            flag = false;
            break;
        }
        return flag;
    }
}

#10

都贴出来了，谢谢你帮我看看。

#11

stkPages在getNextPage（）中用到stkPages.push(new Integer(currentPage.position));当你看书翻页的时候getNextPage（）会被调用，用stkPages.push(new Integer(currentPage.position));把当前位置记录。还有一处是在getPrevPage()中，这个函数当你看书的时候点上一页时用到，用i = ((Integer)stkPages.pop()).intValue();来取得上一页的位置

#12

vctCache在savePageToCache（）中用到，代码我没有仔细看，应该是用来缓存浏览过的页面的vctCache.addElement(page.copy());这句话把浏览过的页面的一个备份放到vctCache中。还有一处是在findPageInCache（）用来在Vector把需要的页面内容取出来

#13

谢谢，那么变量Vector vctCache 和Stack stkPages在这个类里是起什么
作用？

#14

to luckycat(潘鑫):
差不多都理解了，结帖，认识你很开心，谢谢。

#15

呵呵，刚看到，我也来学习:)