3

I'm working on an assignment where I need to take "books" from the user(a title, an author, and ISBN number, all strings), and store these books somehow, and then do various things to these books using methods.

What I've chosen to do is store each "book" as an array with three values, one for the title, one for author, one for ISBN number. Then, I store that array inside an arraylist. where I hope to call upon each "book" later.

Unfortunately, the way I've chosen to go about this is to add a while loop so that the user can add as many books as they choose before moving on. But since its a loop, each time the user goes around, they essentially rewrite the same array(I.E. it has the same name) before pushing it back into the arraylist. After a lot of agonizing that was the only way I could think of doing it. Code below:

 static int numofbooks = 0;//I think you can ignore these for this question static int checkedbooks = 0; static ArrayList<String[]> AllBooks = new ArrayList<String[]>(); //this arraylist is the "library" that all the "books" are stored in. It's a static so it can be referenced across every method public static void Add() { String user_answer = new String("yes");//this is for the while loop Scanner cont = new Scanner(System.in); Scanner bookscanner = new Scanner(System.in); while (user_answer.equalsIgnoreCase("yes")) { String[] Book = new String[3];//This is the "book" to be stored System.out.print("Enter book name: ");//the various detes Book[0] = bookscanner.nextLine(); System.out.print("Enter the author's name: "); Book[1] = bookscanner.nextLine(); System.out.print("Enter the ISBN: "); Book[2] = bookscanner.nextLine(); AllBooks.add(Book);//The "book" is pushed into the arraylist numofbooks++;//ignore System.out.print("Would you like to add another book? Type yes if so: "); user_answer = cont.nextLine();//if the user wants, they can do it again } }

My question is that since I basically use the same array name every time, will it even be possible to call on each array again when I need them?

For example I will need to remove one or more books from the arraylist, will this be possible(or easy) with this system?

Sorry, I'm a major beginner.

I've tried various methods to verify that each array is being properly stored, such as by printing out the arraylist, however I've been unsuccessful. In one case, using an "Arrays.toString" I saw that two arrays were being stored at different memory locations(?) but I'm not sure how reliable this will be.

Improve this question
2
  • Using a string array for each book is bad modelling. However, as long as you use that, what you need is here: What's the simplest way to print a Java array? Commented Apr 12 at 5:33
  • How to retrieve individual arrays from arrays of strings stored inside an ArrayList? Retrieval is not the main problem. Printing each array is. Either use better modelling or use the link in my previous comment. Commented Apr 12 at 5:52

2 Answers 2

Reset to default
7

tl;dr

How can I call each array from inside the arraylist?

Use the enhanced for loop.

for ( String[] book : books ) { System.out.println ( Arrays.toString ( book ) ) ; }

Or use Streams.

books .stream() .map( Arrays :: toString ) .forEach( System.out :: println ) ;

Multiple array instances

since I basically use the same array name every time, will it even be possible to call on each array again

The name of your array does not really matter here.

String[] Book = new String[3];

That name Book ( which should have been lowercase book per Java naming convention) is the name of the variable that holds a reference to the new array instance being created on the right side of the equals sign. Each time through your while loop, you generate a fresh new array instance. A reference to that new array instance is assigned to Book, and a few lines later you hand off that same reference to a new element added to your ArrayList.

Your ArrayList does not actually hold arrays. Your list holds references to arrays, each element being one reference to one array held somewhere else in memory.

Here is a conceptual diagram of your array instances floating around in memory, with a reference to each held as an element in your ArrayList. Each line represents a reference.

screenshot of memory layout with an ArrayList of String[] instances

… essentially rewrite the same array(I.E. it has the same name)

No. Notice the word new in your line new String[3]. Each time you call new String[3] you produce a fresh new shiny empty array with three slots containing no reference (null).

The previous array instances produced as you loop this code continue to exist in memory. those array instances will continue to exist for as long as you hold one or more references to them. After its last reference is discarded, an array instance becomes a candidate for garbage collection, to be removed from memory eventually.

