Java - Reading from txt file and storing in array

Question

I am working on a small library application which is able to save manuals stored to a text file, and load said text file back. However currently I am unable to store the library in an array, as once the user loads a file they are simply displayed the text within the console area.

How can I get the loaded library.txt file to be stored in the library rather than printed to the console?

Here is my manual class with the save implementation:

import java.io.*;
import java.util.Scanner;

public class Manual {

String serial;
String title;
String author;
String publicationYear;
String status;
String borrower;
String borrowDate;
String returnDate;  

Scanner userInput = new Scanner(System.in); 

/**
 * Display the Manual:
 * @return ManualInfo
 */
final String displayManual(){

    String ManualInfo ="\nSerial Number: ........... "+serial+ 
                    "\nTitle: ................... "+title+
                    "\nAuthor: .................. "+author+
                    "\nPublication Year: ........ "+publicationYear+
                    "\nStatus: .................. "+status+
                    "\nBorrower: ................ "+borrower+
                    "\nDate Borrowed: ........... "+borrowDate+
                    "\nReturn date: ............. "+returnDate+
                    "\n";
    return ManualInfo;  
}   

/**
 * Creates the Manual.
 */
final void createManual(){

    serial = Console.readString(Messages.enterSerialMessage, Messages.tooShortMessage, 3);
    title = Console.readString(Messages.enterTitleMessage, Messages.tooShortMessage, 2);
    author = Console.readString(Messages.enterAuthorMessage, Messages.tooShortMessage, 3);
    publicationYear = Console.readString(Messages.enterPublicationYearMessage, Messages.tooShortMessage, 4);

    borrower = "N/A";
    borrowDate = "N/A";
    returnDate = "N/A";

    status = "Available";
}   

/***
 * Runs the main part of the program and terminates if the choice is 0.
 */
public void run(){

    User.addUser();
    Menu.displayMenu();//Displays the main menu and ask for choice.

    exit:           
        while(Menu.menuChoice != 0){


            if(Menu.menuChoice == 1 && Library.ManualList.size() > 0){                      
                Library.displayManualList();
                boolean saveYesNo = Console.readYesNo("The ManualKeeper® app is able to save your current library to a '.txt' \nfile in your workspace directory.\n\nWould you like to save the current library? (Y/N):\n");
                if(saveYesNo){
                    try {
                        FileWriter fw = new FileWriter("Library.txt");
                        PrintWriter pw = new PrintWriter(fw);

                        for (int i1 = 0; i1 < Library.ManualList.size(); i1++){
                            pw.println("-------------------- Index Number: " + i1 + " --------------------");
                            pw.println(Library.ManualList.get(i1).displayManual());
                            pw.println("---------------------------------------------------------\n");
                        }
                        pw.close();
                    } catch (IOException e) {
                        System.out.println("Error! Library unable to save.");
                    }
                    System.out.println("\n\n--------------------------------------------------------------------------");
                    System.out.println("\n                              Library saved!\n");
                    System.out.println("--------------------------------------------------------------------------\n");
                }
                    else if(saveYesNo){
                        System.out.println("\n");
                }   
                Menu.displayMenu();
            }

            if(Menu.menuChoice == 1 && Library.ManualList.isEmpty()){
                System.out.println(Messages.addManualFirst);
                Menu.displayMenu();
            }
            if(Menu.menuChoice == 1 && Library.ManualList.size() > 0){                      
                Library.displayManualList();
                boolean saveYesNo = Console.readYesNo("The ManualKeeper® app is able to save your current library to a '.txt' \nfile in your workspace directory.\n\nWould you like to save the current library? (Y/N):\n");
                if(saveYesNo){
                    try {
                        FileWriter fw = new FileWriter("Library.txt");
                        PrintWriter pw = new PrintWriter(fw);

                        for (int i1 = 0; i1 < Library.ManualList.size(); i1++){
                            pw.println("-------------------- Index Number: " + i1 + " --------------------");
                            pw.println(Library.ManualList.get(i1).displayManual());
                            pw.println("---------------------------------------------------------\n");
                        }
                        pw.close();
                    } catch (IOException e) {
                        System.out.println("Error! Library unable to save.");
                    }
                    System.out.println("\n\n--------------------------------------------------------------------------");
                    System.out.println("\n                              Library saved!\n");
                    System.out.println("--------------------------------------------------------------------------\n");
                }
                    else if(saveYesNo){
                        System.out.println("\n");
                }   
                Menu.displayMenu();
            }

            if(Menu.menuChoice == 1 && Library.ManualList.isEmpty()){
                System.out.println(Messages.addManualFirst);
                Menu.displayMenu();
            }

Here is my startLibrary class with my load implementation:

public class startLibrary {

/**
 * The main method.
 *
 * @param args the arguments
 */
public static void main(String[] args){
    System.out.println("\n--------------------------------------------------------------------------");
    System.out.println("\n                 Welcome to the ManualKeeper® library app!");
    System.out.println("\n--------------------------------------------------------------------------\n");
    boolean loadYesNo = Console.readYesNo("The ManualKeeper® app is able to load any 'Library.txt' files found in \nyour workspace directory.\n\nWould you like to load a library? (Y/N):\n");
    if(loadYesNo){
    try {
        FileReader fr = new FileReader("Library.txt");
        BufferedReader br = new BufferedReader(fr);

        String str;
        while ((str = br.readLine()) != null) {
            System.out.println(str + "\n");
        }

        br.close();
    } catch (IOException e) {
        System.out.println("Error! File not found");
    }
    }

    Manual newManual = new Manual();
    newManual.run();




}//End of Main Method.

Here is my library class in full incase needed:

package library;

import java.util.ArrayList;


/** The Manual choice. */
public static int ManualChoice;

static String returnManualTitle;

/** The status1. */
static String status1 = "Available";

/** The status2. */
static String status2 = "Borrowed"; 

/** The Manual list. */
static ArrayList<Manual> ManualList = new ArrayList<Manual>();
static ArrayList<Manual> borrowedManuals = new ArrayList<Manual>();


/**
 * Adds the Manual.
 */
static void addManual(){
    Manual newManual = new Manual(); //create new Manual object with status "Available."
    newManual.createManual();
    ManualList.add(newManual);//add the Manual to the ManualList ArrayList.
    System.out.println("\n\n--------------------------------------------------------------------------");
    System.out.println("\n                          Manual added to library!\n");
    System.out.println("--------------------------------------------------------------------------\n");
}

/**
 * Display Manual list.
 */
static void displayManualList(){
    if (ManualList.isEmpty()){//If the library is empty, it goes back to main menu and choice.
        System.out.println("-------------------------------------------------------------");
        System.out.println(Messages.empltyLibraryMessage + Messages.tryAgainMessage);
        System.out.println("-------------------------------------------------------------");
        Menu.menuChoice = 7;

    } else {    
        System.out.printf("\n\nHere are the Manual/s currently stored in the library:\n\n\n");
        for (int i = 0; i < ManualList.size(); i++){
            System.out.printf("-------------------- Index Number: %s --------------------\n",i);
            System.out.println(ManualList.get(i).displayManual());  
            System.out.println("---------------------------------------------------------\n");
            }
        }//End of For Loop.         
    }// End of Else Statement.          

static void displayBorrowedManuals(){
    if (ManualList.isEmpty()){//If the library is empty, it goes back to main menu and choice.
        System.out.println("-------------------------------------------------------------");
        System.out.println(Messages.empltyLibraryMessage + Messages.tryAgainMessage);
        System.out.println("-------------------------------------------------------------");
        Menu.menuChoice = 7;

    } else {                    
        for (int i = 0; i < borrowedManuals.size(); i++){
            System.out.printf("-------------------- Index Number: %s --------------------\n",i);
            System.out.println(borrowedManuals.get(i).displayManual()); 
            System.out.println("---------------------------------------------------------");
        }//End of For Loop.         
    }// End of Else Statement.          
}//End of if Statement.
/**
 * Borrow Manual.
 */
public static void borrowManual(){

    //register user's Manual choice.
    displayManualList();
    ManualChoice = (Console.readInteger(Messages.enterManualIndexMessage, Messages.ManualIndexNotInListMessage, 0, Library.ManualList.size() - 1));

    borrowLoop:
    while(Menu.menuChoice == 3){
        //Check if the Manual to be borrowed is available.
        //ManualChoice = (Console.readInteger(Messages.enterManualIndexMessage, Messages.ManualIndexNotInListMessage, 1, Library.ManualList.size()));

        if ((ManualList.get(ManualChoice).status.equalsIgnoreCase(status1)) && (ManualList.size() >= ManualChoice)){
            //Print the borrowed Manual information and change the Manual status to borrowed.
            ManualList.get(ManualChoice).status = "Borrowed";
            ManualList.get(ManualChoice).borrower = User.userName;
            ManualList.get(ManualChoice).borrowDate = "Today.";
            ManualList.get(ManualChoice).returnDate = "In two weeks.";
            //Add the borrowed Manual to the borrowedManuals arraylist:
            borrowedManuals.add(ManualList.get(ManualChoice));
            System.out.println("\n--------------------------------------------------------------------------");
            System.out.println("\n                             Manual borrowed!\n");
            System.out.println("--------------------------------------------------------------------------\n");
            break borrowLoop;

        }else if(ManualList.get(ManualChoice).status.equalsIgnoreCase(status2) && ManualList.size() >= ManualChoice){
            System.out.println("\n--------------------------------------------------------------------------");
            System.out.println("\n            "
                    + " The Manual you wish to borrow is already on loan.");
            System.out.println("\n--------------------------------------------------------------------------\n");
            break borrowLoop;

        }else if(ManualChoice > ManualList.size()-1){
            System.out.println(Messages.noSuchManualMessage);
            break borrowLoop;
        }
    if(ManualList.size() > 1){
        displayManualList();
    }
    else if(ManualList.size() == 1){
        ManualList.get(ManualChoice).status = "Borrowed";
        ManualList.get(ManualChoice).borrower = User.userName;
        ManualList.get(ManualChoice).borrowDate = "Today.";
        ManualList.get(ManualChoice).returnDate = "In two weeks.";
        borrowedManuals.add(ManualList.get(ManualChoice));
        System.out.printf("\n\nOSCAR YOU SHOULD NOT BE SEEING THIS!!!!!!!\n\n %s\n\n", ManualList.get(ManualChoice).displayManual());
        System.out.println("Please return the Manual within two weeks!\n");
        displayManualList();
        }
    }
    Menu.displayMenu();
}

/**
 * Return Manual.
 */
static void returnManual(){
    System.out.printf("\n\nHere are the Manual/s currently out on loan:\n\n");

    if(borrowedManuals.size() > 0){
    for (int i = 0; i < borrowedManuals.size(); i++)
        System.out.println(borrowedManuals.get(i).displayManual());
        returnManualTitle = Console.readString(Messages.enterManualSerial, Messages.tooShortMessage, 3);
    }

    int x = 0;
    boolean serialExistance = false;
    while (x < ManualList.size()){//Search for the Manual by title, if it exists change it's status,
                                //it's borrower and borrowDate.

        if (ManualList.get(x).serial.equalsIgnoreCase(returnManualTitle)){

            ManualList.get(x).status = "Available";
            ManualList.get(x).borrower = "N/A";
            ManualList.get(x).borrowDate = "N/A";
            ManualList.get(x).returnDate = "N/A";

            int p = 0;
                while (p < borrowedManuals.size()) {
                    Manual borrowed = borrowedManuals.get(p); // guessing the name of this class
                    if (borrowed.serial.equalsIgnoreCase(returnManualTitle)) {
                        borrowedManuals.remove(p);
                        break;
                    }
                    p++;
                }               
            System.out.println(Messages.successReturnMessage);
            serialExistance = true;

            break;//if a title is found, break out of the loop and display choice menu.
        }
        x = x+1;
    }//end of while loop.
    if(serialExistance == false){
        boolean repeatReturnManual = Console.readYesNo("\n--------------------------------------------------------------------------" + "\n\nThe Manual with the title "+"\""+returnManualTitle +"\""+ " wasn't found!"
                                                        +"\n\nDo you want to try again? (Y/N):\n");
        System.out.println("\n--------------------------------------------------------------------------");
        if(repeatReturnManual){
            returnManual();
        }
    }else if(serialExistance){
        Menu.menuChoice = 7;
    }               
}

/**
 * Removes the Manual.
 */
public static void removeManual(){

    if(ManualList.size() >0){
        displayManualList();
        ManualChoice = Console.readInteger(Messages.enterRemoveManualIndex ,Messages.ManualIndexNotInListMessage, 0, ManualList.size());        
        int p = 0;
        while (p < borrowedManuals.size()){//Search for the Manual by title, if it exists change it's status,
            //it's borrower and borrowDate.

            if (borrowedManuals.get(p).title.equalsIgnoreCase(returnManualTitle)){

                borrowedManuals.remove(p);
            }
        }
        ManualList.remove(ManualChoice);
        System.out.print(Messages.successRemovedManualMessages);
        Menu.menuChoice = 7;
    }               
}

/**
 * Empty library.
 */
static void emptyLibrary(){
    System.out.println("\n                                 WARNING!");
    System.out.println("\n           You have chosen to delete all Manuals in the library.\n"); 
    System.out.println("--------------------------------------------------------------------------");
    boolean emptyLibraryChoice = Console.readYesNo("\nAre you sure you wish to destroy the library? (Y/N): \n");
    System.out.println("\n--------------------------------------------------------------------------\n");
    if(emptyLibraryChoice){
        Library.ManualList.clear();
        System.out.println(Messages.successEmptyLibraryMesssage);
        System.out.println("--------------------------------------------------------------------------\n");
        Menu.menuChoice = 7;
        }

}

}

Answer 1

I think you reposted the question. And I think the question was answered pretty good. I try to explain it to you:

You save your library as a text file. You add all manuals like this:

"-------------------- Index Number: " + i1 + " --------------------"
                    "\nSerial Number: ........... "+serial+ 
                    "\nTitle: ................... "+title+
                    "\nAuthor: .................. "+author+
                    "\nPublication Year: ........ "+publicationYear+
                    "\nStatus: .................. "+status+
                    "\nBorrower: ................ "+borrower+
                    "\nDate Borrowed: ........... "+borrowDate+
                    "\nReturn date: ............. "+returnDate+
                    "\n";
"---------------------------------------------------------\n"

Now you write many of these into the library.txt file. The problem: You cant extract the information. The solution is: PARSING. This here is just a little code you have to adapt to get it work:

    final String delimiterManuals = ";;;;;;;;";
    final String delimiterValues = "::::::::";

//save file
for (int i1 = 0; i1 < Library.ManualList.size() - 1; i1++)
{
    //here are all attributes
    pw.print(Library.ManualList.get(i1).title));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).author));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).publicationYear));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).status));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).borrower));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).borrowDate));
    pw.print(delimiterValues);
    pw.print(Library.ManualList.get(i1).returnDate); //this is your last attribute
    pw.print(delimiterManuals);
}
//WATCH: lastAttribute is just an example (because I don't want to write every attribute)
//last Manual has no delimiterManual at the end (end of file)
pw.print(Library.ManualList.get(Library.ManualList.size()-1).title));
pw.print(delimiterValues);
pw.print(Library.ManualList.get(Library.ManualList.size()-1).author));
pw.print(delimiterValues);
//other attributes of the manual...
pw.print(Library.ManualList.get(Library.ManualList.size()-1).lastAttribute);


ArrayList<String> a = new ArrayList<String>();
//load
FileReader fr = new FileReader("Library.txt");
BufferedReader br = new BufferedReader(fr);

String str;
while ((str = br.readLine()) != null)
{
    a.add(str);
}
ArrayList<Manual> manuals = new ArrayList<Manual>()
for(int i = 0; i < a.size(); ++i)
{
    //split into single manuals
    String[] split1 = a.get(i).split(delimiterManuals);
    for(int j = 0; j < split1.length; ++j)
    {
        //split into single values
        String[] split2 = split1.split(delimiterValues);
        //here you have all values of a manual in the order you saved them so:
        Manual m = new Manual();
        m.title = split[0]; // <-- please don't do this! create and use setter/getter (like m.setTitle(split[0]);
        m.author = split[1]
        // till all fields are filled up
        manuals.add(m);
    }
}

//now you have all manuals in the manuals ArrayList

Please consider, that you really have to adapt the code. I just wanted to give you a general idea of how to parse.