关于1-5作业问题!!!!之前上交作业我想重新提交.

关于1-5作业问题!!!!之前上交作业我想重新提交.

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
package 逻辑包;
 
public class Song {
    //创建属性
    private String id;
    private String name;
     
    //创建空构造方法,用于实例化创建无参数对象
    public Song() {
         
    }
     
    //创建构造方法:用于外部实例化存储数据
    public Song(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
 
    //创建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;
    }
 
    //toString方法用于控制台输出样式
    @Override
    public String toString() {
        return "Song [id=" + id + ", name=" + name + "]";
    }
 
    @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());
        return result;
    }
     
    //hashCode方法防止输入数据一样导致崩溃
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if(obj.getClass()==Song.class) {
            Song song=(Song)obj;
            return song.getId().equals(id)&&song.getName().equals(name);
        }
        return false;
    }
     
     
     
}
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
package 逻辑包;
 
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
 
public class PlayList implements Serializable {
    /**
     
     */
    private static final long serialVersionUID = 1L;
    //属性:歌曲列表名称,歌曲集合List类型
    private String playListName;
    private List<Song> musicList=new ArrayList<>();
    static private Scanner sc=new Scanner(System.in);
    static PlayListCollection plc=new PlayListCollection();
     
    //构造方法
    public PlayList() {
         
    }
    //只存歌单名称的构造方法
    public PlayList(String playListName) {
        super();
        this.playListName = playListName;
    }
 
    //getter,setter
    public String getPlayListName() {
        return playListName;
    }
 
    public void setPlayListName(String playListName) {
        this.playListName = playListName;
    }
 
    public List<Song> getMusicList() {
        return musicList;
    }
 
    public void setMusicList(List<Song> musicList) {
        this.musicList = musicList;
    }
     
    //【增】添加歌曲方法:直接写无返回方法把歌曲写入参数表
    public void addToPlayList(Song song) {
        //创建boolean用于代表有没有歌曲
        boolean flag=false;
        //循环遍历歌曲列表
        for(Song song1:musicList) {
            //如果键盘输入的歌曲id和歌曲列表里的歌曲id一样就返回true代表有这首歌,利用这个true给新的if提示添加失败
            if(song1.getId().equals(song.getId())) {
                flag=true;
                break;//跳出该循环继续
            }
            //
            if(flag) {
                System.out.println("添加失败");
            }else {
                musicList.add(song);//直接添加方法参数里的song
            }
        }
    }
     
    //显示所有歌曲
    public void displayAllSong() {
        //增强for循环即可
        System.out.println("显示所有歌曲:");
        for(Song song:musicList) {
            System.out.println(song);
        }
    }
     
    //通过id查询歌曲
    public Song searchSongById(String id) {
        //设置歌曲对象为空,使用增强for循环设定song1,再用歌曲列表对象song1对比查询参数id,如果存在则把song1赋值给song,最后返回song;
        Song songId=null;
        for(Song song:musicList) {
            if(song.getId().equals(id)) {
                songId=song;
                break;
            }
        }
        return songId;
    }
     
    //通过名称查询歌曲
    public Song searchSongByName(String name) {
        Song songName=null;
        for(Song song:musicList) {
            if(song.getName().equals(name)) {
                songName=song;
                break;
            }
        }
        return songName;
    }
     
    //修改歌曲
    public void updateSong(Song song) {
        //搜索歌曲,搜到的键盘输入的歌曲删除再添加.song1是容器搜索到的数据.
        Song song1=searchSongById(song.getId());
        musicList.remove(song1);
        //删除完搜索到的数据后,再添加键盘输入实例化的数据
        musicList.add(song);
    }
     
