Make Code More Efficient

Question

I got this code to play some audio clips and it works alright. The only issue is that when I call the play method it lags the rest of my game pretty badly. Is there anything in the play method you guys think could be moved to the constructor to make it more efficient?
package main;
import java.io.*;
import javax.sound.sampled.*;
public class Sound
     private AudioFormat format;
    private byte[] samples;
    private String name;
     public Sound(String filename)
          name=filename;
          try
            AudioInputStream stream =AudioSystem.getAudioInputStream(new File("sounds/"+filename));
            format = stream.getFormat();
            samples = getSamples(stream);
        }catch (Exception e){System.out.println(e);}
     public byte[] getSamples()
        return samples;
    private byte[] getSamples(AudioInputStream audioStream)
        int length=(int)(audioStream.getFrameLength()*format.getFrameSize());
        byte[] samples = new byte[length];
        DataInputStream is = new DataInputStream(audioStream);
        try
            is.readFully(samples);
        }catch (Exception e){System.out.println(e);}
        return samples;
    public void play()
         InputStream stream =new ByteArrayInputStream(getSamples());
        int bufferSize = format.getFrameSize()*Math.round(format.getSampleRate() / 10);
        byte[] buffer = new byte[bufferSize];
        SourceDataLine line;
        try
            DataLine.Info info=new DataLine.Info(SourceDataLine.class, format);
            line=(SourceDataLine)AudioSystem.getLine(info);
            line.open(format, bufferSize);
        }catch (Exception e){System.out.println(e);return;}
        line.start();
        try
            int numBytesRead = 0;
            while (numBytesRead != -1)
                numBytesRead =
                    stream.read(buffer, 0, buffer.length);
                if (numBytesRead != -1)
                   line.write(buffer, 0, numBytesRead);
        }catch (Exception e){System.out.println(e);}
        line.drain();
        line.close();
    public String getName()
         return name;
}

Answer 1

I don't know much about the guts of flex, but I assume it's
based on Java's design etc.
Storing event.target.selectedItem in an objet should not be
anymore efficient than calling event.target.selectedItem. The objet
will simply be a pointer of sorts to event.target.selectedItem. At
no point in the event.target.selectedItem call are you doing a
search or something, so storing the result will not result in any
big savings.
Now, if you were doing something like
array.findItem(something) 4 times, then yes, it would be to your
advantage to store the data.
Keep in mind that storing event.target.selectedItem in an
object will probably break bindings....that may or may not be a
problem. Objet doesn't support binding. There is a subclass of
Object that does, but I forget which.
Just a suggestion based on my knowledge of how data is stored
in an object oriented language...this may not be the case in
flex.