Head First Java BeatBox restoring a file query

[Al Dunne]

Hi all,

I hope I've put this in the correct forum.

I've completed the Head First Java Beat Box and everything worked fine. I then went on to the saving and restoring part and got that working (note I added a JFileChooser to my code). The problem I'm having is getting my head around the file restore part of the code as follows (note I made some variable/method name changes etc to the Head First code):-

    public void loadBeatBox (File file){
        boolean [] loadCheckBoxState = null;
        try{
            FileInputStream fileIn = new FileInputStream (file);
            ObjectInputStream  objectInStream = new ObjectInputStream (fileIn);
            loadCheckBoxState = (boolean []) objectInStream.readObject();
        }
        catch (Exception ex){
            System.out.println("Sorry but we could not load your song.");
            ex.printStackTrace();            
        }
        
        for (int i = 0; i < 256; i++){
            JCheckBox check = (JCheckBox) checkBoxState.get(i);
            if (loadCheckBoxState[i]){
                check.setSelected(true);
            }
            else{
                check.setSelected(false);
            }            
        }
        
        beatSequencer.stop();
        buildTrackAndStart();        
    }

From what I understand so far, the code above does the following:
Line 2 - Declare a boolean array called "loadCheckBoxState" and set it to null.
Lines 4/5 - Create a new object input stream to read from the saved file that gets passed to it.
Line 6 - Create the loadCheckBoxState boolean array. Then fill it with the contents of the objectInput stream, casted as a boolean array (boolean []). Q1. I'm not sure why it has to be casted as the file was saved as a boolean array?
Line 13 - Create a loop to iterate 256 times.

Now here's where my major problem is.
Line 14 - Declare a JCheckBox check and make it equal to the state of the actual checkbox in the class (note checkBoxState is the checkBox that was loaded into the ArrayList and the panel in the code not re-produced above) at the loop position. Q2. It's this line that's getting me. Why do we need to cast "(JCheckBox)"??? And how does this code actually change the checkBoxState checboxes in the code not re-produced (which are used to create the MIDI and build the track)??? To me this line reads make the JCheckBox check = the state of the JCheckBox checkBoxState
Lines 15 - Lines 19 - Iterate through the saved file and if the loaded checkbox is true/false, make the JCheckBox check true/false. My questions on this line will be answered (I think) if someone can answer my questions on Line 14.

Any help would be much appreciated. I hope I'm being clear in what I'm asking.

I can reproduce the full class if it would make it easier.

Thanks,

Al.

