Java：顺序排序名称并保存到随机访问文件中

Question

I am trying to make a program where I can add a name and it's supposed to be saved in a RandomAccessFile , (alphabetically). Whenever I add a name it gets saved in a file, it's supposed to have at the end the next corresponding position for the next name. I'm having problems with the saving whenever I add a name with starting with A, then I add a name with C, and if I where to add a name starting with B it's not pointing me in the right alphabetical order.

Here is what an example of what the program should do:

I add a name starting with A.

Numbers on "left" side are just where the next name start, Numbers on "right" side are the pointers to the next name

[0]-----A----[-1] ----------- the "-1" pointer means its the end of the list

I add a name starting with C.

[0]-----A----[100] ------- the "100" pointer means that the next name "C" start on byte 100

[100]---C----[-1] --------- end of the list pointer, notice how A no longer has the "-1" pointer

I add a name starting with B.

[0]-----A----[200] ------ "A" no longer points to 100 because the next letter should be "B"

[100]---C----[-1] -------- -1 still means that "C" is the end of the list pointer

[200]---B----[100] --------- "B" is pointing at "C" because the next letter after

Here is my code so far, but I'm missing the part where a name that belongs in the middle of the list is added.

public boolean add(String name, String lastName, String telf) {

    try {
        fileSize = file.length();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
    if (fileSize == 0) { //must be a new entry

        try {

            byte entry[] = new byte[sizeEntry];  // size of each entry
            file.write(entry);
            file.seek(file.getFilePointer() - sizeEntry);

            file.writeUTF(name);   //name gets saved
            file.writeUTF(lastName);// last name gets saved
            file.writeUTF(telf);    // telf gets saved
            file.writeUTF("N");     // deleted "Y" or "N" gets saved
            file.writeUTF("-1");    // pointer gets saved

        } catch (IOException e) {
            System.out.println("Error at saving....");
            e.printStackTrace();
        }

    } else {
        pPresent= 0;     //variable for the pointer reading
        pPrevious= 0; // variable for the pointer read

        try {
            file.seek(0); //start reading at the top
            do {
                pPresent= file.getFilePointer();//saves present pointer
                file.seek(pPresent);//seeks to present pointer
                nameRead = file.readUTF();  //reads name
                file.readUTF();  //reads last name
                file.readUTF();  //reads telf
                file.readUTF();  //reads deleted?
                pNext= Long.parseLong(file.readUTF()); // reads the next pointer

                int comparison= name.compareTo(nameRead);
                if (comparison< 0) {

                    //enters here if the new entry goes before the present entry
                    if (pNext!= -1) {
                        file.seek(pNext);//enters here if pointer is not at end of list
                    } else {
                        try {// proceeds to writing a new entry 

                            file.seek(file.length()); //goes to the end of the file
                            byte entry[] = new byte[sizeEntry];
                            file.write(entry);
                            file.seek(file.getFilePointer() - sizeEntry);

                            file.writeUTF(name);
                            file.writeUTF(lastname);
                            file.writeUTF(telf);
                            file.writeUTF("N");
                            file.writeUTF(Long.toString(pPrevious));//writes the previous pointer

                            file.seek(pPrevious);//seeks to the previous entry
                            file.readUTF();//reads name
                            file.readUTF();//reads lastname
                            file.readUTF();//reads telf
                            file.readUTF();//reads deleted?
                            file.writeUTF(Long.toString(pPrevious));//overwrites the new previous

                        } catch (IOException e) {
                            System.out.println("Error at saving...");
                            e.printStackTrace();
                        }
                        break;//exits
                    }
                } else {//enteres here if the entry is bigger than the present

                    if (pNext!= -1) {
                        file.seek(pNext);
                    } else {
                        try {

                            pPresent= file.length()-sizeEntry;//saves present entry
                            file.seek(pPrevious); //seeks to previous entry
                            file.readUTF();//reads name
                            file.readUTF();//reads last name
                            file.readUTF();//reads telf
                            file.readUTF();//reads deleted
                            file.writeUTF(Long.toString(pPresent+100));//overwrites the next pointer

                            file.seek(file.length());//seeks at the end
                            byte entry[] = new byte[sizeEntry];//creates a new entry
                            file.write(entry);
                            file.seek(file.getFilePointer() - sizeEntry);

                            file.writeUTF(name);//writes name
                            file.writeUTF(lastname);//writes lastname
                            file.writeUTF(telf);//writes telf
                            file.writeUTF("N");//writes deleted
                            file.writeUTF(Long.toString(pNext));//writes next pointer

                        } catch (IOException e) {
                            System.out.println("Error at saving...");
                            e.printStackTrace();
                        }
                        break;//exits
                    }
                }
                pPresent= file.getFilePointer();//present pointer read
                pPrevious= pPresent;//present pointer becomes previous
            } while (true);


        } catch (IOException e) {

            System.out.println("Error at saving....");
            e.printStackTrace();
        }
    }
    return false;
}

I hope you guys understand the idea of the program a little better now with the source code. The part I don't know how to do is where I add a entry that belongs in the middle of the list. Remember that the order of the names dont change only the pointers pointing to the next do.

Answer 1

Finding the insertion point will require traversing the list, which in turn requires a disk access for every single name. Assuming you have 1 million names, and a typical disk access time of 10 ms, inserting a single name would take about 3 hours. Put differently, linked lists are an extremly unsuitable data structure for storing data on disk.

A reasonable data structure such as a B-Tree would permit lookup and insertion among 1 million names in as little as 3 disk accesses.

Answer 2

Yo have to develop a method that calculates the pointer, I develop a code a few days ago:

public int getNext(String lastName){

    int auxNext=0;
    int auxActual=0;
    byte[] relleno= new byte[100];

    try{

        int Next=-1;

        while(auxNext!=-1){                                             

            auxActual=auxNext;              
            myRaf.seek(auxNext);
            String auxPreviousLastName=myRaf.readUTF();

            auxNext=Integer.valueOf(myRaf.readUTF());

            if(auxNext!=-1){

                myRaf.seek(auxNext);
                String auxApellido=myRaf.readUTF();

                String aux=myRaf.readUTF();

                if(lastName.compareTo(auxLastName)<0){                          

                    Next=auxNext;                                       
                    myRaf.seek(auxActual);                                  
                    myRaf.write(relleno);
                    myRaf.seek(auxActual);
                    myRaf.writeUTF(auxPreviousLastName);                        
                    myRaf.writeUTF(String.valueOf(myRaf.length()));
                    return Next;                                            

                }

            }else{                                                          

                updateEnds();
                return -1;                                                  

            }

        }

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return -1;

}

public void updateEnds(){       //This method search the last register, and updates that reference

    byte[] relleno= new byte[100];

    try {
        for (int i = 0; i < myRaf.length(); i+=100) {               

            myRaf.seek(i);
            String auxLastName=myRaf.readUTF();             
            String next=myRaf.readUTF();

            if (next.equals("-1")) {                                    

                myRaf.seek(i);                                          
                myRaf.write(relleno);                                   
                myRaf.seek(i);                                          
                myRaf.writeUTF(auxLastName);
                myRaf.writeUTF(String.valueOf(myRaf.length())); 


            }

        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

PD, Sorry, I don't write in english as well as you.