AudioFormat class provides the function of obtaining sound effect sampling, such as sampling rate and number of channels. In addition, it provides frame size -- some bytes. For example, 16 bit stereo, its frame size is 4, or 2 bytes represent the sampling value, so we can easily calculate how much memory stereo can occupy. For example, the memory value of 16 bit two-thirds length stereo audio format sampling: 44100x 3x4 bytes = 517KB. If it is mono, the sampling capacity is half that of stereo.

After we know the size and format of audio sampling, the next step is to read the content from these audio files. Interface line is an API used to send and receive system audio. We can use line to send sound samples to the OS sound system to play, or receive the sound of the OS sound system, such as microphone sound. Line has several sub interfaces. The main sub interface is SourceDataLine, which allows us to write sound data to the sound system in the OS. The instance of line is obtained through the getLine() method of AudioSystem. We can pass the parameter line Info object to specify the line type returned. Because line Info has a dataline Info subclass, which knows that in addition to the SourceDataLine interface, there is another line called Clip() interface. This interface can do many things for us, such as loading samples from AudioInputStream stream stream into memory, and automatically transmitting these data to audio system for playback. The following is the code for playing sound using Clipe:

package com.funfree.arklis.sounds;
import java.io.*;
import javax.sound.sampled.*;

/**
	Function: write a class to encapsulate the sound, open it from the file system, and then play it
	*/

public class SimpleSoundPlayer  {
    private AudioFormat format;
    private byte[] samples;//Save sound samples

    /**
        Opens a sound from a file.
    */
    public SimpleSoundPlayer(String filename) {
        try {
            //Open an audio stream
            AudioInputStream stream =
                AudioSystem.getAudioInputStream(
                new File(filename));

            format = stream.getFormat();

            //Get sampling
            samples = getSamples(stream);
        }
        catch (UnsupportedAudioFileException ex) {
            ex.printStackTrace();
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }


    /**
        Gets the samples of this sound as a byte array.
    */
    public byte[] getSamples() {
        return samples;
    }


    /**
        Get samples from AudioInputStream and save them as byte arrays-- The array here will be encapsulated in the ByteArrayInputStream class,
		So that Line can play multiple audio files at the same time.
    */
    private byte[] getSamples(AudioInputStream audioStream) {
        //Gets the number of bytes read
        int length = (int)(audioStream.getFrameLength() *
            format.getFrameSize());

        //Read the entire stream
        byte[] samples = new byte[length];
        DataInputStream is = new DataInputStream(audioStream);
        try {
            is.readFully(samples);
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }

        // Return sample
        return samples;
    }


    /**
        Play stream
    */
    public void play(InputStream source) {
		//Audio sampling every 100 milliseconds
        int bufferSize = format.getFrameSize() *
            Math.round(format.getSampleRate() / 10);
        byte[] buffer = new byte[bufferSize];

        //Create a line object to perform sound playback
        SourceDataLine line;
        try {
            DataLine.Info info =
                new DataLine.Info(SourceDataLine.class, format);
            line = (SourceDataLine)AudioSystem.getLine(info);
            line.open(format, bufferSize);
        }catch (LineUnavailableException ex) {
            ex.printStackTrace();
            return;
        }

        // Start autoplay
        line.start();

        // Copy data to line object
        try {
            int numBytesRead = 0;
            while (numBytesRead != -1) {
                numBytesRead =
                    source.read(buffer, 0, buffer.length);
                if (numBytesRead != -1) {
                   line.write(buffer, 0, numBytesRead);
                }
            }
        }catch (IOException ex) {
            ex.printStackTrace();
        }

        // Wait until all data is played, and then close the line object.
        line.drain();
        line.close();

    }

}

If you need to broadcast circularly, you can modify the above class to realize this function.

LoopingByteInputStream class

package com.funfree.arklis.engine;
import static java.lang.System.*;
import java.io.*;

/**
	Function: encapsulate ByteArrayInputStream class, which is used to play audio files in a loop. When loop playback is stopped
		  Call close() method
	*/
public class LoopingByteInputStream extends ByteArrayInputStream{
	private boolean closed;
	
	public LoopingByteInputStream(byte[] buffer){
		super(buffer);
		closed = false;
	}
	
	/**
		Read an array with length. If the subscript is set to the beginning of the array,
		If it is closed, - 1
		*/
	public int read(byte[] buffer, int offset, int length){
		if(closed){
			return -1;
		}
		int totalBytesRead = 0;
		while(totalBytesRead < length){
			int numBytesRead = super.read(buffer,offset + totalBytesRead,
				length - totalBytesRead);
			if(numBytesRead > 0){
				totalBytesRead += numBytesRead;
			}else{
				reset();
			}
		}
		return totalBytesRead;
	}
	
	/**
		Close flow
		*/
	public void close()throws IOException{
		super.close();
		closed = true;
	}
}