Having problems reading data from a file and filling an ArrayList

[Daniel Andres]

Hello fellow programmers. I need some guidance please as to how to fill an ArrayList. Please understand I do not want the whole program to be written for me I'm just stuck in filling the ArrayList and I would like a clarification as to what I am doing wrong.
This main menu is not complete yet as I am focusing on the actual code first. My post is lengthy but I only have one question stated further below. Please do help!

import java.util.Scanner;
public class CreateExhibition
{
    public static void main(String[] args)
    {
		Curator exhibition = new Curator();
		System.out.println("exhibition?");
		Scanner input = new Scanner (System.in);
		String keepGoing = input.nextLine();
		while(keepGoing.equals("yes"))
		{
			String theExhibitionList = exhibition.paintingsChosen();
			System.out.println(theExhibitionList);
			System.out.println("a new exhibition?");
		}
    }
    
}

Here is the curator class

import java.util.ArrayList;
import java.util.Scanner;
public class Curator
{
	//Declare Museums
	Museum nationalGallery = null;
	Museum corcoranGallery = null;
	Museum portraitGallery = null;
	Museum phillipsCollection = null;
	String theExhibitionList;
	int topicSelection;
	int museumsSelected;
	private ArrayList<Museum> museumsUsed = new ArrayList<Museum>();
	private ArrayList<Painting> paintingsFromOneMuseumArray = new ArrayList<Painting>();	
	private ArrayList<Painting> exhibitionPaintingsArray = new ArrayList<Painting>();

	public Curator()
	{	
		//Give museums memory
		System.out.println("test");
		nationalGallery = new Museum("National Gallery","nationalGallery.txt");
		corcoranGallery = new Museum("Corcoran Gallery", "corcoranGallery.txt");
		portraitGallery = new Museum("Portrait Gallery", "portraitGallery.txt");
		phillipsCollection = new Museum("Phillips Collection", "phillipsCollection.txt");
	}

	public String paintingsChosen()
	{
		getMuseumsForTheExhibition();
		topicSelection = selectTopic();
		String paintingList = null;
		switch (topicSelection)
		{
		case 1:// painter
			String painter = getPainter();
//			paintingList = painter(painter, museumsUsed);
			break;
		}// switch
		return theExhibitionList + paintingList;
	}
	private void getMuseumsForTheExhibition(){

		museumsUsed = new ArrayList<Museum>();
		//		display museum choices
		//		read choices		
		//		fill museumsUsed
		System.out.println("For this exhibition, from which Museums would you like the art work be drawn?\n");
		System.out.println("Please enter their numbers on one line:");
		System.out.println("1) National Gallery\n2) Phillips Collection\n3) Corcoran\n4) Portrait Gallery\n");
		Scanner keyboard = new Scanner(System.in);
		museumsSelected = keyboard.nextInt();
		switch (museumsSelected){
		case 1:
			museumsUsed.add(nationalGallery);
			break;
		case 2:
			museumsUsed.add(phillipsCollection);
			break;
		case 3:
			museumsUsed.add(corcoranGallery);
			break;
		case 4:
			museumsUsed.add(portraitGallery);

		}

	}
	private int selectTopic(){	

		int choiceOfTopic;
		System.out.println("Now that you have chosen the Museums,\nplease choose an exhibition topic\nand enter its number:");
		System.out.println("1) Painter\n2) Year painted\n3) Size\n4) Medium\n5) Country\n6) Genre");
		Scanner input = new Scanner(System.in);
		choiceOfTopic = input.nextInt();
		return choiceOfTopic;

	}

	private String getPainter(){

		String nameOfPainter;
		System.out.println("Please enter a Painter:");
		Scanner input = new Scanner (System.in);
		nameOfPainter = input.nextLine();
		return nameOfPainter;

	}	
//	private String painter(String paintersName, ArrayList<Museum> museumArray){

//	}
	//	private String createPaintingListFromExhibitionPaintingArray(String paintingListSoFar){
	//
	//	}
}

Museum class. Here I invoke the readPainting method so iterate through a list of items for all of the museums. I need to read each line and assign it to a variable and then I think I need to put these values into the array paintingArray(line 7) from the museum class but because I have doubles and integers I do not know how to do that. When I call the method painter from the curator class from line 36 I need to pass the name of a painter that the user chose and also the museum filled with a given array that the user also chose. In this case, assuming the array has the information from the last picture I posted, I need to search for all of the paintings from that painter. But since I don't know how to fill the array I am stuck. Please help me understand the process. I have just started to use ArrayList so I just have a basic understanding of it.

