Java 编写一种方法，以随机顺序播放曲目列表中的每一首曲目

我不确定我在这里做错了什么。我做到了，你可以从一个列表中随机播放一首歌，但不能随机播放整个列表。如果我能得到任何帮助，我将不胜感激。我的代码是：

import java.util.ArrayList;
import java.util.Random;

/**
 * A class to hold details of audio tracks.
 * Individual tracks may be played.
 * 
 * @author William Gambill
 * @version July 10, 2013
 */
public class MusicOrganizer
{
    // An ArrayList for storing music tracks.
    private ArrayList<Track> tracks;
    // A player for the music tracks.
    private MusicPlayer player;
    // A reader that can read music files and load them as tracks.
    private TrackReader reader;
    // Used to initialize the random feature.
    private Random randomtrack;

    /**
     * Create a MusicOrganizer
     */
    public MusicOrganizer()
    {
        tracks = new ArrayList<Track>();
        player = new MusicPlayer();
        reader = new TrackReader();
        randomtrack = new Random();
        readLibrary("audio");
        System.out.println("Music library loaded. " + getNumberOfTracks() + " tracks.");
        System.out.println();
    }

    /**
     * Add a track file to the collection.
     * @param filename The file name of the track to be added.
     */
    public void addFile(String filename)
    {
        tracks.add(new Track(filename));
    }

    /**
     * Add a track to the collection.
     * @param track The track to be added.
     */
    public void addTrack(Track track)
    {
        tracks.add(track);
    }

    /**
     * Play a track in the collection.
     * @param index The index of the track to be played.
     */
    public void playTrack(int index)
    {
        if(indexValid(index)) {
            Track track = tracks.get(index);
            player.startPlaying(track.getFilename());
            System.out.println("Now playing: " + track.getArtist() + " - " + track.getTitle());
        }
    }

    /**
     * Play a track in the collection at random.
     * @param index The index of the track to begin the randomizer.
     */
    public void randomTrack(int index)
    {
        int trackNumber = getNumberOfTracks();
        int rindex = randomtrack.nextInt(trackNumber);
        if(indexValid(index)) {
            Track track = tracks.get(rindex);
            player.startPlaying(track.getFilename());
            System.out.println("Now playing: " + track.getArtist() + " - " + track.getTitle());
        }
    }

    /**
     * Play all tracks in the collection at random.
     * @param index The index of the track to begin the randomizer.
     */
    public void randomAllTracks(int index)
    {
        int trackNumber = getNumberOfTracks();
        int rindex = randomtrack.nextInt(trackNumber);
        if(indexValid(index)) 
        {
            for(Track track : tracks)    
            {
            player.startPlaying(track.getFilename());
            System.out.println("Now playing: " + track.getArtist() + " - " +   track.getTitle());
            System.out.println();
            }


        }
    }

    /**
     * Return the number of tracks in the collection.
     * @return The number of tracks in the collection.
     */
    public int getNumberOfTracks()
    {
        return tracks.size();
    }

    /**
     * List a track from the collection.
     * @param index The index of the track to be listed.
     */
    public void listTrack(int index)
    {
        System.out.print("Track " + index + ": ");
        Track track = tracks.get(index);
        System.out.println(track.getDetails());
    }

    /**
     * Show a list of all the tracks in the collection.
     */
    public void listAllTracks()
    {
        System.out.println("Track listing: ");

        for(Track track : tracks) {
        System.out.println(track.getDetails());
        }
        System.out.println();
    }

    /**
     * List all tracks by the given artist.
     * @param artist The artist's name.
     */
    public void listByArtist(String artist)
    {
        for(Track track : tracks) {
            if(track.getArtist().contains(artist)) {
                System.out.println(track.getDetails());
            }
        }
    }

    /**
     * Remove a track from the collection.
     * @param index The index of the track to be removed.
     */
    public void removeTrack(int index)
    {
        if(indexValid(index)) {
            tracks.remove(index);
        }
    }

    /**
     * Play the first track in the collection, if there is one.
     */
    public void playFirst()
    {
        if(tracks.size() > 0) {
            player.startPlaying(tracks.get(0).getFilename());
        }
    }

    /**
     * Stop the player.
     */
    public void stopPlaying()
    {
        player.stop();
    }

    /**
     * Determine whether the given index is valid for the collection.
     * Print an error message if it is not.
     * @param index The index to be checked.
     * @return true if the index is valid, false otherwise.
     */
    private boolean indexValid(int index)
    {
        // The return value.
        // Set according to whether the index is valid or not.
        boolean valid;

        if(index < 0) {
            System.out.println("Index cannot be negative: " + index);
            valid = false;
        }
        else if(index >= tracks.size()) {
            System.out.println("Index is too large: " + index);
            valid = false;
        }
        else {
            valid = true;
        }
        return valid;
    }

    private void readLibrary(String folderName)
    {
        ArrayList<Track> tempTracks = reader.readTracks(folderName, ".mp3");

        // Put all thetracks into the organizer.
        for(Track track : tempTracks) {
            addTrack(track);
        }
    }
}