    //导出歌曲文本
    public void outPut( ) {
        System.out.println("导出歌单");
        System.out.println("请输入要导出的播放列表名称:");
        String playListName=sc.next();
        PlayList SearchPL=plc.searchPlayListName(playListName);
        if(SearchPL!=null) {
            FileOutputStream fos;
            try {
                fos = new FileOutputStream(playListName + "歌单.txt");
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                 oos.writeObject(SearchPL);
                 oos.flush();
                 fos.close();
                 oos.close();
                 System.out.println("导出成功!");
            catch (FileNotFoundException e) {
                e.printStackTrace();
            catch (IOException e) {
                e.printStackTrace();
                System.out.println("导出失败!");
            }
             
        else {
            System.out.println("未找到该播放列表");
        }
    }
     
    //删除歌曲
    public void deleteSong(String id) {
        //使用搜索歌曲id方法,搜索到的id(搜索id是把整首歌曲赋值)赋值给歌曲类对象,直接歌曲列表调用删除方法删除song这首歌曲
        Song song=searchSongById(id);
        musicList.remove(song);
    }
 
}
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
package 逻辑包;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
 
public class PlayListCollection {
    //存播放器列表的集合,存播放列表名称playListName,key=String列表名称,value=PlayList取值使用歌曲
    static Map<String,PlayList> playListMap=new HashMap<>();
    static List<Song> list=new ArrayList<>();//歌曲的集合
    static int n;//键盘输入容器
    static private Scanner sc=new Scanner(System.in);
     
    //getter,setter方法用于提取和设置
    public static Map<String, PlayList> getPlayListMap() {
        return playListMap;
    }
    public static void setPlayListMap(Map<String, PlayList> playListMap) {
        PlayListCollection.playListMap = playListMap;
    }
     
    //添加播放列表
    public void addPlayList(PlayList playList) {
        try {
            //提取播放器列表的名称
            String playListName=playList.getPlayListName();
            playListMap.put(playListName, playList);//名字作为key,歌曲作为value存入hashMap集合(歌曲列表名称+歌曲一同存入集合)!如果没有歌曲只会存入空的列表
            System.out.println("添加播放列表成功");
        catch (Exception e) {
            System.out.println("有同名列表请重新输入!");
            e.printStackTrace();
        }
    }
     
    //删除播放列表
    public void deletePlayList(String name) {
        //通过boolean从HashMap里调用比对得出是否列表存在
        boolean yes=playListMap.containsKey(name);
        if(yes) {
            playListMap.remove(name);
            System.out.println("已删除");
        }else {
            System.out.println("该列表不存在");
        }
    }
     
    //通过名字查询播放列表
    public PlayList searchPlayListName(String PlayListName) {
        //通过boolean判断是否存在
        boolean yes=playListMap.containsKey(PlayListName);
        PlayList playList=null;//设定为空这是必要逻辑!
        if(yes) {
            playList=playListMap.get(PlayListName);
        }
        return playList;
    }
     
    //显示所有播放器列表名称
    public void displayPlayListName() {
        if(playListMap.isEmpty()) {
            System.out.println("还没创建播放列表!");
        }else {
            //用keySet方法通过value关键字显示歌曲列表
            Set<String>key=playListMap.keySet();
            //增强for循环显示
            for(String playListName:key) {
                System.out.println(playListName);
            }
        }
    }
}
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
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
package 逻辑包;
 
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
 
public class Console {
    //静态属性区
    static int n;//键盘输入容器
    static private Scanner sc=new Scanner(System.in);
    static PlayList musicList=new PlayList("主列表");
    static PlayList otherMusicList=new PlayList("其他列表");
    static PlayListCollection plc=new PlayListCollection();
     
    //菜单区域
    public static void mainManuTxt() {
        System.out.println("***********************");
        System.out.println("1-歌曲管理");
        System.out.println("2-播放器列表管理");
        System.out.println("0-退出");
        System.out.println("***********************");
        System.out.println("请输入对应数字操作:");
    }
     
    public static void playMusicManuTxt(){
        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("9-返回");
        System.out.println("***********************");
        System.out.println("请输入对应数字操作:");
    }
     
    public static void playListManuTxt() {
        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 playMusicManu() {
        //属性区
        //菜单区
        while(true) {
            playMusicManuTxt();
            n=sc.nextInt();
            //返回
            if(n==9) {
                break;
            }
            //循环主菜单调用方法
            switch(n) {
                case 1:
                    //添加歌曲
                    System.out.println("请输入添加歌曲数量:");
                    n=sc.nextInt();
                    //由于是批量添加所以用for循环添加
                    for(int i=1;i<=n;i++) {
                        //输入歌曲属性id,name
                        System.out.println("歌曲id:");
                        String strId=sc.next();
                        System.out.println("歌曲名称");
                        String strName=sc.next();
                        //实例化对象将键盘输入内容插入到容器里
                        Song song=new Song(strId,strName);
                        //插入这首歌曲到主播放器列表容器中,添加歌曲到List集合方法在方法中,所以这里只使用实例化对象调用方法把歌曲插入即可
                        musicList.addToPlayList(song);
                        System.out.println("前信息" + song);
                    }
                    break;
                case 2:
                    /*添加歌曲到副列表
                     * 1.需要判断要插入播放器列表是否存在<使用搜索列表方法作为返回值判断>
                     * 2.若不存在输入歌曲id,再判断这个歌曲id是否存在<使用搜索歌曲id方法作为返回值判断>,不存在就继续输入歌曲名称,
                     *        实例化歌曲对象将这些内容添加,再用最开始判断播放器列表的容器调用添加歌曲列表的方法加入歌曲即可
                     *        !添加歌曲列表的方法里有HashMap的put方法将歌曲和和列表都一同添加到集合中
                    */
                    System.out.println("当前播放器列表:");
                    plc.displayPlayListName();
                    System.out.println("------------------------");
                    System.out.println("输入播放列表名称");
                    String sName=sc.next();
                    //使用播放器列表搜索功能判断键盘输入的列表是否存在
                    PlayList newPlayList=plc.searchPlayListName(sName);
                    if(newPlayList==null) {
                        System.out.println("列表不存在!请先添加列表!");
                    }else {
                        System.out.println("请输入要添加的歌曲的数量:");
                        int count=sc.nextInt();
                        for(int i=1;i<=count;i++) {
                            System.out.println("请输入第"+i+"首歌曲:");
                            System.out.println("请输入歌曲id:");
                            String strId=sc.next();
                            //判断id是否存在主播放列表,利用搜索id方法把搜索到的整首歌曲赋值给song
                            Song song=musicList.searchSongById(strId);
                            if(song==null) {
                                //如果歌曲不存在则创建新的添加
                                System.out.println("该歌曲不存在,请继续添加:");
                                System.out.println("请输入歌曲名称:");
                                String strName = sc.next();
                                // 创建一个Song类的对象
                                Song songAdd = new Song(strId, strName);
                                //实例化的song
                                newPlayList.addToPlayList(songAdd);
                                musicList.addToPlayList(songAdd);
                            }else {
                                //存在否则直接添加到该播放器列表
                                newPlayList.addToPlayList(song);
                            }
                        }
                        //显示主播放器列表和新添加播放器列表
                        System.out.println("显示主播放器列表:");
                        musicList.displayAllSong();
                        System.out.println("显示新建播放器列表:");
                        newPlayList.displayAllSong();
                    }
                    break;
                case 3:
                    /*通过歌曲id查询播放列表中的歌曲
                     * 1.将键盘输入的对象pl代入查找播放器名称的方法,如果不存在跳出,存在则输入歌曲id,同样用查找歌曲id方法得到整首歌对象song
                     *    1>如果歌曲不存在则输出键盘输入的列表名称,存在则打印这首歌曲的信息(toString)
                     * */
                    System.out.println("通过歌曲id查询播放列表中的歌曲");
                    System.out.println("请输入要查询的播放列表名称:");
                    String strPlayListName=sc.next();
                    //查询播放列表是否存在并存入searchPL
                    PlayList SearchPL=plc.searchPlayListName(strPlayListName);
                    if(SearchPL==null) {
                        System.out.println("该"+strPlayListName+"播放列表不存在!");
                        break;
                    }else{
                         System.out.println("请输入要查询的歌曲id:");
                         String strId=sc.next();
                       //查询音乐id是否存在并存入SearchS
                         Song SearchS=musicList.searchSongById(strId);//查询到的结果的容器
                         if(SearchS==null) {
                             System.out.println("该"+strId+"歌曲不存在!");
                         }else {
                             System.out.println("该歌曲信息为:");
                             System.out.println(SearchS);
                         }
                    }
                    break;
                case 4:
                    /*修改歌曲
                     * 1.键盘输入,实例化代入
                     * 2.通过HashMap得到总集合A
                     * 3.通过总集合A用keySet得到歌曲列表B,因为HashMap集合的key设定的就是歌曲列表名称.
                     * 4.设定n=0是已经修改过了
                     * 5.for遍历B得到C[遍历次数],用A.get得到C设置成音乐容纳D
                     * 6.D调用搜索歌曲ID查找键盘输入的ID,进行判断歌曲列表名称里要修改的歌曲是否存在
                     * 7.如果存在(不为空)则调用修改歌曲方法,否则n++没修改
                     * 如果歌曲列表里有2首歌曲,没有进行修改歌曲,那n=2,如果n=2与歌曲列表里的总数值不同,那说明已经修改过了,所以为真.
                     * */
                    System.out.println("修改播放列表的歌曲:");
                    System.out.println("请输入要修改的歌曲ID:");
                    String strId2 = sc.next();
                    System.out.println("请输入修改后的歌曲名称");
                    String strName = sc.next();
                    // 创建song类的对象
                    Song song = new Song(strId2, strName);
                    //遍历总集合取到A
                    Map<String,PlayList>A=PlayListCollection.getPlayListMap();
                    //获得播放列表名称容器B
                    Set<String>B=A.keySet();
                    //设定是否被修改默认属性为0
                    n=0;
                    //遍历集合进行循环所有播放列表
                    for(String C:B) {
                        PlayList D=A.get(C);
                        Song song2=D.searchSongById(strId2);
                        if(song2!=null) {
                            D.updateSong(song);
                        }else {
                            n++;//如果没有歌曲没有输入则循环整个歌曲
                        }
                    }
                    //如果歌曲列表的长度不等于遍历循环的长度,说明在上面遍历循环时已经修改了歌曲
                    if(n!=B.size()) {
                        System.out.println("修改成功!");
                    }else {
                        System.out.println("该歌曲在所有播放列表中均不存在");
                    }
                    break;
                case 5:
                    /*删除歌曲
                     * 1.Map集合遍历所有播放器列表,通过Map集合利用keySet获取播放器列表名称
                     * 2.通过增强for循环来遍历所有播放器名称
                     *    1>遍历到的新的歌曲类对象=通过keySet的对象get取得for循环遍历的播放器名称(相当于得到所有当前加入的歌曲集合)
                     *    2>歌曲集合调用搜索歌曲id功能查询键盘输入的id,并赋值给对象.
                     *        1-如果歌曲不为空,则这个歌曲列表集合调用删除歌曲方法删除键盘录入的歌曲ID
                     *        2-否则判别歌曲是否被删除的count++
                     * 3.如果播放器列表.size!=count,说明歌曲列表的长度不等于歌曲列表里还有这首歌曲的长度,提示删除成功.否则不存在所有播放器列表里
                     * 小顺序:
                     * 1.Map取得容器总和
                     * 2.Set.keySet通过总和取得播放器名称
                     * 3.播放器容器遍历,将播放器名称汇总成容器,利用这个容器调用搜索歌曲方法查找键盘输入id汇总成这个歌曲,如果确实搜索到这个歌曲,就调用删除歌曲方法删除.否则没找到count对象+1
                     * 4....看程序
                     * */
                    System.out.println("删除播放列表中的歌曲");
                    System.out.println("请输入要删除的歌曲id:");
                    String strId=sc.next();
                    //取得歌单名称+歌曲集合赋值给Map集合,这个集合用于调用keySet得到播放列表名称
                    Map<String,PlayList> pl=PlayListCollection.getPlayListMap();
                    //通过keySet取得播放列表名称
                    Set<String>setName=pl.keySet();
                    int count=0;//代表删除成功的默认值
                    //遍历播放器列表名称
                    for(String playListName:setName) {
                        //通过Map集合的所有对象使用get方法取得遍历播放器列表,赋值给pl2,因为遍历的playListName取不到搜索歌曲id的方法,所以要通过Map集合get播放器列表做成播放器列表的容器属性
                        PlayList pl2=pl.get(playListName);
                        //这时可以用pl2调用搜索歌曲方法去查找键盘输入的id,不能直接用musicList实例对象调用,会造成搜索不到数据!!!!因为遍历才有数据!!!!
                        Song song1=pl2.searchSongById(strId);
                        //如果搜索的歌曲不为空,则删除
                        if(song1!=null) {
                            pl2.deleteSong(strId);//只能通过遍历出来的播放器集合容器对象才可以调取删除命令,上面的搜索歌曲只能调到歌单名称或者歌曲名称,并不是集合,这里只能用集合.
                        //否则count++没搜索到
                        }else {
                            count++;
                        }
                    }
                    //已删除音乐count还是默认值[0] 不等于 歌单列表为有数据[1],则删除成功,因为歌单列表为空
                    if(count!=setName.size()) {
                        System.out.println("删除成功!");
                    }else {
                        System.out.println("不存在播放器列表中!");
                    }
                    break;
                case 6:   
                    /*显示所有歌曲
                     * 1.查询键盘输入的播放列表是否存在
                     * 2.不存在则提示不能再,存在则显示所有.
                     * */
                    System.out.println("当前播放器列表:");
                    plc.displayPlayListName();
                    System.out.println("------------------------");
                    System.out.println("显示播放列表中的所有歌曲");
                    System.out.println("请输入要显示的播放列表名称:");
                    String displayAllSong = sc.next();
                    // 查询播放列表是否存在
                    PlayList pl3 = plc.searchPlayListName(displayAllSong);
                    if (pl3 == null) {
                        System.out.println("该播放列表不存在!");
                        break;
                    } else {
                        // 显示播放列表中的所有歌曲
                        pl3.displayAllSong();
                    }
                    break;
                case 7:
                    /*导出歌曲
                     * */
                    System.out.println("正在为输入导出的歌单命名!");
                    musicList.outPut();
                    break;
                default:
                    System.out.println("输入错误");
                    break;
            }
        }
    }
     
    //播放器列表增删改查方法
    public static void playListManu() {
        //循环
        while(true) {
            playListManuTxt();
            n = sc.nextInt();
             
            if (n == 9)
                break;
 
            switch(n){
            case 1:
                /*添加播放器列表
                 * */
                plc.addPlayList(musicList);
                System.out.println("请输入播放列表的名称:");
                String playListName = sc.next();
                PlayList normalPlayList = new PlayList(playListName);
                plc.addPlayList(normalPlayList);
                break;
            case 2:
                System.out.println("当前播放器列表:");
                plc.displayPlayListName();
                System.out.println("------------------------");
                System.out.println("请输入需要删除的播放列表:");
                String deletePlayListName = sc.next();
                plc.deletePlayList(deletePlayListName);
                break; // 通过名称删除播放列表
            case 3:
                System.out.println("当前播放器列表:");
                plc.displayPlayListName();
                System.out.println("------------------------");
                System.out.println("请输入需要查询的播放列表:");
                String searchPlayListName = sc.next();
                PlayList searchPlayList = plc.searchPlayListName(searchPlayListName);
                if(searchPlayList!=null) {
                    if(searchPlayList.getMusicList().size()!=0) {
                        System.out.println(searchPlayList.getMusicList());
                    } else {
                        System.out.println("该播放列表不存在歌曲!");
                    }
                     
                } else {
                    System.out.println("该播放列表不存在!");
                }
                break;
                 
            case 4:
                System.out.println("当前播放列表的名称为:");
                plc.displayPlayListName();
                break; // 显示所以播放列表
            }
        }
         
    }
     
    public static void main(String[] args) {
         
        /*菜单写法:
         * while(true){
         * 菜单方法;
         * 键盘输出n;
         * if(n==9){返回}
         *        switch(n){
         *            case1:歌曲管理方法;break;
         *            case2:播放器管理方法;break;
         *            case0:退出;
         *            default:输入错误
         *        }
         * }
        */
        while(true) {
            mainManuTxt();
            n=sc.nextInt();
                switch(n) {
                    case 1:playMusicManu();break;
                    case 2:playListManu();break;
                    case 0:System.exit(0);
                    default:System.out.println("输入错误");break;
                }
             
        }
    }
 
}

作业里有很多问题,目前第一个是无法显示所有歌曲,输入列表名字以后什么都不显示.后续,希望能和老师在这里把所有功能完善.

正在回答 回答被采纳积分+1

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

4回答
好帮手慕查理 2018-12-19 15:01:43

您好,我们运行您的代码,发现没有出现同学所说的问题。运行效果如下:

http://img1.sycdn.imooc.com//climg/5c19ebdd00016d6104220987.jpg

同学是在问答区贴出的代码基础上又修改代码了吗?同学也可以耐心等待一下作业批复文档。祝学习愉快!

  • 提问者 龍彦宏 #1
    我重新写了一遍,很奇怪,是不是win7问题?刚写好查询功能,搜索后没查到歌曲,我觉得的是键盘录入的内容没存入集合list里,不知道哪里错了?
    2018-12-19 15:08:53
  • 好帮手慕查理 回复 提问者 龍彦宏 #2
    您好,同学可以新建问答将全部代码反馈,我们无法判断您的代码进行了哪部分的修改是无法测试并查找问题的。或者同学先自己尝试修改,确认出现问题自己无法修改之后提问。祝学习愉快!
    2018-12-19 16:33:05
好帮手慕查理 2018-12-19 11:04:14

您好,运行现在已经贴出的代码并在修改添加歌曲的基础上,是可以添加歌曲到普通播放列表的,输入播放列表的名称也可以显示歌曲信息,同学具体指的是?请详细描述一下。

http://img1.sycdn.imooc.com//climg/5c19b2750001034304790616.jpg

http://img1.sycdn.imooc.com//climg/5c19b2a30001aefd07010752.jpg

祝学习愉快!

  • 提问者 龍彦宏 #1
    添加歌曲到副列表的方法执行的时候无法显示主菜单和自建菜单里的歌曲
    2018-12-19 14:34:38
好帮手慕查理 2018-12-18 18:07:46

您好,无法显示歌曲是因为添加歌曲时应该写在for循环外面:

http://img1.sycdn.imooc.com//climg/5c18c5b000017c1309550485.jpg

musicList需要进行初始化,如果不进行初始化操作时可能会出现空指针异常。具体可以根据报错信息提示的行数查看是调用哪个方法时出现的空指针异常。

您提交的作业老师会根据您提交的文档进行评分的,请耐心等待批复文档,先将您提出的问题进行解决。祝学习愉快!

  • 提问者 龍彦宏 #1
    好的,那有什么问题我再这里问您,谢谢!
    2018-12-18 18:52:32
  • 提问者 龍彦宏 #2
    musicList如何初始化呢?不知道怎么写
    2018-12-18 22:46:16
  • 提问者 龍彦宏 #3
    初始化搞定了,但无法显示主播放器和新增播放器里的音乐列表...不知道哪里问题,也没错误提示....
    2018-12-18 22:56:12
好帮手慕查理 2018-12-18 15:06:14

您好,查到您提交了工具类的作业,您是想让老师不批改您提交的文档,而批改您这版作业吗?请反馈。如果是的话,我们可以将您的代码反馈给老师。后续问题您也可以继续提问。祝学习愉快!

  • 提问者 龍彦宏 #1
    那个作业提交了不是要评分的吗?批改这个吧
    2018-12-18 15:24:24
  • 提问者 龍彦宏 #2
    那个作业也可以让老师批改,但要修改的细节一点,那代码有很多问题,需要更进一步学习.
    2018-12-18 15:36:56
  • 提问者 龍彦宏 #3
    老师,我把PlayList类里面的private List<Song> musicList=new ArrayList<>();改成private List<Song> musicList;出现空指针异常错误了,但找不到哪里的问题.所以请老师加紧帮忙批改我提交的那个,怎么也要判分,要不学分不够...谢谢了!
    2018-12-18 15:54:31
问题已解决,确定采纳
还有疑问,暂不采纳

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

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

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

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

帮助反馈 APP下载

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

公众号

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

在线咨询

领取优惠

免费试听

领取大纲

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