import java.util.ArrayList;
import java.util.Scanner;

public class Museum
{
	private String museum;
	private ArrayList<Painting> paintingArray = new ArrayList<Painting>();
	
	public Museum(String museumName, String paintingFile){	

		Scanner scanMuseumFile = TextFileIO.createTextRead(paintingFile);
		readFile(scanMuseumFile);
		scanMuseumFile.close();
	}

	public void readFile(Scanner read){	
		int paintingNumber = read.nextInt();
		int x = 0;
		for(x = 0; x < paintingNumber; x++)
		{
			Painting getPaintingInformation = new Painting();
			getPaintingInformation.readPainting(read);
		}

	}
//	*** The Museum class can return an ArrayList of paintings ***
//	*** given the choice from the client.
//	public ArrayList<Painting> genre(String genre){
//
//	}
//	public ArrayList<Painting> country(String desiredCountry){	
//
//	}
//	public ArrayList<Painting> datePainted(int start, int end){
//
//	}
//	public ArrayList<Painting> painter(String paintersName){
//
//	}
//	public ArrayList<Painting> size(double start, double end){
//
//	}
//	public ArrayList<Painting> medium(String desiredMedium){
//
//	}
//	public String toString(){	
//
//	}
}

And painting class

import java.util.ArrayList;
import java.util.Scanner;

public class Painting
{
	private String painterName;
	private String paintName;
	private int year;
	private double size;
	private String medium;
	private String country;
	private String genre;
	public void readPainting(Scanner read)
	{
		read.nextInt();
		painterName = read.nextLine();
		paintName = read.nextLine();
		year = read.nextInt();
		size = read.nextDouble();
		genre = read.nextLine();
		medium = read.nextLine();
		country = read.nextLine();
		
	}
	//Get and set methods.
//	public String toString(){
//
//	}
}

TextFileIO class (This has some information from another program that I was using it with but had to create it in order to read from a file)

import java.util.Scanner;
import java.io.*;
public class TextFileIO
{
	public static void main(String[] args)
	{
		String fileName = "textFile2.txt";
		int x = 3;
		String line = null;
		int count;
		Scanner scan = new  Scanner(System.in);
		PrintWriter textStream =TextFileIO.createTextWrite(fileName);
		System.out.println("Enter 4 lines of text:");
		for (count = 1; count <= 4; count++)
		{
			line = scan.nextLine();
			textStream.println(count + " " + line);
		}
		textStream.close( ); // did not require error handling
		System.out.println("Those lines were written to " + fileName);
		System.out.println();
		System.out.print("Now we will read them from " + fileName + " using the ");
		System.out.println("Scanner class." );
		Scanner scanFile = TextFileIO.createTextRead(fileName);// scan a file
		for (count = 1; count <= 4; count++)
		{
			count = scanFile.nextInt();
			line = scanFile.nextLine();
			System.out.println(count + line);
		}
		scanFile.close();

	}

	public static PrintWriter createTextWrite(String S)
	{
		PrintWriter TStream = null;
		try
		{
			TStream = new PrintWriter(new FileOutputStream(S));
		}
		catch(FileNotFoundException e)
		{
			System.out.println("Error opening the file in createTextWrite");
			System.exit(0);
		}
		return TStream;
	}


	public static Scanner createTextRead(String S)
	{
		Scanner textFile = null;
		try
		{
			textFile = new Scanner(new File(S));
		}
		catch(FileNotFoundException e)
		{
			System.out.println("File not found");
			System.out.println("or could not be opened.");
		}
		return textFile;
	}



}

Here is the data saved for each museum and a few lines for one of them

[Junilu Lacar]

Daniel Andres wrote:My post is lengthy but I only have one question stated further below. Please do help!

Yes, the post is quite lengthy and I just spent a minute scanning through trying to find that one question you said would be stated further below which you somehow actually forgot to state. What exactly was your question?

[Daniel Andres]

I need to read each line and assign it to a variable and then I think I need to put these values into the array paintingArray(line 7) from the museum class but because I have doubles and integers I do not know how to do that. This written right before the museum code.

That's what I need to find out. Could you run the code please so that you can see the error message I get?

[Paul Clapham]