import java.util.ArrayList；
导入java.util.Random；
/**
*用于保存音频曲目详细信息的类。
*可以播放单独的曲目。
* 
*@作者威廉·甘比尔
*@版本2013年7月10日
*/
公共级音乐组织者
{
//用于存储音乐曲目的数组列表。
私有ArrayList轨道；
//用于播放音乐曲目的播放器。
私人音乐播放器；
//可以读取音乐文件并将其作为曲目加载的读取器。
私人轨道阅读器；
//用于初始化随机特征。
私有随机轨道；
/**
*创建一个音乐组织器
*/
公共音乐组织者（）
{
tracks=newarraylist（）；
player=新音乐播放器（）；
reader=新的TrackReader（）；
randomtrack=新随机（）；
readLibrary（“音频”）；
System.out.println（“音乐库已加载。”+getNumberOfTracks（）+“曲目”）；
System.out.println（）；
}
/**
*将曲目文件添加到集合中。
*@param filename要添加的曲目的文件名。
*/
公共void addFile（字符串文件名）
{
添加（新曲目（文件名））；
}
/**
*将曲目添加到集合中。
*@param track要添加的曲目。
*/
公共无效添加轨道（轨道）
{
tracks.add（track）；
}
/**
*播放集合中的曲目。
*@param index要播放的曲目的索引。
*/
公共void playTrack（int索引）
{
if（索引有效（索引））{
Track Track=tracks.get（索引）；
player.startPlaying（track.getFilename（））；
System.out.println（“正在播放：“+track.getArtist（）+”-“+track.getTitle（））；
}
}
/**
*随机播放集合中的曲目。
*@param index开始随机发生器的轨迹索引。
*/
公共轨道（整数索引）
{
int trackNumber=getNumberOfTracks（）；
int rindex=randomtrack.nextInt（trackNumber）；
if（索引有效（索引））{
Track Track=tracks.get（rindex）；
player.startPlaying（track.getFilename（））；
System.out.println（“正在播放：“+track.getArtist（）+”-“+track.getTitle（））；
}
}
/**
*随机播放集合中的所有曲目。
*@param index开始随机发生器的轨迹索引。
*/
公共轨道（整数索引）
{
int trackNumber=getNumberOfTracks（）；
int rindex=randomtrack.nextInt（trackNumber）；
if（索引有效（索引））
{
用于（轨道：轨道）
{
player.startPlaying（track.getFilename（））；
System.out.println（“正在播放：“+track.getArtist（）+”-“+track.getTitle（））；
System.out.println（）；
}
}
}
/**
*返回集合中的曲目数。
*@返回集合中的曲目数。
*/
public int getNumberOfTracks（）
{
返回轨迹。size（）；
}
/**
*列出收藏中的曲目。
*@param index要列出的曲目的索引。
*/
公共无效列表跟踪（整数索引）
{
系统输出打印（“轨道”+索引+“：”）；
Track Track=tracks.get（索引）；
System.out.println（track.getDetails（））；
}
/**
*显示集合中所有曲目的列表。
*/
public void listAllTracks（）
{
System.out.println（“跟踪列表：”）；
用于（轨道：轨道）{
System.out.println（track.getDetails（））；
}
System.out.println（）；
}
/**
*列出给定艺术家的所有曲目。
*@param-artist艺术家的名字。
*/
公共空列表艺术家（字符串艺术家）
{
用于（轨道：轨道）{
if（track.getArtist（）.contains（artist））{
System.out.println（track.getDetails（））；
}
}
}
/**
*从收藏中删除曲目。
*@param index要删除的曲目的索引。
*/
公共void removeTrack（int索引）
{
if（索引有效（索引））{
轨道。删除（索引）；
}
}
/**
*播放收藏中的第一首曲目（如果有）。
*/
公众优先
{
如果（tracks.size（）>0）{
player.startPlaying（tracks.get（0.getFilename（））；
}
}
/**
*阻止球员。
*/
公众假期
{
player.stop（）；
}
/**
*确定给定索引对集合是否有效。
*如果不正确，则打印错误消息。
*@param index要检查的索引。
*@如果索引有效，则返回true，否则返回false。
*/
私有布尔索引有效（整数索引）
{
//返回值。
//根据索引是否有效进行设置。
布尔有效；
如果（指数<0）{
System.out.println（“索引不能为负数：“+索引”）；
有效=错误；
}
else if（索引>=tracks.size（））{
System.out.println（“索引太大：“+Index”）；
有效=错误；
}
否则{
有效=真；
}
返回有效；
}
私有void readLibrary（字符串folderName）
{
ArrayList=reader.readTracks（folderName，.mp3”）；
//把所有的标签都放进记事本里。
用于（轨道：机架）{
addTrack（track）；
}
}
}

您可以在代码中使用吗？根据文件：

使用默认sourc随机排列指定的列表

public void randomAllTracks() {
    List<Track> randomList = buildRandomList();
    playList(randomList);
}

private List<Track> buildRandomList() {
    List<Track> randomList = new ArrayList<Track>(this.tracks);
    Collections.shuffle(randomList);

    return randomList;
}

public void playList(List<Track> playList) {
    if(playList.size() > 0) {
        for(Track track : playList) {
            player.startPlaying(track.getName());
        }
    }
}