will it even be possible to call on each array again when I need them?

So yes, this does work as you intend. You make a bunch of array instances, all of them collected in sequence in an ArrayList (well, actually references to those arrays are collected). You can then later iterate through the ArrayList to retrieve each of those array instances being referenced.

ArrayList<String[]> books = new ArrayList… … for ( String[] book : books ) { System.out.println ( Arrays.toString ( book ) ) ; }

FYI, the key here is to understand a reference in Java. Get that concept and the rest becomes clear.

need to remove one or more books from the arraylist, will this be possible(or easy) with this system

You can use the methods offered by ArrayList to remove any element. In your case, each element is one of your array instances.

using an "Arrays.toString" I saw that two arrays were being stored at different memory locations(?)

The result of that method is not really the memory address of the array instance. But you can think of it that way.

Yes each of your array instances is floating around somewhere in memory, each in a different place. So each has a different address in memory.

stored at different memory locations(?) but I'm not sure how reliable this will be.

Again, you need to learn about Java references. The reference tracks the memory location. Java handles all that for you automatically.

Object-oriented programming

By the way, bigger picture… Your use of an array here to hold each book is a workable solution, but awkward and unusual.

Some limitations:

  • For one thing, the values within an array must all be the same type. So your string array could not hold a LocalDate for when the book was published, for example.
  • Another limitation of your use of array here is that the array has no names for the fields. The programmer has to know that the book’s title is in first part of array, the book’s author in the second, etc. This approach is frustrating and error-prone.

The purpose of a class in OOP is to overcome these limitations. Each field describing a book can be a different type and have a name. By defining a class, you are defining your own data type.

record Book ( String title , String author , LocalDate published ) {} List < Book > books = new ArrayList<>() ; books.add( new Book ( "Foundation" , "Isaac Asimov" , LocalDate.of ( 1951 , 5 , 17 ) ) ) ; books.add( new Book ( "Looking for Alaska" , "John Green" , LocalDate.of ( 2005 , 7 , 14 ) ) ) ; String favoriteTitle = books.get ( 0 ).title() ; // “Foundation”.

By the way, ISBN should not be represented as a String. An ISBN has a specific structure, with various parts having a meaning. In real work, you would define a class for ISBN. Or more likely, you would obtain an ISBN class that someone else has written.

record Book ( String title , String author , ISBN isbn , LocalDate published ) {}
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

I agree that the record is the way to go.
1

  1. Yes, even though you're using the same variable name Book each time, you're creating a brand new array object inside the loop. When you do this line:

     String[] Book = new String[3];

    it creates a new array in memory each time the loop runs, and when you do:

     AllBooks.add(Book);

  2. So, you're not overwriting anything. Each time through the loop, a different array is added. You are not pushing the same array repeatedly — you're creating new ones. So yes, you'll be able to access, remove, or modify individual books later using the ArrayList methods like ArrayList.get(), ArrayList.iterator() and ArrayList.remove(int).

So to answer your questions directly:

... since I basically use the same array name every time, will it even be possible to call on each array again when I need them?

Yes, it will be possible (since you are not using the same array every time).

For example I will need to remove one or more books from the arraylist, will this be possible(or easy) with this system?

Possible, yes. Easy,that depends. Since equals() doesn’t work as expected on arrays, you will not be able to use ArrayList.contains() or ArrayList.remove(Object). Other ArrayList methods mentioned above work as expected.

I've tried various methods to verify that each array is being properly stored, such as by printing out the arraylist, however I've been unsuccessful. In one case, using an "Arrays.toString" I saw that two arrays were being stored at different memory locations(?) but I'm not sure how reliable this will be.

What you see when prińting with Arrays.toString() is a system hashcode of each array (not exactly a memory location, though many confuse this). This suffices to verify that you have got different arrays though the array contents are not printed.

Improve this answer

1 Comment

As it’s currently written, your answer is unclear. Please edit to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers in the help center.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.