Daniel Andres wrote:Could you run the code please so that you can see the error message I get?

It would be a LOT more practical if you just told us what the error message is. Better still, copy it and paste it into your next post.

[Daniel Andres]

I'll do that. I've done that in the past but then programmers wanted me to post the code so that they can run it and see it for themselves. I figured that's the preferred option.

I'll post it shortly

[Paul Clapham]

No, when you get an error message the first thing to do is to read it. The error message has words in in for a reason, namely to try and tell you what went wrong. Frequently it's possible to fix the problem just based on what the error message says. So asking somebody else to spend several minutes copying and pasting your code just so they can see the error message you've already seen is... well, as I said there's a better way.

[Daniel Andres]

Would you like to create an exhibition?
yes
For this exhibition, from which Museums would you like the art work be drawn?

Please enter their numbers on one line:
1) National Gallery
2) Phillips Collection
3) Corcoran
4) Portrait Gallery

1
Now that you have chosen the Museums,
please choose an exhibition topic
and enter its number:
1) Painter
2) Year painted
3) Size
4) Medium
5) Country
6) Genre
1
Please enter a Painter:
giotto
Museum@55f96302
nullMuseum@55f96302

------------------------------------------------------------------------------------

I have fixed and added code but my main issue remains. As you can see, museum from museumsUsed is not displaying the correct results. All of the iterations from readFile in the Painting class I need to fill in an ArrayList but because it contains int and doubles I do not know how to do that. I think this is too lengthy and difficult to explain :/

[Junilu Lacar]

Daniel Andres wrote:
Please enter a Painter:
giotto
Museum@55f96302
nullMuseum@55f96302

------------------------------------------------------------------------------------
I have fixed and added code but my main issue remains. As you can see, museum from museumsUsed is not displaying the correct results.

By "not displaying the correct results" are you referring to the part that I have bolded?

[Daniel Andres]

Junilu Lacar wrote:

Daniel Andres wrote:
Please enter a Painter:
giotto
Museum@55f96302
nullMuseum@55f96302

------------------------------------------------------------------------------------
I have fixed and added code but my main issue remains. As you can see, museum from museumsUsed is not displaying the correct results.

By "not displaying the correct results" are you referring to the part that I have bolded?

Yes, I have seen that error before when working with regular arrays but I do not remember why this happens.

[Junilu Lacar]

Daniel Andres wrote:
Yes, I have seen that error before when working with regular arrays but I do not remember why this happens.

That's not an error. That looks like the string representation of a Museum object.  Go over you code again and see where you're printing a Museum object. That's where that output is coming from.

[Junilu Lacar]

Daniel, I have to say that the amount of code you posted and the actual source of the problem you're trying to find indicates to me that you have a very poor grasp of what your code is actually doing. This is never a good thing. To have that much code and so little understanding of it can only lead to bad things. I guess that's something all programmers have to learn the hard way though.

One way out of this jungle of confusion is refactoring. That is, improving the design, and in particular, the clarity and organization, of your code.

This reply is going to be a long one so I will break it up into a few separate posts.

Buckle up.

(continued...)

[Junilu Lacar]

First, let's look at what is not working. This is where most of your confusion and lack of understanding becomes apparent.
public class Museum {    private String museum;    private ArrayList<Painting> paintingArray = new ArrayList<Painting>();        public Museum(String museumName, String paintingFile){          Scanner scanMuseumFile = TextFileIO.createTextRead(paintingFile);        readFile(scanMuseumFile);        scanMuseumFile.close();    }    public void readFile(Scanner read){        int paintingNumber = read.nextInt();        int x = 0;        for(x = 0; x < paintingNumber; x++)        {            Painting getPaintingInformation = new Painting();            getPaintingInformation.readPainting(read);        }    }    ... }
Your approach for reading in data from a text file and creating objects from it is somewhat unconventional. For a program of this size and complexity, however, it's still relatively manageable. So, we'll stick with this approach for now. Just so you know, Museum is what is known as a domain object. You normally should not assign the responsibility of reading data and creating objects to a domain object. That's a responsibility that's best given to something else in the data layer of your application. Creating objects from data read from a text file is an infrastructure layer concern, not a domain layer concern.

Data in text files like the ones you're reading in presents some challenges:
1. The semantics (meaning) of each line is implicit. You have to know what each line represents.
2. The logical organization of the data is also implicit. You have to know which lines go together.
3. There is very little room for error in 1 & 2. If any of these are off in some way, an automated process that assumes correctness will fail.

