java_mzd
- 浏览: 580551 次
- 性别:
- 来自: 长沙
-
最新评论
-
lingyigeshijie_：
说的很明白
java多线程并发编程与CPU时钟分配小议 -
程序员是怎么炼成的：
initCacpcity和loadFactor为什么要stat ...
Hash表分析以及Java实现 -
snails：
博主很用心啊，以下文章也挺好的jdk和jre的区别
JDK,JRE,JVM区别与联系 -
newbee_zc：
我要向你学习！
淘宝武汉*面试归来 -
南瓜猿：
。。。联盟招收小学弟吗- -
迷途，归来
跟着Mars老师
一起写android中的Mp3播放器
真是受益匪浅
再次感谢老师的无私奉献
不过其中问题也确实不少
感觉老师的代码重构做的不够
其中对LRC文件的解析也弄的比较马虎
今天特意花了一天的时间
好好研究了正则表达式
也仔细思索了LRC文件到底应该怎么来解析
以下先分析思路
再给出实现代码
首先
我们应该明白LRC文件的组成
LRC文件本质就是个符合一定格式规范的文本文件
这一点对照XML文件就很好理解了
一个LRC文件的组成
通常由以下几个部分组成
[ti:约定]-------标题
[ar:周惠]------演唱者
[al:周蕙－精选]-------专辑
[00:26.00]远处的钟声回荡在雨里--------每句内容由一个时间点和内容组成
同时应该注意到
[02:23.00][00:49.00]一路从泥泞走到了美景---------在每个内容可能出现多个时间点
然后
我们 用一个实体类
LrcInfo
来封装每个Lrc文件的具体内容
package javamzd.mp3player.Info;
import java.util.HashMap;
/**
* 用来封装歌词信息的类
* @author Administrator
*
*/
public class LrcInfo {
private String title;//歌曲名
private String singer;//演唱者
private String album;//专辑
private HashMap<Long,String> infos;//保存歌词信息和时间点一一对应的Map
//以下为getter() setter()
}
3.读入Lrc文件，开始逐行解析
解析步骤：
1.读入文件
2.封装为BufferedReader对象
3.调用readline()方法逐行读取数据，得到String str
4.用parser()方法解析每一条具体的String语句
5.每句解析完后，将得到的内容在LrcInfo对象中进行设置
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 此类用来解析LRC文件 将解析完整的LRC文件放入一个LrcInfo对象中 并且返回这个LrcInfo对象s author:java_mzd
*/
public class LrcParser {
private LrcInfo lrcinfo = new LrcInfo();
private long currentTime = 0;//存放临时时间
private String currentContent = null;//存放临时歌词
private Map<Long, String> maps = new HashMap<Long, String>();//用户保存所有的歌词和时间点信息间的映射关系的Map
/**
* 根据文件路径，读取文件，返回一个输入流
*
* @param path
* 路径
* @return 输入流
* @throws FileNotFoundException
*/
private InputStream readLrcFile(String path) throws FileNotFoundException {
File f = new File(path);
InputStream ins = new FileInputStream(f);
return ins;
}
public LrcInfo parser(String path) throws Exception {
InputStream in = readLrcFile(path);
lrcinfo = parser(in);
return lrcinfo;
}
/**
* 将输入流中的信息解析，返回一个LrcInfo对象
*
* @param inputStream
* 输入流
* @return 解析好的LrcInfo对象
* @throws IOException
*/
public LrcInfo parser(InputStream inputStream) throws IOException {
// 三层包装
InputStreamReader inr = new InputStreamReader(inputStream);
BufferedReader reader = new BufferedReader(inr);
// 一行一行的读，每读一行，解析一行
String line = null;
while ((line = reader.readLine()) != null) {
parserLine(line);
}
// 全部解析完后，设置info
lrcinfo.setInfos(maps);
return lrcinfo;
}
/**
* 利用正则表达式解析每行具体语句
* 并在解析完该语句后，将解析出来的信息设置在LrcInfo对象中
*
* @param str
*/
private void parserLine(String str) {
// 取得歌曲名信息
if (str.startsWith("[ti:")) {
String title = str.substring(4, str.length() - 1);
System.out.println("title--->" + title);
lrcinfo.setTitle(title);
}// 取得歌手信息
else if (str.startsWith("[ar:")) {
String singer = str.substring(4, str.length() - 1);
System.out.println("singer--->" + singer);
lrcinfo.setSinger(singer);
}// 取得专辑信息
else if (str.startsWith("[al:")) {
String album = str.substring(4, str.length() - 1);
System.out.println("album--->" + album);
lrcinfo.setAlbum(album);
}// 通过正则取得每句歌词信息
else {
// 设置正则规则
String reg = "\\[(\\d{2}:\\d{2}\\.\\d{2})\\]";
// 编译
Pattern pattern = Pattern.compile(reg);
Matcher matcher = pattern.matcher(str);
// 如果存在匹配项，则执行以下操作
while (matcher.find()) {
// 得到匹配的所有内容
String msg = matcher.group();
// 得到这个匹配项开始的索引
int start = matcher.start();
// 得到这个匹配项结束的索引
int end = matcher.end();
// 得到这个匹配项中的组数
int groupCount = matcher.groupCount();
// 得到每个组中内容
for (int i = 0; i <= groupCount; i++) {
String timeStr = matcher.group(i);
if (i == 1) {
// 将第二组中的内容设置为当前的一个时间点
currentTime = strToLong(timeStr);
}
}
// 得到时间点后的内容
String[] content = pattern.split(str);
// 输出数组内容
for (int i = 0; i < content.length; i++) {
if (i == content.length - 1) {
// 将内容设置为当前内容
currentContent = content[i];
}
}
// 设置时间点和内容的映射
maps.put(currentTime, currentContent);
System.out.println("put---currentTime--->" + currentTime
+ "----currentContent---->" + currentContent);
}
}
}
/**
* 将解析得到的表示时间的字符转化为Long型
*
* @param group
* 字符形式的时间点
* @return Long形式的时间
*/
private long strToLong(String timeStr) {
// 因为给如的字符串的时间格式为XX:XX.XX,返回的long要求是以毫秒为单位
// 1:使用：分割 2：使用.分割
String[] s = timeStr.split(":");
int min = Integer.parseInt(s[0]);
String[] ss = s[1].split("\\.");
int sec = Integer.parseInt(ss[0]);
int mill = Integer.parseInt(ss[1]);
return min * 60 * 1000 + sec * 1000 + mill * 10;
}
public static void main(String[] args) {
LrcParser lp = new LrcParser();
try {
lp.parser("G:\\WebRoot\\a1.lrc");
} catch (Exception e) {
System.out.println("parser erro");
e.printStackTrace();
}
}
}
以上代码难度都不大
个人觉得
正则表达式其实并不难
只是因为有很多不规则符号堆叠在一起
让我们直观的很难理解
掌握符号规则后
还是挺好用的
正则表达在JAVA中都被封装在
regex包下面
主要是Pattern类与Matcher类
其实我个人在掌握了正则的基本概念后
用JAVA写这个代码却花了不少时间
主要是对这两个对象中的一些方法理解错误
以下简单总结下
两个类中易理解错的方法
Matcher对象中
matcher()方法是匹配整个字符串
lookingat()是匹配字符串的开头
find()是查找字符串中能否匹配
使用find()方法
得到一个字符串中的匹配后
matcher.start()得到这个匹配的startIndex
matcher.end()得到这个匹配的endIndex
matcher.group()能得到满足匹配的全部内容（最大的一个组）
matcher.groupCount()能得到当前匹配中的组数------（在正则中用（）包围起来的一个部分算一个单独的组）
marcher.group(i) 得到指定的某个组的内容
又通过matcher.find()
我们可能在某一行可以得到多个匹配结果
每当调用一次matcher.find()
当前匹配对象就自动换为下个匹配成功对象
要遍历所有匹配结果
//遍历每个匹配成功对象
while (matcher.find()) {
//对每一个匹配对象的操作
// 得到匹配的所有内容 String msg = matcher.group(); // 得到这个匹配项开始的索引 int start = matcher.start(); // 得到这个匹配项结束的索引 int end = matcher.end(); // 得到这个匹配项中的组数 int groupCount = matcher.groupCount(); // 得到每个组中内容 for (int i = 0; i <= groupCount; i++) { String timeStr = matcher.group(i); if (i == 1) { // 将第二组中的内容设置为当前的一个时间点 currentTime = strToLong(timeStr); } } // 得到时间点后的内容 String[] content = pattern.split(str); // 输出数组内容 for (int i = 0; i < content.length; i++) { if (i == content.length - 1) { // 将内容设置为当前内容 currentContent = content[i]; } }
最后
我们解析完LRC文件后
在播放Mp3时
只需要根据播放时间
取出HashMap中的内容进行显示即可
分享到：
评论
14 楼
一念之间.
2013-12-19
看到LZ和道友们的热烈讨论 分享其解决的优化方案 真是受益匪浅 。氛围太好了。
13 楼
lucky_jayce
2013-05-16
文章很好，寫的不錯。
不過我解析lrc發現一點小缺陷。
1.lrc的編碼問題（我解析的歌詞編碼是gbk，但是解析后亂碼）
2.lrc的解析后的時間排序問題。（歌詞 [00:42.83][01:55.97]你的小小情绪对我来说 ） 這段歌詞解析后沒能根據時間排序。
我稍微改動下，代碼如下
package javamzd.mp3player.Info;
import java.util.Map;
/**
* 用来封装歌词信息的类
* @author Administrator
*
*/
public class LrcInfo {
private String title;//歌曲名
private String singer;//演唱者
private String album;//专辑
private Map<Long,String> infos;//保存歌词信息和时间点一一对应的Map
//以下为getter() setter()
}
package d;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 此类用来解析LRC文件 将解析完整的LRC文件放入一个LrcInfo对象中 并且返回这个LrcInfo对象s author:java_mzd
*/
public class LrcParser {
private LrcInfo lrcinfo = new LrcInfo();
private long currentTime = 0;// 存放临时时间
private String currentContent = null;// 存放临时歌词
private Map<Long, String> maps = new TreeMap<Long, String>();// 用户保存所有的歌词和时间点信息间的映射关系的Map
/**
* 根据文件路径，读取文件，返回一个输入流
*
* @param path
* 路径
* @return 输入流
* @throws FileNotFoundException
*/
private InputStream readLrcFile(String path) throws FileNotFoundException {
File f = new File(path);
InputStream ins = new FileInputStream(f);
return ins;
}
public LrcInfo parser(String path) throws Exception {
InputStream in = readLrcFile(path);
lrcinfo = parser(in);
return lrcinfo;
}
public LrcInfo parser(String path, Charset charset) throws Exception {
InputStream in = readLrcFile(path);
lrcinfo = parser(in, charset);
return lrcinfo;
}
/**
* 将输入流中的信息解析，返回一个LrcInfo对象
*
* @param inputStream
* 输入流
* @return 解析好的LrcInfo对象
* @throws IOException
*/
public LrcInfo parser(InputStream inputStream) throws IOException {
return parser(inputStream, Charset.defaultCharset());
}
public LrcInfo parser(InputStream inputStream, Charset charset)
throws IOException {
// 三层包装
InputStreamReader inr = new InputStreamReader(inputStream, charset);
BufferedReader reader = new BufferedReader(inr);
// 一行一行的读，每读一行，解析一行
String line = null;
while ((line = reader.readLine()) != null) {
parserLine(line);
}
// 全部解析完后，设置info
lrcinfo.setInfos(maps);
return lrcinfo;
}
/**
* 利用正则表达式解析每行具体语句 并在解析完该语句后，将解析出来的信息设置在LrcInfo对象中
*
* @param str
*/
private void parserLine(String str) {
// 取得歌曲名信息
if (str.startsWith("[ti:")) {
String title = str.substring(4, str.length() - 1);
System.out.println("title--->" + title);
lrcinfo.setTitle(title);
}// 取得歌手信息
else if (str.startsWith("[ar:")) {
String singer = str.substring(4, str.length() - 1);
System.out.println("singer--->" + singer);
lrcinfo.setSinger(singer);
}// 取得专辑信息
else if (str.startsWith("[al:")) {
String album = str.substring(4, str.length() - 1);
System.out.println("album--->" + album);
lrcinfo.setAlbum(album);
}// 通过正则取得每句歌词信息
else {
// 设置正则规则
String reg = "\\[(\\d{2}:\\d{2}\\.\\d{2})\\]";
// 编译
Pattern pattern = Pattern.compile(reg);
Matcher matcher = pattern.matcher(str);
// 如果存在匹配项，则执行以下操作
while (matcher.find()) {
// 得到匹配的所有内容
String msg = matcher.group();
// 得到这个匹配项开始的索引
int start = matcher.start();
// 得到这个匹配项结束的索引
int end = matcher.end();
// 得到这个匹配项中的组数
int groupCount = matcher.groupCount();
// 得到每个组中内容
for (int i = 0; i <= groupCount; i++) {
String timeStr = matcher.group(i);
if (i == 1) {
// 将第二组中的内容设置为当前的一个时间点
currentTime = strToLong(timeStr);
}
}
// 得到时间点后的内容
String[] content = pattern.split(str);
// 输出数组内容
for (int i = 0; i < content.length; i++) {
if (i == content.length - 1) {
// 将内容设置为当前内容
currentContent = content[i];
}
}
// 设置时间点和内容的映射
maps.put(currentTime, currentContent);
}
}
}
/**
* 将解析得到的表示时间的字符转化为Long型
*
* @param group
* 字符形式的时间点
* @return Long形式的时间
*/
private long strToLong(String timeStr) {
// 因为给如的字符串的时间格式为XX:XX.XX,返回的long要求是以毫秒为单位
// 1:使用：分割 2：使用.分割
String[] s = timeStr.split(":");
int min = Integer.parseInt(s[0]);
String[] ss = s[1].split("\\.");
int sec = Integer.parseInt(ss[0]);
int mill = Integer.parseInt(ss[1]);
return min * 60 * 1000 + sec * 1000 + mill * 10;
}
public static void main(String[] args) {
LrcParser lp = new LrcParser();
try {
LrcInfo info = lp.parser("D:\\1.lrc", Charset.forName("gbk"));
System.out.println(info);
} catch (Exception e) {
System.out.println("parser erro");
e.printStackTrace();
}
}
}
不過我解析lrc發現一點小缺陷。
1.lrc的編碼問題（我解析的歌詞編碼是gbk，但是解析后亂碼）
2.lrc的解析后的時間排序問題。（歌詞 [00:42.83][01:55.97]你的小小情绪对我来说 ） 這段歌詞解析后沒能根據時間排序。
我稍微改動下，代碼如下
package javamzd.mp3player.Info;
import java.util.Map;
/**
* 用来封装歌词信息的类
* @author Administrator
*
*/
public class LrcInfo {
private String title;//歌曲名
private String singer;//演唱者
private String album;//专辑
private Map<Long,String> infos;//保存歌词信息和时间点一一对应的Map
//以下为getter() setter()
}
package d;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 此类用来解析LRC文件 将解析完整的LRC文件放入一个LrcInfo对象中 并且返回这个LrcInfo对象s author:java_mzd
*/
public class LrcParser {
private LrcInfo lrcinfo = new LrcInfo();
private long currentTime = 0;// 存放临时时间
private String currentContent = null;// 存放临时歌词
private Map<Long, String> maps = new TreeMap<Long, String>();// 用户保存所有的歌词和时间点信息间的映射关系的Map
/**
* 根据文件路径，读取文件，返回一个输入流
*
* @param path
* 路径
* @return 输入流
* @throws FileNotFoundException
*/
private InputStream readLrcFile(String path) throws FileNotFoundException {
File f = new File(path);
InputStream ins = new FileInputStream(f);
return ins;
}
public LrcInfo parser(String path) throws Exception {
InputStream in = readLrcFile(path);
lrcinfo = parser(in);
return lrcinfo;
}
public LrcInfo parser(String path, Charset charset) throws Exception {
InputStream in = readLrcFile(path);
lrcinfo = parser(in, charset);
return lrcinfo;
}
/**
* 将输入流中的信息解析，返回一个LrcInfo对象
*
* @param inputStream
* 输入流
* @return 解析好的LrcInfo对象
* @throws IOException
*/
public LrcInfo parser(InputStream inputStream) throws IOException {
return parser(inputStream, Charset.defaultCharset());
}
public LrcInfo parser(InputStream inputStream, Charset charset)
throws IOException {
// 三层包装
InputStreamReader inr = new InputStreamReader(inputStream, charset);
BufferedReader reader = new BufferedReader(inr);
// 一行一行的读，每读一行，解析一行
String line = null;
while ((line = reader.readLine()) != null) {
parserLine(line);
}
// 全部解析完后，设置info
lrcinfo.setInfos(maps);
return lrcinfo;
}
/**
* 利用正则表达式解析每行具体语句 并在解析完该语句后，将解析出来的信息设置在LrcInfo对象中
*
* @param str
*/
private void parserLine(String str) {
// 取得歌曲名信息
if (str.startsWith("[ti:")) {
String title = str.substring(4, str.length() - 1);
System.out.println("title--->" + title);
lrcinfo.setTitle(title);
}// 取得歌手信息
else if (str.startsWith("[ar:")) {
String singer = str.substring(4, str.length() - 1);
System.out.println("singer--->" + singer);
lrcinfo.setSinger(singer);
}// 取得专辑信息
else if (str.startsWith("[al:")) {
String album = str.substring(4, str.length() - 1);
System.out.println("album--->" + album);
lrcinfo.setAlbum(album);
}// 通过正则取得每句歌词信息
else {
// 设置正则规则
String reg = "\\[(\\d{2}:\\d{2}\\.\\d{2})\\]";
// 编译
Pattern pattern = Pattern.compile(reg);
Matcher matcher = pattern.matcher(str);
// 如果存在匹配项，则执行以下操作
while (matcher.find()) {
// 得到匹配的所有内容
String msg = matcher.group();
// 得到这个匹配项开始的索引
int start = matcher.start();
// 得到这个匹配项结束的索引
int end = matcher.end();
// 得到这个匹配项中的组数
int groupCount = matcher.groupCount();
// 得到每个组中内容
for (int i = 0; i <= groupCount; i++) {
String timeStr = matcher.group(i);
if (i == 1) {
// 将第二组中的内容设置为当前的一个时间点
currentTime = strToLong(timeStr);
}
}
// 得到时间点后的内容
String[] content = pattern.split(str);
// 输出数组内容
for (int i = 0; i < content.length; i++) {
if (i == content.length - 1) {
// 将内容设置为当前内容
currentContent = content[i];
}
}
// 设置时间点和内容的映射
maps.put(currentTime, currentContent);
}
}
}
/**
* 将解析得到的表示时间的字符转化为Long型
*
* @param group
* 字符形式的时间点
* @return Long形式的时间
*/
private long strToLong(String timeStr) {
// 因为给如的字符串的时间格式为XX:XX.XX,返回的long要求是以毫秒为单位
// 1:使用：分割 2：使用.分割
String[] s = timeStr.split(":");
int min = Integer.parseInt(s[0]);
String[] ss = s[1].split("\\.");
int sec = Integer.parseInt(ss[0]);
int mill = Integer.parseInt(ss[1]);
return min * 60 * 1000 + sec * 1000 + mill * 10;
}
public static void main(String[] args) {
LrcParser lp = new LrcParser();
try {
LrcInfo info = lp.parser("D:\\1.lrc", Charset.forName("gbk"));
System.out.println(info);
} catch (Exception e) {
System.out.println("parser erro");
e.printStackTrace();
}
}
}
12 楼
zorro668
2010-12-26
zhengyutong 写道
楼主的羊羔体写的很不错。
更像“梨花体”
11 楼
java_mzd
2010-11-16
JE帐号 写道
我觉得LZ你没完全看懂"nuclearg"的意思.
他的意思是,你没有考虑怎么获取两句歌词时间间隔,以及预读取后面歌词的问题.因为他认为歌词在显示的时候是滚动状态的.
考虑一下,假如一首歌,有两句之间时间间隔只有0.5s,而另外两句时间间隔有5s,那么你就很难用一个全局的滚动速度来显示这四句歌词了.另外,考虑一下,如果我要求你除了显示当前歌词,还给把下三条也给显示出来,你怎么办?
当然,如果你的歌词不是滚动状态,而是只显示一行,那无所谓了.
但是,我的意见是,在这个场景下,你使用一个Map作为歌词显示的model这种做法不是很好.为什么不考虑在解析完歌词后直接将歌词按照一定规则编录一下呢.然后也不要定时更新歌词了,每次除了返回要显示的歌词外,也可以考虑返回一句歌词需要在多久以后显示的信息,这样可能你只需要每个1到2秒才postDelayed一次,比起现在的10ms,每秒就可以少100次.
他的意思是,你没有考虑怎么获取两句歌词时间间隔,以及预读取后面歌词的问题.因为他认为歌词在显示的时候是滚动状态的.
考虑一下,假如一首歌,有两句之间时间间隔只有0.5s,而另外两句时间间隔有5s,那么你就很难用一个全局的滚动速度来显示这四句歌词了.另外,考虑一下,如果我要求你除了显示当前歌词,还给把下三条也给显示出来,你怎么办?
当然,如果你的歌词不是滚动状态,而是只显示一行,那无所谓了.
但是,我的意见是,在这个场景下,你使用一个Map作为歌词显示的model这种做法不是很好.为什么不考虑在解析完歌词后直接将歌词按照一定规则编录一下呢.然后也不要定时更新歌词了,每次除了返回要显示的歌词外,也可以考虑返回一句歌词需要在多久以后显示的信息,这样可能你只需要每个1到2秒才postDelayed一次,比起现在的10ms,每秒就可以少100次.
多谢多谢
醍醐灌顶
呵呵
恩
我明白了。
等会就改了尝试尝试
10 楼
JE帐号
2010-11-16
我觉得LZ你没完全看懂"nuclearg"的意思.
他的意思是,你没有考虑怎么获取两句歌词时间间隔,以及预读取后面歌词的问题.因为他认为歌词在显示的时候是滚动状态的.
考虑一下,假如一首歌,有两句之间时间间隔只有0.5s,而另外两句时间间隔有5s,那么你就很难用一个全局的滚动速度来显示这四句歌词了.另外,考虑一下,如果我要求你除了显示当前歌词,还给把下三条也给显示出来,你怎么办?
当然,如果你的歌词不是滚动状态,而是只显示一行,那无所谓了.
但是,我的意见是,在这个场景下,你使用一个Map作为歌词显示的model这种做法不是很好.为什么不考虑在解析完歌词后直接将歌词按照一定规则编录一下呢.然后也不要定时更新歌词了,每次除了返回要显示的歌词外,也可以考虑返回一句歌词需要在多久以后显示的信息,这样可能你只需要每个1到2秒才postDelayed一次,比起现在的10ms,每秒就可以少100次.
他的意思是,你没有考虑怎么获取两句歌词时间间隔,以及预读取后面歌词的问题.因为他认为歌词在显示的时候是滚动状态的.
考虑一下,假如一首歌,有两句之间时间间隔只有0.5s,而另外两句时间间隔有5s,那么你就很难用一个全局的滚动速度来显示这四句歌词了.另外,考虑一下,如果我要求你除了显示当前歌词,还给把下三条也给显示出来,你怎么办?
当然,如果你的歌词不是滚动状态,而是只显示一行,那无所谓了.
但是,我的意见是,在这个场景下,你使用一个Map作为歌词显示的model这种做法不是很好.为什么不考虑在解析完歌词后直接将歌词按照一定规则编录一下呢.然后也不要定时更新歌词了,每次除了返回要显示的歌词外,也可以考虑返回一句歌词需要在多久以后显示的信息,这样可能你只需要每个1到2秒才postDelayed一次,比起现在的10ms,每秒就可以少100次.
9 楼
java_mzd
2010-11-16
bitray 写道
播放器可以提前加载整个歌词，然后在每次计算下句时间到本句时间之间的间隔和歌词间距，然后使用平均速度进行滚动就可以了。
如果是时间轮询反复去查是非常浪费资源的，尤其你是为手机开发程序的话，更要重视资源啊，因为手机的内存资源和硬件都是很有限。一点一滴不能浪费啊
如果是时间轮询反复去查是非常浪费资源的，尤其你是为手机开发程序的话，更要重视资源啊，因为手机的内存资源和硬件都是很有限。一点一滴不能浪费啊
呵呵
Good Question
在手机开发中确实资源是个很重要的问题
“按时间轮询”这句话确实是我自己表述错误了
在android中，用Handler的post()方法启动新线程的时候是调用的该线程的run()方法
然后我只需要在这个run()方法的最后，加上一句handler.postDelayed(updateTimeCallback, 10);这样就能实现每10MS重新启动这个更新歌词线程一次，而且其实都是在主线程内运行的
当然
可能这样又会有朋友质疑：其实这就是个方法的递归调用了。
不过Android中用Handler调用新线程，不用Looper对象，直接post()的话，确实是在主线程中运行的，这样实现确实效果和递归调用个更新歌词方法很相似
不过这样的有点却也是递归调用没有的
递归调用如果这样一直递归的话，会死递归，再也挑不出来了
但是用Handler的post()方法这样启动的线程的run()方法，可以在任何需要的时候remove()掉，
于是当我们需要暂停的时候，只需要先remove()线程，然后记录下已经播放的时间就行。
当继续的时候，就继续post()该线程
总而言之，其实是一直在main()方法中执行的
8 楼
java_mzd
2010-11-16
Foxswily 写道
规则文件直接用语法解析器
ANTLR
http://www.antlr.org/
ANTLR
http://www.antlr.org/
多谢兄弟指导
7 楼
java_mzd
2010-11-16
nuclearg 写道
你这段程序的目的就是“把LRC文件解析封装为LRC对象”对吧
我在写播放器，现在拿到了一堆（注意是一堆）时间与歌词的名值对
好我现在要做歌词滚动，因为你用的是HashMap，不保存条目之间的顺序，我根本不知道下一条歌词应该在什么时候显示出来
我怎么滚？滚多快?我甚至根本连下一条歌词是什么都不知道
难道我还要遍历一遍这个歌词列表，然后自己冒泡排出一个顺序么……这种事情难道不应该是你的这个“LRC读取组件”该做的么
这事就应该对每一条歌词起一个类，里面是文本、起始时间、持续时间，然后返回一个歌词类的ArrayList或LinkedList。非得用HashMap，不是只用过这个吧
我在写播放器，现在拿到了一堆（注意是一堆）时间与歌词的名值对
好我现在要做歌词滚动，因为你用的是HashMap，不保存条目之间的顺序，我根本不知道下一条歌词应该在什么时候显示出来
我怎么滚？滚多快?我甚至根本连下一条歌词是什么都不知道
难道我还要遍历一遍这个歌词列表，然后自己冒泡排出一个顺序么……这种事情难道不应该是你的这个“LRC读取组件”该做的么
这事就应该对每一条歌词起一个类，里面是文本、起始时间、持续时间，然后返回一个歌词类的ArrayList或LinkedList。非得用HashMap，不是只用过这个吧
不过真的是我表述的不清楚还是你自己写播放器写成定式思维了
为什么我一定要先从Collection里面
按顺序一条一条的取出歌词，再根据每句歌词的时间等到了这个播放时间再来显示呢？
我就不能以歌曲播放时间，每10MS为一个单位，用这个时间去HashMap里面取歌词呢？
如果取到了，就更新，没取到，不产生任何操作
这样不就完美的解决这个问题了吗？
至于用List或者Quenu，呵呵，你可以真的当我没文化从来没用过吧
只是你就看这样的一行
[02:55.00][01:22.00]也答应永远都不让对方担心
[03:02.00][01:28.00]要做快乐的自己 照顾自己
因为歌曲可能会分段，每句歌词可能在后面的断再出现
于是，我们解析的时候，每次就可能解析的不止一个时间，这时候有两个时间，而且不是按顺序来的，我想问大虾你怎么解决呢？
先保存所有时间，再排序来一个个存？
如果我用HashMap来存的话，只是保存每个时间点和该句歌词的关系，我只要用播放时间去Map中取就好了。
6 楼
zhengyutong
2010-11-16
楼主的羊羔体写的很不错。
5 楼
bitray
2010-11-16
播放器可以提前加载整个歌词，然后在每次计算下句时间到本句时间之间的间隔和歌词间距，然后使用平均速度进行滚动就可以了。
如果是时间轮询反复去查是非常浪费资源的，尤其你是为手机开发程序的话，更要重视资源啊，因为手机的内存资源和硬件都是很有限。一点一滴不能浪费啊
如果是时间轮询反复去查是非常浪费资源的，尤其你是为手机开发程序的话，更要重视资源啊，因为手机的内存资源和硬件都是很有限。一点一滴不能浪费啊
4 楼
Foxswily
2010-11-16
规则文件直接用语法解析器
ANTLR
http://www.antlr.org/
ANTLR
http://www.antlr.org/
3 楼
nuclearg
2010-11-15
你这段程序的目的就是“把LRC文件解析封装为LRC对象”对吧
我在写播放器，现在拿到了一堆（注意是一堆）时间与歌词的名值对
好我现在要做歌词滚动，因为你用的是HashMap，不保存条目之间的顺序，我根本不知道下一条歌词应该在什么时候显示出来
我怎么滚？滚多快?我甚至根本连下一条歌词是什么都不知道
难道我还要遍历一遍这个歌词列表，然后自己冒泡排出一个顺序么……这种事情难道不应该是你的这个“LRC读取组件”该做的么
这事就应该对每一条歌词起一个类，里面是文本、起始时间、持续时间，然后返回一个歌词类的ArrayList或LinkedList。非得用HashMap，不是只用过这个吧
我在写播放器，现在拿到了一堆（注意是一堆）时间与歌词的名值对
好我现在要做歌词滚动，因为你用的是HashMap，不保存条目之间的顺序，我根本不知道下一条歌词应该在什么时候显示出来
我怎么滚？滚多快?我甚至根本连下一条歌词是什么都不知道
难道我还要遍历一遍这个歌词列表，然后自己冒泡排出一个顺序么……这种事情难道不应该是你的这个“LRC读取组件”该做的么
这事就应该对每一条歌词起一个类，里面是文本、起始时间、持续时间，然后返回一个歌词类的ArrayList或LinkedList。非得用HashMap，不是只用过这个吧
2 楼
java_mzd
2010-11-15
nuclearg 写道
没你这么干的
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
呵呵，
那么我想问你
你觉得播放器是怎么调用的呢？
还不是根据LRC歌词的每个时间点来匹配当前播放时间
写这个的目的就是把LRC文件解析封装为LRC对象
然后供播放器调用
至于播放器怎么调用
问题就更简单了
首先：
我们可以观察到Lrc格式中的时间点是00.00S
也就是最小单位是10ms
在播放器中
我们获取当前已经播放时间的时间playedTime为Long型
然后处理 playedTime 对象----去掉个位数
启动轮询线程
每隔10MS
用处理过的的playedTime去Map中判断
如果在这个时间点有记录
则取出记录，更新UI
如果没有记录，则不操作
播放器的显示歌词的原理难道不就是这样实现的嘛？
1 楼
nuclearg
2010-11-15
没你这么干的
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
发表评论
相关推荐
平时我们会经常遇到对IP地址的检测，检验IP地址是否合理。当然你可以通过其他程序代码去实现，这里用正则表达式去实现更为简单。
java中用正则表达式来检测IP地址是否合理，简单又好用。.rar
平时我们经常会遇到对IP地址的检测，检验所填写的IP地址是否合乎语法要求。当然你可以用别的方法去实现，这里用正则表达式来实现相当简单。
需要EXCEL中用正则表达式的朋友加快脚步吧！
C#中用正则表达式C#中用正则表达式C#中用正则表达式C#中用正则表达式C#中用正则表达式C#中用正则表达式C#中用正则表达式
我想利用本月的专栏描述一个有趣...RegexForm 是一个基于正则表达式的MFC窗体有效性验证系统。为了实现这个程序，我首先实现了 RegexWrap。但因为许多细节与正则表达式本身无关，所以感觉在这里描述 RegexForm 更好些。
在C#中用正则表达式进行对字符串组成的验证
PHP和正则表达式 个正则表达式是个特定格式化模式可以用来找出个串在另个串中使用情况几个编程语言包括Visual Basic,Perl,JavaScript和PHP都支持正则表达式...让我们先来看看什么是正则表达式为什么你要在PHP中用到它们
如下代码： import re import requests class HandleLaGou(object): def __init__(self): self.laGou_session = requests.session() self.header = { 'User-Agent': 'Mozilla/5.0 (Macintosh;...
如何去判断不同编码的正则表达式，比如，本文中用了两种方法判断gb2312和utf8编码的正则表达式。
在MySQL中用正则表达式替换数据库中的内容的方法
主要介绍了Python的爬虫包Beautiful Soup中用正则表达式来搜索的技巧,包括使用正则表达式去搜索多种可能的关键字以及查找属性值未知的标签等,需要的朋友可以参考下
replace() 方法 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。 1.匹配模式 正则表达式查找与模式匹配的字符串部分 在JavaScript中，它们是在正斜杠之间//或使用new RegExp() 例如： ...
通过使用正则表达式，方便的提取出字符串中用双引号括起来的数字字段，并去掉其千分位号，也可用来去除一对双引号。可以借助贪婪模式，进行最小匹配。 string teststr="2323,232323,fff,\"344,34,734\",34365,65656,...
在VS2010下，把prce源文件直接引入到工程中，直接调用 prce中的正则表达式。没有使用单独创建lib工程。使用的版本是pcre-8.35
主要介绍了IOS中用正则表达式判断输入的内容为8-16位且同时包含数字和字母,需要的朋友可以参考下
一个java正规表达式工具类 关键字: 一个java正规表达式工具类 猛然想起两年写了一个java的正规表达式的java工具类，分享一下，有用到的欢迎下载使用。 如果你有常用的定义好的，且测试通过的正规表达式，欢迎跟贴...
可以分组保存，测试中用到的正则表达式。 c.本工具使用最常见的regex。以下是简单示例: a|b Matches a or b gr(a|e)y Matches a or e . Matches any single character [abc] Matches a single character a, b ...
虽然现在几乎所有的文本编辑器都支持正则表达式，但我在本教程中用的是 Visual Studio Code，不过你可以使用任何你喜欢的编辑器。另请注意，你通常需要在搜索输入框附近的某处打开 RegEx 开关。以下是在 VS Code 中...
js中用正则表达式 过滤特殊字符 ,校验所有输入域是否含有特殊符号