[William P O'Sullivan]

loadCheckBoxState = (boolean []) objectInStream.readObject();

The objectInStream.readObject() returns an Object which you then "convert" or cast to be the same as loadCheckBoxState
which happens to be an array of booleans.

Not sure about line 14, but probably quite similar.

Remember, an Object can pretty much be anything under the covers (except primitive).
Using generics here <> could also help.

WP

[Al Dunne]

Great that's the Line 6 casting answered. Thanks William. What you mean about Generics <>? Around my queries?

[William P O'Sullivan]

Sorry,

It this case, they cannot help.

As for line 14, I have no idea how checkBoxState is defined.
It's obviously a collection of probably JCheckBox(es).

Show me what is.

WP

[Al Dunne]

It's an ArrayList of type JCheckBox. Here's my full cose (sorry about all the comments, it was me trying to understand each step). I'd really like to understand how the file import is altering the state of the checkBoxState ArrayList. Again, any help much appreciated. Al.

import java.awt.*;
import javax.swing.*;
import javax.sound.midi.*;
import java.util.*;
import java.awt.event.*;
import java.io.*;

public class BeatBox extends JPanel{
    
    JPanel containerPanel;
    JPanel checkBoxPanel;
    JPanel instrumentNamePanel;
    ArrayList <JCheckBox> checkBoxState;
    Sequencer beatSequencer;
    Sequence beatSequence;
    Track beatTrack;
    JFrame containerFrame;
   
/* @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
   Create an array of Strings to hold the name of each instrument*/
    String [] instrumentNames = {"Bass Drum",
              "Closed Hi-Hat", "Open Hi-Hat", "Acoustic Snare", "Crash Symbol",
              "Hand Clap", "High Tom", "Hi Bongo", "Maracas", "Whistle",
              "Low Conga", "Cowbell", "Vibraslap", "Low-mid Tom", "High Agogo",
              "Open Hi Conga"};
  /* @ Reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
    // Create an array to hold the midi key for each instrument.
These numbers are specified in the javax.sound.midi package */
    int [] instruments = {
              35, 42, 46, 38, 49, 39, 50, 60, 70, 72, 64, 56, 58, 47, 67, 63};
    
    // @author Alan Dunne, x11105160
    public BeatBox(){
        // Create the container panel and give it some borders
        BorderLayout layout = new BorderLayout();
        containerPanel = new JPanel (layout);
//        containerPanel.setBorder((BorderFactory.createEmptyBorder(1, 1, 1, 1)));
        containerPanel.setBounds(0, 0, 417, 379);
        
        
/* Create the ArrayList of type JCheckBox that's
 going to hold the state of all the check boxes i.e. selected or not*/
        checkBoxState = new ArrayList <JCheckBox>();

/ Create the Panel to hold the instrument names and tell it to stack on the Y axis i.e. down. */
        GridLayout alan = new GridLayout(16, 1);
        instrumentNamePanel = new JPanel(alan);
        alan.setVgap(1);
// Populate the instrument name box using a loop to take strings from the String [] instrumentNames
        for (int i = 0; i<instrumentNames.length; i++){
            instrumentNamePanel.add(new Label (instrumentNames[i]));
        }
        // Add the instruments name box to the container panel
        containerPanel.add(BorderLayout.WEST, instrumentNamePanel);
        
        // Create a 16 x 16 grid layout for the checkBoxePanel
        GridLayout grid = new GridLayout (16, 16);
        grid.setHgap(-1);
        grid.setVgap(1);
        // Create the checkBoxePanel
        checkBoxPanel = new JPanel (grid);
        // Add the checkBoxPanel to the container panel
        containerPanel.add(BorderLayout.CENTER, checkBoxPanel);
        
        
/* Create the checkboxes, add their state to the checkBoxState ArrayList 
and add them to the checkBoxPanel.
Do by using a loop to create 256 checkboxes called c but
 adding each one to a different place in the ArrayList. 
It also adds 256 checkboxes called c to each of the positions
 in the grid layout (checkBoxPanel). */
        for (int i = 0; i < 256; i++){
            JCheckBox c = new JCheckBox();
            c.setSelected(false);
            checkBoxState.add(c);
            checkBoxPanel.add(c);
        }
        
// Call the set setUpMidi method to ready the track
        setUpMidi();    
        
// Add the container panel to the BeatBox class panel. Set the BeatBox class panel to null layout.
        setLayout(null);
        add(containerPanel); 
    }
    
    // @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
    // Set up midi sequencer, sequence and track method. 
    public void setUpMidi(){
        try{
            beatSequencer = MidiSystem.getSequencer();
            beatSequencer.open();
            beatSequencer.setTempoInBPM(120);
            // Create a new beatSequence and set the timing to 4 pulses per quarter note
            beatSequence = new Sequence (Sequence.PPQ, 4);
            // Create a new Track to hold the midi data
            beatTrack = beatSequence.createTrack();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
    
    // @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
    // Method to build our track based on the data held from checkbox clicks
    public void buildTrackAndStart(){       
        int [] trackList = null;
        
/* Delete existing track data and create a new empty track
 (Do this so everytime play button gets pressed the existing track
 data will be wiped and a new track created to contain the up to date data)*/
        beatSequence.deleteTrack(beatTrack);
        beatTrack = beatSequence.createTrack();
        
        // Outer loop to check the state of each of the rows (i.e. Bass, Congo etc.).
        for (int i = 0; i < 16; i++){
 /* This array is going to hold the state of the 16 checkboxes in each row.
 Should the instrument play at each position in the row?
 If the checkbox is selected (see loop below) this array will hold the midi
 instrument (number) to be played. If an instrument is to be played 16 times
 in succession, this array will hold something like [35, 35, 35, 35,
 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35] (depends on instrument midi number) 
*/
            trackList = new int [16];

            /* Set the instrument (MIDI key) for each row based on the instruments [] 
data above. Loop 1 this will be 35. Loop 2 will be 42 etc. */
            int key = instruments [i];     
            
/*            // Inner loop to populate each row with data on the state of
 each checkbox in that row i.e. selected/on (true) or not selected/off (false)*/
            for (int j = 0; j < 16; j++){
/*                // Local variable to collect data on the state of each
 checkbox in the row. Gets the data from the checkBoxState ArrayList. 
That ArrayList is holding the state of each of the 256 checkboxes. 
Outer and inner loop above creates 256 checkboxes (loops 16 x 16) called jcb.
(j + (16 * i) => Outer loop(i) 0, Inner Loop(j): 0, 1, 2.....16; Outer loop(i) 1, Inner Loop(j): 16, 17, 18......
*/
                JCheckBox jcb = (JCheckBox)checkBoxState.get(j + (16 * i));
                if (jcb.isSelected()){
// If the checkbox is selected, add the instrument to be played data to the trackList array.
                    trackList[j] = key;
                }
                else{
                    trackList[j] = 0;
                }
            }
/*            // For each loop of the outer loop, add the trackList array
 data to a track by calling the makeTracks method below and
 sending it an array of data (i.e. the instrument number if to be played or a 0 if not. */
            makeTracks(trackList);
/*            // I think the following command adds a Midi
 Control Change (176) to turn off all sound after tick 16.
            // Does this by calling the makeEvent method. Looks like it does it on channel 1.
*/
            beatTrack.add(makeEvent(176, 1, 127, 0, 16));          
        }
/* This line adds an event to beat 16 (it goes 0-15) of each row.
 Otherwise if there were none, the BeatBox might not go the full 16 beats before
 it starts over. 192 is change instrument. Think it reads:
 change instrument on channel 9 to instrument 1 at tick 15.
 Nothing actually happens but the event needs to be there for the reason above. */
        beatTrack.add(makeEvent(192, 9, 1, 0, 15));
        // Try Catch to add our sequence to the sequencer. Throw an exception if fails.
        try{
            beatSequencer.setSequence(beatSequence);
            beatSequencer.setLoopCount(beatSequencer.LOOP_CONTINUOUSLY);
            beatSequencer.start();
            beatSequencer.setTempoInBPM(120);
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
    
    // @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
/*    // This is the method to add midi data to the tracks. 
It adds Midi events at places in the track. For the method to
 be called it must be sent an array of ints. We then name this array received "list".*/
    public void makeTracks (int [] list){
        // Loop to take the instrument number and create a MidiEvent and add the MidiEvent to the track. 
        for (int i = 0; i < 16; i++){
            // Take the data in the int [] ("list"), sent when the method called, and store them in an int [] "key".
            int key = list [i];
            
            // If the data in an array element is 0, do not add a Midi event. Otherwise do.
            if (key != 0){
                // Add a MidiEvent to our track.
// Create the MidiEvent by calling the make Event method and sending it the data noted.
                beatTrack.add(makeEvent(144, 9, key, 100, i));
                beatTrack.add(makeEvent(128, 9, key, 100, i+1));
            }
        }
    }
    
    /* @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005.
    // Method to create MidiEvents that will get added to the track.
 Note the return type is MidiEvent rather than void.*/
    public MidiEvent makeEvent (int command, int channel, int one, int two, int tick){
        MidiEvent event = null;
        try{
            ShortMessage a = new ShortMessage();
            a.setMessage (command, channel, one, two);
            event = new MidiEvent (a, tick);
        }
        catch (Exception e){
            e.printStackTrace();
        }
        return event;
    }
    
    // @author Alan Dunne, x11105160
    public void start(){
        buildTrackAndStart();
    }
    
    // @author Alan Dunne, x11105160
    public void stop(){
        beatSequencer.stop();
    }
    
    // @author Alan Dunne, x11105160
    public void upTempo(){
        float tempoNum = beatSequencer.getTempoFactor();
        beatSequencer.setTempoFactor((float)(tempoNum * 1.035));
    }
    
    // @author Alan Dunne, x11105160
    public void downTempo(){
        float tempoNum = beatSequencer.getTempoFactor();
        beatSequencer.setTempoFactor ((float)(tempoNum * 0.965));
    }
    
    // @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005. 
    // as modified by @author Alan Dunne, x11105160    
    public void saveBeatBox(File file){
        boolean [] savedCheckBoxState = new boolean [256];
        
        for (int i = 0; i < 256; i++){
            JCheckBox state = (JCheckBox) checkBoxState.get(i);
            if (state.isSelected()){
                savedCheckBoxState [i] = true;
            }
            
        }
        
        try{
            FileOutputStream fileOut = new FileOutputStream (file);
            ObjectOutputStream objectOutStream = new ObjectOutputStream (fileOut);
            objectOutStream.writeObject(savedCheckBoxState);            
        }
        catch (Exception ex){
            System.out.println("Sorry but we could not save your song.");
            ex.printStackTrace();
        }
    }
    
 /*/ @reference: Head First Java, Second Edition, Sierra K & Bates B, 2005. 
  as modified by @author Alan Dunne, x11105160  */
    public void loadBeatBox (File file){
        boolean [] loadCheckBoxState = null;
        try{
            FileInputStream fileIn = new FileInputStream (file);
            ObjectInputStream  objectInStream = new ObjectInputStream (fileIn);
            loadCheckBoxState = (boolean []) objectInStream.readObject();
        }
        catch (Exception ex){
            System.out.println("Sorry but we could not load your song.");
            ex.printStackTrace();            
        }
        
        for (int i = 0; i < 256; i++){
            JCheckBox check = (JCheckBox) checkBoxState.get(i);
            if (loadCheckBoxState[i]){
                check.setSelected(true);
            }
            else{
                check.setSelected(false);
            }            
        }
        
        beatSequencer.stop();
        buildTrackAndStart();        
    }
    
    // @author Alan Dunne, x11105160  
    public void clearPattern(){
        for (int i = 0; i < 256; i++){
            JCheckBox check = (JCheckBox) checkBoxState.get(i);
            check.setSelected(false);
            }            
        
        beatSequencer.stop();
        buildTrackAndStart();
        beatSequencer.stop();
    }
}

[Campbell Ritchie]

Al Dunne wrote: . . . sorry about all the comments . . .

There’s nothing wrong with comments, but you need to use the right type. The lines are too long, which makes the code very difficult to read. Use /*...*/ comments over several lines, not one long //... comment. The same applies to those long array initialisers; they should be spread over several lines, otherwise they fall off the width of the screen.

[Al Dunne]

Thanks Ritchie. Can anyone help with line 14 of original code posting / line 273 of full code posting?

How exactly is this changing the checkBoxState arraylist?

Al.

[Campbell Ritchie]

I presume you have an array of booleans or similar and you are iterating the list and array simultaneously. You should actually avoid the if-else, like this:-

for (int i = 0; i < list.length(); i++)
{
   ((CheckBox)checkBoxState.get(i)).setSelected(loadCheckBox[i]);
}

There is some poor code style there.

It is error-prone to try running arrays in parallel, and arrays in parallel with lists are even worse. If you can think of some way to link the values directly to the boxes, preferably in the same class, that would be a great improvement. It would also allow you to use a for-each loop.

You can get some nasty Exceptions if the length of the array, the list, and the loop termination number are different.

You ought to parameterise the list, so as to avoid the error-prone (CheckBox) cast.

What you are doing is going through a list of check boxes, and setting their selected-ness (grammar!) to match the value in the parallel boolean[] array.

[Al Dunne]

Campbell Ritchie wrote:
What you are doing is going through a list of check boxes, and setting their selected-ness (grammar!) to match the value in the parallel boolean[] array.

But can you tell me how this actually happens. I understand that line 265 makes the boolean [] loadCheckBoxState = the boolean [] read from the saved file (object cast back to a boolean []).

But whay I don't understand is how this then changes the state of the boolean [] "ArrayList <JCheckBox> checkBoxState" that gets run through the buildTrackAndStart method (Line 106).

So the line to adjust this has to be Lines 272 - 280

        for (int i = 0; i < 256; i++){  
            JCheckBox check = (JCheckBox) checkBoxState.get(i);  
            if (loadCheckBoxState[i]){  
                check.setSelected(true);  
            }  
            else{  
                check.setSelected(false);  
            }              
        }  

I think it must be Line 2 from the little snippet above that is changing the state of checkBoxState[i].
To me this reads, new JCheckBox check = whatever is stored in checkBoxState [i] but I'm probably wrong and this actually means make whatever is in checkBoxState = to whatever gets put into 'check'.
Can anyone clarify this?

This is code from the HeadFirst Java book (slightly modified by me). If there's bad coding, it's their fault.

Sorry about the delay getting back also. I have another problem in NetBeans that has been sucking up my time. Still haven't solved it. Relates to jar files. I might stick it up here now aswell.

[Campbell Ritchie]

I think you are right in general, but there are lots of little points. You don’t have a CheckBox[], but a List<CheckBox>. It ought to have been parameterised; maybe that is old code from the 1st edition which hasn’t been updated. In the good old days before generics, you had to cast whatever you “got” out of a Collection (if you wanted to use anything but methods inherited from java.lang.Object). To use the setSelected() method, you have to tell the compiler that anything “got” has that method, which you do with a cast. Of course, if you mistakenly insert something which cannot be cast, you suffer an exception when you retrieve it. If (since Java5) you call it a List<CheckBox>, then the compiler knows anything put in is a CheckBox, so it knows anything coming out is also a CheckBox and it can perform the casting for you, secure in the knowledge it can’t suffer such an Exception.
Now you have a List with 256 CheckBoxes in, all with a selected field, and a parallel array (ouch!). If the array and the List are the same size, and the List only contains CheckBoxes, then you set each CheckBox’s selected field to a value to match the value in the array. It is like saying

When you start, I want you to select some of the check boxes. Select Nos 2 3 5 7 11 13 17 19 ... and un-select all the others.

Are you reading all those booleans from a file? I didn’t remember that. It is along time since I looked at that part of Head First Java™.

[Al Dunne]

Yes, the saveBeatBox method is at Line 236 above. It just saves a boolean [] called savedCheckBoxState.

Still don't understand how this line changes the state of checkBoxState[i]. Is it not always that the thing on the left of the = will become what's on the right?

JCheckBox check = (JCheckBox) checkBoxState.get(i); 

The code is from the second edition of HeadFirst which I think is the latest version.

Thanks for taking the time.

[Campbell Ritchie]

That code doesn’t change the state of the List at all. What it does, however, is get a reference to every Check Box in the List, and the next statement changes the state of that check box. My version did it all in one line.

[Al Dunne]

Campbell Ritchie wrote:That code doesn’t change the state of the List at all. What it does, however, is get a reference to every Check Box in the List, and the next statement changes the state of that check box. My version did it all in one line.

Am I right then in saying that "JCheckBox check = (JCheckBox) checkBoxState.get(i);" makes 'check' be a reference to checkBoxState[i] so that if you change the state of 'check' (as the bit after that code does) it will change the state of checkBoxState[i].

This is the part that I don't understand as in the most part all I've been working with is primitives where if you say int num = otherNum (another int) then the value of num will be the same as otherNum. Whereas if you applied the logic from above writing int num = otherNum would make the value in OtherNum the same as num.

I'm vaguely remebering something about object references??? If you make an object1 ref = object2, am I right in saying that the object 1 is just a reference to object2 rather than an object itself. Confusing myself now.

[Campbell Ritchie]

Al Dunne wrote: . . . Am I right then in saying that "JCheckBox check = (JCheckBox) checkBoxState.get(i);" makes 'check' be a reference to checkBoxState[i] . . .

No. There is no such thing as checkBoxState[i]. That is a List, and you are getting a reference to its i-th element, not [i] which is only used for arrays.

Yes, check represents a reference to the whichever-th object out of the List. It provides access to that object and you can call its public methods. One of those methods alters whether it is selected or not.
Yes, the whichever-th element of that List and check both point to the same object, so a method call in one reference affects the object which the other reference points to. That is why you can have the long version you quoted and the short version I quoted.

Kettle k = new Kettle("Bosch", 20, 5);
Kettle kk = k; // Two variables now pointing to the same object reference
kk.heat();
System.out.println(k); //Prints A Bosch Kettle ... temperature 100° ...

The difference with primitives is that a primitive is stored as its actual value.

int i = 21;
int j = i;
i = 127;

At this point the contents of the memory location underlying j is 0000....0001_0101 and that underlying i is 0000....0111_1111. But objects don’t work like that. The memory location underlying check and the whichever-th you-know-what are the same. There is no way readily to find out the actual memory location, which the JVM hides from you. But whatever it is, it points to the same object and calling a method (or similar) on one of those references affects the state of the object. Just as when you heat Kettle kk, Kettle k gets hot too.

[Al Dunne]

Thanks a lot for your help Ritchie. Much appreciated.