As such, we will just trust that the data files you were given do not have any errors. This leaves the possibility of errors happening resting solely on your code that reads it in and interprets its meaning. For future reference, just remember that the conventional approach would be to have something in the application's data layer read in the data file, interpret the data, and build object(s) out of whatever it reads.

(continued...)

[Junilu Lacar]

From the image you posted and from the code you wrote, this is what I can deduce about the data in those text files:

20                      // number of data groups that follow
1                       // *** first data group, painting #1
Giotto                  // artist name
Saint Francis of Assisi // painting title
1590                    // year
2.9                     // size
Renaissance             // genre
Tempera                 // medium
Italy                   // country
2                       // *** second data group, painting #2
Angelico                // artist name
...

I have already noted some of the challenges this type of data presents. One thing you don't want to do is compound those challenges by spreading the logic for reading in and interpreting that data across a wide area in your code. This is exactly what you have done, however. The problems caused by your approach is exactly why it is preferable to assign that responsibility to something in the data layer of the application. Those problems include: lack of focus in the code, which leads to a lack of clarity in the code, which leads to a lack of understanding of what the code is doing, which leads to bugs, which leads to difficulty in maintenance and getting the program to work correctly in the first place, which leads to ... (a slow death spiral marked by pain and despair).

(continued...)

[Junilu Lacar]

Now, let's look at some of the things that you did that adds to the confusion in the code.

Let's start with some basic things that you can easily fix. Let's talk about names. In particular, let's talk about using good names in your program.

You may think this is a very trivial thing but try to take the Stroop Effect test first and see for yourself just how much a conflict between words and intent can affect your brain and its ability to comprehend and function.

    Scanner scanMuseumFile = TextFileIO.createTextRead(paintingFile);
"scan museum file" is an imperative sentence; it's a command to do something. A Scanner is a noun, a thing that does something.

Now, imagine naming your dog "Sit".  How the heck are you going to train that dog to do anything? It will be the most confused dog ever. Imagine yourself giving commands to your dog, Sit: "Sit, fetch!" "Sit, run!" "Sit, stay!" "Sit, heel!" "Sit, sit!" "Sit, roll over!" "Sit, play dead!" "Sit, shake hands!" "Sit, sit!"

Do you get what I mean? This is the same kind of confusing thing that the next line of code says:
readFile(scanMuseumFile);
although I can understand how you might think that line of code actually makes sense. To anyone else who doesn't have the ability to get into your head, however, that line of code can be confusing. At a subconscious level, that line of code may actually be leading you astray as well.

The more insidious problem with the name(s) you use is that it shifts from being a "paintingFile" to being a "museumFile" (line 11). So which one is it? Is this a museum file or a painting file? Because according to your class design, Museum and Painting are two different things. This, as I said, indicates some level of confusion on your part.

There are a number of sensible alternatives to that name. Here are a couple, just off the top of my head:
Scanner input = TextFileIO.createTextRead(paintingFilename); readFile(input); // or Scanner source = TextFileIO.createTextRead(filename); readFile(source);
Notice the suggestions for the other name as well.

(continued...)

[Junilu Lacar]

I'm going to have to step away for a while, so I'll just cut to the chase. Your main problem is that you read in the data but you never actually add any objects to your List<Painting>.  Look carefully at the code that I originally cited in my second post in this series.

I will go into more details later when I have time.

[Junilu Lacar]

This code:
   public void readFile(Scanner read){        int paintingNumber = read.nextInt();        int x = 0;        for(x = 0; x < paintingNumber; x++)        {            Painting getPaintingInformation = new Painting();            getPaintingInformation.readPainting(read);        }      }
This is what I was saying about spreading out the logic that reads from the data source across a wide area in your code.  One line 17, you read an integer. Since this is the first number you read from the file, it is supposed to represent the number of data groups that follow it, with each data group comprising information about a single Painting. The rest of the logic to read the data group for a single painting is somewhere else, in that readPainting(read) method call.

Once again, there's a problem with the names you use. The name paintingNumber does not accurately reflect the actual meaning/intent of the value that is assigned to it. This number is not a "painting number". Rather, it is the number of Painting objects that you should expect to create from the data read from the file.  Also, the call to getPaintingInformation.readPainting(read) just doesn't make any grammatical sense at all. What does this code really want to say?

