还是有点不清楚主播放列表的实例和普通播放列表实例的区分

还是有点不清楚主播放列表的实例和普通播放列表实例的区分

就是将歌曲添加到普通播放列表当中,播放列表里面不就一个集合实例么(是用来装主播放列表里面的歌曲的啊) 那么装普通播放列表的集合是怎么实现的

正在回答

登陆购买课程后可参与讨论,去登陆

4回答

例如List存放了所有的列表,包括普通列表和主播放列表,那怎么区分呢用map的KEY来区分,一个map就是一个播放列表,key是列表的名字,value存放Song对象,但又不止于一个Song,所以这个value存放的又是一个list列表。整体数据结构就是:List<Map<String,List<Song>>>。祝:学习愉快 

  • 荒小北158 提问者 #1
    非常感谢!
    2017-09-19 09:49:38
  • 荒小北158 提问者 #2
    老师`````我问题一堆 我在下面贴代码
    2017-09-19 09:59:33
好帮手慕雪 2017-09-19 11:19:37

1)87行  

1
2
Song songInfo = new Song("songId""songName""singerName");去掉双引号。 
Song songInfo = new Song(songId, songName, singerName);

2)94不对应该先找到主播放列表的歌曲list,然后添加到list中。把91行的for循环移动到80行上面,修改里面的内容,功能就是查询主播放列表的歌曲。

3) 

1
2
3
4
5
public void exportPlayList() {
        for(int i = 0; i < musicList.size(); i++) {
            System.out.println(musicList.get(i).toString());//Song有没有重写toString()?如果写了就改成musicList.get(i),如果没有就一个一个输出,例如Song song=musicList.get(i);然后输出song.getName()....
        }
    }

自己再调一下类似的问题,如果还有调不出来另起一个问答。内容太长不容易被发现。

提问者 荒小北158 2017-09-19 10:01:48
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
package com.imooc.test;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
 
import com.imooc.play.PlayList;
import com.imooc.play.PlayListCollection;
import com.imooc.play.Song;
 
public class TestDemo {
    //主菜单列表
    public static void mainMenu() {
        System.out.println("**************************");
        System.out.println("**主菜单**");
        System.out.println("1--播放列表管理");
        System.out.println("2--播放器管理");
        System.out.println("0--退出");
        System.out.println("**************************");
        System.out.println("请输入对应数字进行操作:");
    }
    // 播放列表菜单
        public static void playListMenu() {
            System.out.println("*********************");
            System.out.println("1--将歌曲添加到主播放列表");
            System.out.println("2--将歌曲添加到普通播放列表");
            System.out.println("3--通过歌曲id查询播放列表中的歌曲");
            System.out.println("4--通过歌曲名称查询播放列表中的歌曲");
            System.out.println("5--修改播放列表中的歌曲");
            System.out.println("6--删除播放列表中的歌曲");
            System.out.println("7--显示播放列表中的所有歌曲");
            System.out.println("8--导出歌单");
            System.out.println("9--返回上一级菜单");
            System.out.println("*********************");
            System.out.println("请输入对应的数字进行列表管理:");
        }
        //播放器列表管理菜单
        public static void playListCollectionMenu() {
            System.out.println("****************");
            System.out.println("1--向播放器添加播放列表");
            System.out.println("2--从播放器删除播放列表");
            System.out.println("3--通过名字查询播放列表名称");
            System.out.println("4--显示所有播放列表名称");
            System.out.println("9--返回上一级菜单");
            System.out.println("*****************");
            System.out.println("请输入对应的数字进行播放器管理:");
        }
    public static void main(String[] args) {
        //创建一个ArrayList实例,用于存储所有的播放列表信息(包含了 播放列表及其多对应的歌曲信息)
        List<PlayListCollection> bigList = new ArrayList<PlayListCollection>();
        //创建一个播放列表的实例
        PlayList playList = new PlayList("主播放列表",new ArrayList<Song>());
        int n = -1;
        //创建一个hashMap用于存储列表信息 作为传入给playListCollection的媒介
        HashMap<String,PlayList> map = new HashMap<String,PlayList>();
        map.put("主播放列表", playList);
        //创建一个播放器的实例
        PlayListCollection playListCollection = new PlayListCollection(map);//将map传入,也就是将主播放列表作为key值传入
        bigList.add(playListCollection); //将map对象存储在list中
         
        while( n!=0 ) {//用于控制退出程序
        mainMenu();//调用菜单列表方法
        Scanner in = new Scanner(System.in);
         n = in.nextInt();//输入对应列表数字
        switch(n) {
        case 1:
            while(n!=9) {//while循环用于控制返回上一级菜单
            playListMenu();//播放列表菜单
            n = in.nextInt();//输入对应列表数字
            switch(n) {
             
              //将歌曲添加到主播放列表
            case 1:
                System.out.println("将歌曲添加到主播放列表\n请输入要添加的歌曲的数量:");
                n = in.nextInt();
                for (int i = 0; i < n; i++) {
                    System.out.println("请输入第" + (i + 1) + "首歌曲\n请输入歌曲id:");
                    String songId = in.next();//输入歌曲的id
                    System.out.println("请输入歌曲的名称:");
                    String songName = in.next();//输入歌曲的名字
                    System.out.println("请输入演唱者:");
                    String singerName = in.next();//输入歌手的名字
                    Song songInfo = new Song("songId""songName""singerName");//为歌曲信息赋值
                    playList.addToPlayList(songInfo);
                    //遍历keySet
                    for(String key:map.keySet()) {
                        //找到主播放列表
                        if("主播放列表".equals(key)) {
                            map.put(key,playList);
                            playListCollection.setPlayListMap(map);//播放列表存储歌曲信息
                            break;//添加完毕则跳出循环
                        }
                }
                     
            }
            break;//添加完歌曲信息后跳出switch
            //将歌曲添加到普通播放列表
            case 2:
                System.out.println("将歌曲添加到普通播放列表\n请输入要添加的播放列表名称:");
                String strPlayListName = in.next();//输入播放列表的名称
                /*
                 * 首先要判断歌曲添加到的普通播放列表存不存在
                 */
                boolean flag = true;
                //取得keySet
                Set<String> keySet = playListCollection.getPlayListMap().keySet();
                //遍历keySet
                for(String key:keySet) {
                    //判断playListMap中是否存在要添加的播放列表
                    if(strPlayListName.equals(key)) {
                         
                         // 进入if说明找寻到了想要添加歌曲的播放列表,在if 语句里面完成歌曲的添加
                          
                        System.out.println("请输入要添加的歌曲的数量:");
                        n = in.nextInt();
                        for (int i = 0; i < n; i++) {
                            System.out.println("请输入第" + (i + 1) + "首歌曲\n请输入歌曲id:");
                            String songId = in.next();//输入歌曲的id
                            //判断添加歌曲的id是否存在于主播放列表
                            for(int k = 0; k < playList.getMusicList().size(); k++) {
                                if(songId.equals(((Song)(playList.getMusicList()).get(k)).getId())) {
                                    /*
                                     * 这里直接将主播放列表中的歌曲添加到普通播放列表中   这里有未完成代码!
                                     */
                                    flag = false;
                                    break;//找到与主播放列表里面相同的id,直接跳出循环
                                
                            }
                            if(flag) {
                                flag = true;
                                System.out.println("该歌曲在主播放列表不存在,继续输入歌曲的其他信息!");
                            }
                            System.out.println("请输入歌曲的名称:");
                            String songName = in.next();//输入歌曲的名字
                            System.out.println("请输入演唱者:");
                            String singerName = in.next();//输入歌手的名字
                            //判断主播放列表当中是否存在所要添加的歌曲id
                            Song songInfo = new Song("songId", "songName", "singerName");//为歌曲信息赋值
                            playList.addToPlayList(songInfo);//播放列表存储歌曲信息
                        }
                        flag = false;
                    }
                }
                if(flag) {
                    System.out.println("该播放列表不存在,请先将播放列表添加到播放器中!");
                }
                break;
                 
            //通过歌曲id查询播放列表中的歌曲
            case 3:
                System.out.println("通过歌曲id查询播放列表中的歌曲:\n请输入要查询的播放列表名称:");
                    String playListName = in.next();//输入播放列表的名称
                    flag = true;
                    //判断播放列表是否存在
                if(playListCollection.getPlayListMap().containsKey(playListName)) {
                    System.out.println("请输入要查询的歌曲:");
                    String songId = in.next();
                        //判断歌曲存不存在
                        if(playList.searchSongById(songId) == null) {
                            System.out.println("该歌曲在播放列表"+playListName+"不存在!");
                        } else {
                            System.out.println("歌曲的信息为:"+playList.searchSongById(songId).toString());
                        }  
                } else {
                    System.out.println("该播放列表不存在!请重新操作!");
                }
                break;
                 
             //通过歌曲名称查询播放列表中的歌曲
            case 4:
                System.out.println("通过歌曲的名称查询播放列表中的歌曲\n请输入要查询的播放列表名称:");
                playListName = in.next();//输入播放列表的名称
                flag = true;
                //判断播放列表是否存在
            if(playListCollection.getPlayListMap().containsKey(playListName)) {
                System.out.println("请输入要查询的歌曲名称:");
                String songName = in.next();
                    //判断歌曲存不存在
                    if(playList.searchSongByName(songName) == null) {
                        System.out.println("该歌曲在播放列表"+playListName+"不存在!");
                    } else {
                        System.out.println("歌曲的信息为:"+playList.searchSongByName(songName).toString());
                    }  
            } else {
                System.out.println("该播放列表不存在!请重新操作!");
            }
                break;
                 
            //修改播放列表中的歌曲
            case 5:
                System.out.println("修改播放列表中的歌曲:\n请输入要修改的歌曲id:");
                String songId = in.next();
                //判断歌曲id存不存在
                if(playList.searchSongById(songId) == null){
                    System.out.println("该歌曲不存在!请重新操作!");
                } else {
                    System.out.println("请输入修改后的歌曲名称:");
                    String songName = in.next();
                    System.out.println("请输入修改后的歌手名字:");
                    String singerName = in.next();
                    for(String key:playListCollection.getPlayListMap().keySet()) {
                        for(int i = 0; i<playListCollection.getPlayListMap().get(key).getMusicList().size();i++) {
                            if(songId.equals(((Song)(playListCollection.getPlayListMap().get(key).getMusicList().get(i))).getId())){
                                ((Song)(playListCollection.getPlayListMap().get(key).getMusicList().get(i))).setName(songName);
                                ((Song)(playListCollection.getPlayListMap().get(key).getMusicList().get(i))).setSinger(singerName);
                                break;
                            }
                        }
                        break;
                    }
                    System.out.println("修改成功!");
                }
                 
                break;
            //删除播放列表中的歌曲
            case 6:
                System.out.println("删除播放列表中的歌曲:\n请输入要删除的歌曲id:");
                songId = in.next();
                playList.deleteSong(songId);
                break;
                //显示播放列表中的歌曲
            case 7:
                System.out.println("显示播放列表中的所有歌曲\n请输入要显示的播放列表名称:");
                playListName = in.next();
                flag = true;
                for(String key:playListCollection.getPlayListMap().keySet()){
                    if(playListName.equals(key)) {
                        Iterator<PlayListCollection> it = bigList.iterator();
                        while(it.hasNext()) {
                            it.next().getPlayListMap().get(key).exportPlayList();
                        }
                        flag = false;
                        break;
                    }
                }
                if(flag) {
                    System.out.println("该播放列表不存在!请重新操作");
                }
                break;
             
              //导出歌单 (输入输出流)
            case 8:
                break;
                 
            case 9:
                n = 9;
                break;
            }
        }
        break;
        //播放器管理
        case 2:
             
            while(n!=9) {
            playListCollectionMenu();//播放器管理列表
            n = in.nextInt();//输入列表对应数字
            switch(n) {
            /*
             * 向播放器添加列表
             */
            case 1:
                System.out.println("向播放器添加播放列表\n输入要添加的播放列表名称:");
                String playListName = in.next();
                playList.setPlayListName(playListName);//列表名称的赋值
                playListCollection.addPlayList(playList);
                break;
                 
                  //从播放器中删除播放列表
            case 2:
                System.out.println("输入要删除的播放列表的名称:");
                playListName = in.next();//输入播放列表的名称
                if(playListCollection.getPlayListMap().containsKey(playListName)) {
                    playListCollection.deletePlayList(playList);
                else {
                    System.out.println("该播放列表不存在!请重新操作!");
                }
                break;
                 
                 //通过播放列表的名称查询列表内的信息
            case 3:
                System.out.println("通过名字查询播放列表信息:"+"\n请输入要查询的播放列表名称:");
                playListName = in.next();//输入要查询的播放列表名称
                playListCollection.searchPlayListByName(playListName);
                break;
                 
                 //显示所有的播放列表名称
            case 4:
                playListCollection.displayPlayListName();
            }
        }
            break;
        case 0:
            n = 0;
            System.out.println("谢谢使用!");
            break;
        }
        }
    }
 
}


  • 提问者 荒小北158 #1
    播放器类里面的 删除播放列表功能和通过查询列表名称来显示列表信息功能都有问题 还有播放列表类 添加歌曲之后我想显示列表中的歌曲也错了``````````哭》。。。。。。。。一塌糊涂
    2017-09-19 10:04:14
提问者 荒小北158 2017-09-19 10:00:52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package com.imooc.play;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class PlayList {
    private String playListName;//播放列表的名称
    private List<Song> musicList = new ArrayList<Song>();//储存歌曲信息的List集合
    //无参构造方法
    public PlayList() {
         
    }
     
    //带参构造方法
    public PlayList(String playListName, List musicList) {
        super();
        this.playListName = playListName;
        this.musicList = musicList;
    }
     
    //getter/setter
    public String getPlayListName() {
        return playListName;
    }
    public void setPlayListName(String playListName) {
        this.playListName = playListName;
    }
    public List getMusicList() {
        return musicList;
    }
    public void setMusicList(List musicList) {
        this.musicList = musicList;
    }
    //将歌曲添加到播放列表
    public void addToPlayList(Song song) {
        if(musicList.contains(song)){
            System.out.println("歌曲已经存在于播放列表!请勿重复操作!");
        else {
            musicList.add(song);
        }
    }
     
    //通过id查询歌曲
    public Song searchSongById(String id) {
        boolean flag = false;
        int i;
        for(i = 0; i < musicList.size(); i++) {
            if(id.equals((musicList.get(i)).getId())) {
                flag = true;
                break;
            
        }
        if(flag) {
            return musicList.get(i);
        else {
            return null;
        }
         
 
    }
    //通过名称查询歌曲
    public Song searchSongByName(String n) {
        int i;
        boolean flag = false;
        for( i = 0; i < musicList.size(); i++) {
             
            if (((Song)(musicList.get(i))).getName() == n) {
                flag = true;
                break;
            
        }
        if(flag) {
                return musicList.get(i);
            else{
                return null;
            }
    }
    //修改歌曲
    public void updateSong(Song song) {
         
    }
    //从播放列表中删除歌曲
    public void deleteSong(String id) {
        boolean flag = false;
        int n = 0;
        for (int i = 0; i < musicList.size(); i++) {
            if (id.equals(((Song) musicList.get(i)).getId())) {
                flag = true;
                n = i;
            }
        }
        if (flag) {
            musicList.remove(n);
        else {
            System.out.println("您要删除的歌曲不在播放列表中!");
        }
    }
    //显示播放列表中的所有歌曲
    public void exportPlayList() {
        for(int i = 0; i < musicList.size(); i++) {
            System.out.println(musicList.get(i).toString());
        }
    }
     
     
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package com.imooc.play;
 
public class Song {
    private String id;//歌曲的id
    private String name;//歌曲名称
    private String singer;//演唱者
    //构造方法
    public Song(String id, String name, String singer) {
        super();
        this.id = id;
        this.name = name;
        this.singer = singer;
    }
    //getter/setter
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSinger() {
        return singer;
    }
    public void setSinger(String singer) {
        this.singer = singer;
    }
    //重写toString()
    @Override
    public String toString() {
        return "[歌曲id:" + id + ", 歌曲:" + name + ", 演唱者:" + singer + "]";
    }
    //重写hashCode和equals
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((singer == null) ? 0 : singer.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Song other = (Song) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        else if (!id.equals(other.id))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        else if (!name.equals(other.name))
            return false;
        if (singer == null) {
            if (other.singer != null)
                return false;
        else if (!singer.equals(other.singer))
            return false;
        return true;
    }
     
     
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package com.imooc.play;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
 
 
public class PlayListCollection {
        private Map<String,PlayList> playListMap = new HashMap<String,PlayList>();
         
        //无参构造方法
        public PlayListCollection() {
             
        }
        //带参构造方法
        public PlayListCollection(Map<String, PlayList> playListMap) {
            super();
            this.playListMap = playListMap;
        }
 
        //setter/getter
        public Map<String, PlayList> getPlayListMap() {
            return playListMap;
        }
 
        public void setPlayListMap(Map<String, PlayList> playListMap) {
            this.playListMap = playListMap;
        }
         
        //添加播放列表
        public void addPlayList(PlayList playList) {
            boolean flag = true;
            //取得keySet
            Set<String> keySet = playListMap.keySet();
            //遍历keySet
            for(String key:keySet) {
                //遍历中如果找到map中的key值与我们添加的播放列表名相同则无法添加
                if((playList.getPlayListName()).equals(key)) {
                    System.out.println("该播放列表存在!\n该播放列表的名称为:"+key);
                    flag = false;
                    break;
                }
            }
            if(flag) {
                playListMap.put(playList.getPlayListName(), null);
            
        }
        //删除播放列表
        public void deletePlayList(PlayList playList) {
             
        }
        //通过名字查询
        public PlayList searchPlayListByName(String playListName) {
            boolean flag = true;
            //取得keySet
            Set<String> keySet = playListMap.keySet();
            //遍历keySet
            for(String key:keySet) {
                //如果要查询的列表名字与某个key相同  则输出该列表的相关信息
                if(playListName.equals(key)) {
                    System.out.println("该播放列表存在!\n该播放列表的名称为:"+key+
                            "\n播放列表中的所有歌曲为:"+((Song)(playListMap.get(key).getMusicList())).toString());
                    flag = false;
                    break;
                }
                if(flag) {
                    System.out.println("该播放列表不存在!");
                }
                 
            }
           return null;
        }
        //显示所有播放列表名称
        public void displayPlayListName() {
            //通过keySet来输出playListMap中所有的key(播放列表名称)
            Set<String> keySet = playListMap.keySet();
            System.out.println("显示所有的播放列表名称:"+"\n播放列表的名称:");
            for(String key:keySet) {
                System.out.println(key);
            }
        }
         
}


  • 提问者 荒小北158 #1
    老师耐心帮我看看吧````我已经花很长时间了
    2017-09-19 10:04:58
问题已解决,确定采纳
还有疑问,暂不采纳

恭喜解决一个难题,获得1积分~

来为老师/同学的回答评分吧

0 星
请稍等 ...
微信客服

购课补贴
联系客服咨询优惠详情

帮助反馈 APP下载

慕课网APP
您的移动学习伙伴

公众号

扫描二维码
关注慕课网微信公众号

在线咨询

领取优惠

免费试听

领取大纲

扫描二维码,添加
你的专属老师
插入代码