Refactoring the names in this method, I can get a little bit more clarity out of what the code is doing:
public void createPaintings(Scanner source) {    int numberOfPaintings = source.nextInt();    for (int i = 0; i < numberOfPaintings; i++) {         Painting painting = new Painting();         painting.initializeFrom(source);         // ??? something's missing here...         // otherwise, we're just "throwing away" the new Painting object         // we created and initialized from data we read from the Scanner    } }
Now that it's a little clearer what this code is doing (the code actually tells a story, right?), isn't it more clear that you haven't actually added the new Painting object to a List<Painting>?

Also, it's clearer now that the initializeFrom(source) method call somehow "knows" or assumes to know our current position in the data being read from the source.  If you go into that method, you see all those nextWhatever() calls that assign values to the Painting fields. The problem with this, again, is that the logic for interpreting the meanings (semantics) of the data items and their arrangement in the text file is now spread across two methods.  You have to bounce around between two places of your code to see exactly how this tracking of your place in the source data stream is managed. Having all that logic in one place is better.  It makes the code more coherent.

[Junilu Lacar]

By the way, there are other names you can consider using besides createPaintings(Scanner source).  There are also other designs you can consider:

public List<Painting> materializeFrom(Scanner source) {
   List<Painting> newPaintings = new ArrayList<>();

   int numberOfPaintings = source.nextInt();
   for (int i = 0; i < numberOfPaintings; i++) {
       Painting painting = new Painting();
       ...
       newPaintings.add(painting);
   }

   return newPaintings;
}

Another reasonable method signature would be

public List<Painting> unmarshallFrom(Scanner source) {
   ...
}

Those names at least express what is happening in the method.

Try to figure out how you would call a method that is designed this way.

[Daniel Andres]

Junilu Lacar wrote:By the way, there are other names you can consider using besides createPaintings(Scanner source).  There are also other designs you can consider:

public List<Painting> materializeFrom(Scanner source) {
   List<Painting> newPaintings = new ArrayList<>();

   int numberOfPaintings = source.nextInt();
   for (int i = 0; i < numberOfPaintings; i++) {
       Painting painting = new Painting();
       ...
       newPaintings.add(painting);
   }

   return newPaintings;
}

Another reasonable method signature would be

public List<Painting> unmarshallFrom(Scanner source) {
   ...
}

Those names at least express what is happening in the method.

Try to figure out how you would call a method that is designed this way.

First off, I would like to THANK YOU immensely for such detailed response and tips on the way I have added code to the program. Programmers like you help others get better along the way. This is a project I have to code and this is the way it was designed. I was given a driver and while I too agree that it would have been better to read the file onto an array from the data layer of the application( which I just learned is the way to address this way of coding), I think the reason we need to spread the manipulation of data between classes is to practice on how to do so and how it works. This is exactly why I am having such a headache with this program. I did not know how to fill that data into the array and then return it to the calling method as you stated:

public void createPaintings(Scanner source) {
    int numberOfPaintings = source.nextInt();
    for (int i = 0; i < numberOfPaintings; i++) {
         Painting painting = new Painting();
         painting.initializeFrom(source);
 
         // ??? something's missing here...
         // otherwise, we're just "throwing away" the new Painting object
         // we created and initialized from data we read from the Scanner
    }
}

Also, the "throwing away" part is what my main question was and I see everything clear now from your last post. I wanted to clarify that I do understand what is happening in the program, to a good extent so far at least until I figure later on what certain methods are supposed to do as I progress with the code, and the reason everything is unorganized is because I was given the name of the methods with very little detailed in a few of them to get started and I have to start programming each part and connect them to other methods and helping methods. I enjoy working on a program from scratch using my own algorithms but again, I believe the purpose behind this project is to help us manipulate objects from class to class. Thank you for the tips on proper naming of variables and parameters! I shall continue now with the program...

[Junilu Lacar]

Daniel Andres wrote:First off, I would like to THANK YOU immensely for such detailed response and tips on the way I have added code to the program.

You're welcome. A lot of us hang out here because we like sharing what we know and it's rewarding for us to see our advice help others.

I think the reason we need to spread the manipulation of data between classes is to practice on how to do so and how it works.

You ought to practice doing the right things, not the wrong things. As every music teacher I've ever met likes to say, "Practice only makes habit. Only perfect practice makes perfect."  Do you really want to make a habit of doing the wrong things?

Thank you for the tips on proper naming of variables and parameters! I shall continue now with the program...

Keep practicing, but make sure you're practicing how to get better. Don't just do things because you're asked to do them a certain way. Think critically about what other people do in their code but think even more critically about what you do in your code.

Good luck.

[Daniel Andres]

I have tried to read the data from one museum' array containing a particular painter's name without any luck. I have added the following code:

private String painter(String paintersName, ArrayList<Museum> museumArray){
		
		ArrayList<Museum> sample = new ArrayList<Museum>();	
		Museum museum = new Museum();
		paintingsFromOneMuseumArray = museum.painter(paintersName, museumArray);

In the code above(argument), museumArray was added a specific museum

switch (museumsSelected){
		case 1:
			museumsUsed.add(nationalGallery);

When I invoke this method (below) I feel like I should somehow read through the items in arrayList containing the paintings from National Gallery and then iterate in a loop whether that array contains the painter's name and then return a new String with only those paintings. I'm having trouble relating museumsUsed in the curator class and paintingArray in the Museum class.

public ArrayList<Painting> painter(String paintersName, ArrayList<Museum> array){

		ArrayList<Painting> Painting = new ArrayList<Painting>();	
		for(Painting contentsFromCurrentMuseum: paintingArray){
			
			if (contentsFromCurrentMuseum.getPainterName().equals(paintersName)){
				Painting = paintingArray;
			}
		}
		return Painting;

In essence I am trying to search through the entire list of National Gallery, for example, and look for only the paintings for a given painter and add them to a new String or array and return it to the calling method.

[Daniel Andres]

I did not mean to include the

ArrayList<Museum> sample = new ArrayList<Museum>(); 

in line 3. That was just part of the things I was trying to do

[Junilu Lacar]

Daniel, I hate to sound negative but I believe you've reached an impasse. You have way too much code that has a lot of things wrong with it, from its basic design, organization, and logic. It's not just a matter of fixing one or two statements or even one or two methods. It's the proverbial whack-a-mole problem where fixing one thing locally will lead to other problems surfacing in surrounding code.

And this is the problem with writing too much code all at once that doesn't work. You develop an attachment to the code and feel like throwing any significant portion away is something you just can't bring yourself to do. However, the more you try to patch things up and pull it together, the more problems you create and the further you get from actually being done. If you're lucky, you may get to point where it will mostly work but you're very unlikely to get it working 100% correctly unless you do a major overhaul and redesign. I don't know if you have the luxury or ability to do that though.

[Junilu Lacar]

One of the main problems I see in your code is a lack of focus and specific responsibility. Object-oriented programs are all about that. If It were me, I would have one separate class that was responsible for reading and interpreting a museum data file. It would have a method to report how many painting data groups to expect to find in the file, another to read a painting data group and create a Painting object from it, and another to control the loop that reads in all the Painting data groups and collect all the Painting objects created in a List.

[Daniel Andres]

Alright man. Thanks again for the suggestions.
I'll keep working on it until is fixed.

[Junilu Lacar]

I wrote:If It were me, I would have one separate class that was responsible for reading and interpreting a museum data file. It would have ...

Here's an outline of that class, just off the top of my head:

public class MuseumDataSource {

    /**
     * @param path the path of the museum data file that this data source
     *   will read data from
     */
    public MuseumDataSource(String path) {
        ...
    }

    public List<Painting> getAllPaintings() {
         int numberOfPaintings = readNumberOfPaintings();
         List<Painting> paintings = new ArrayList<>(numberOfPaintings);
         for (int i = 0; i < numberOfPaintings; i++) {
              paintings.add(nextPainting());
         }
         return paintings;
    }

    /**
     * Reads the first line in the file, interpreted as # of paintings listed
     */
    private int readNumberOfPaintings() { ... }
  
    /**
     * Creates a new Painting from the next group of data read from the
     * data file.
     *
     * @return a new Painting object, initialized with information in the 
     *  next group of lines read from the data file.
     */
    private Painting nextPainting() { ... }

}

As I said earlier, you could start with all the above code in your Museum class but that's not how you would do it in the real world. In a non-trivial real-world application, the responsibility of reading data from a text file or whatever persistent storage you use, whether its XML, JSON, a relational database, or whatever else, is assigned to a separate class that belongs in the Data Access Layer of your application.

[Daniel Andres]

Fixed and working!
Thanks for the help