java_mzd
- 浏览: 583241 次
- 性别:
- 来自: 长沙
-
最新评论
-
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
没你这么干的
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
这个东西是被播放器调用的，他怎么知道你的下一条歌词是在几分几秒？我估计你自己都不知道。难道你还打算让他每隔一毫秒来问一下，有就是有，没有就往外抛个异常？
发表评论
相关推荐
### Java中利用正则表达式检测IP地址合理性 在日常的软件开发中，经常会遇到需要验证用户输入数据的情况，特别是对于IP地址这类特定格式的数据。本文将详细介绍如何使用Java中的正则表达式来检查一个IP地址的有效性...
Delphi正则表达式解析器是一款专为Delphi开发者设计的工具，用于处理和解析正则表达式。这款解析器提供了源代码，使得开发者能够深入理解其内部工作原理，并可以根据需求进行定制或扩展。在Delphi编程环境中，正则...
### Java中利用正则表达式实现IP地址检测 在日常编程工作中，经常需要验证用户输入的数据格式是否正确，其中一种常见的需求就是验证IP地址的有效性。对于这种需求，可以通过多种方式来实现，如字符串分割、循环判断...
在Java编程中，正则表达式是一种强大的工具，用于匹配、查找、替换字符串中的模式。在本场景中，我们关注的是使用正则表达式来验证输入的字符串是否符合IP地址的格式。IP地址通常由四组0-255之间的数字组成，每组...
在Excel中，正则表达式（Regular Expression）是一种强大的文本处理工具，用于匹配、查找、替换或提取符合特定模式的字符串。它通过一种特殊的语法来描述字符串的模式，这种模式可以是简单的字符序列，也可以是复杂...
replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。 JavaScript 中的正则表达式提供了强大的字符串匹配和操作能力，广泛应用于字符串处理和数据验证等领域。
该文件中统计的正则表达式包含以下内容（都是实际项目中使用的，经过测试）： 1、大于等于0的值，允许输入两位小数（边界值：100.0，100.00等值都已包含在验证的里面）； 2、大于3小于40的整数； 3、0到1之间的小数...
^ $ [ ] \ { } ( ) | 需要在正则表达式中用反斜杠\进行转义，以使用其原始含义。 - 转义序列：例如\n代表换行，\t代表制表符。 3. 元字符与边界匹配： - ^匹配输入字符串的开始位置，$匹配输入字符串的结束位置...
正则表达式（Regular Expression，简称regex）是一种强大的文本处理工具，它用于匹配、查找、替换、分析等涉及字符串操作的复杂任务。正则表达式编辑器是专门用来创建、测试和调试正则表达式的软件工具，对于程序员...
我想利用本月的专栏描述一个有趣...RegexForm 是一个基于正则表达式的MFC窗体有效性验证系统。为了实现这个程序，我首先实现了 RegexWrap。但因为许多细节与正则表达式本身无关，所以感觉在这里描述 RegexForm 更好些。
如下代码： import re import requests class HandleLaGou(object): def __init__(self): self.laGou_session = requests.session() self.header = { 'User-Agent': 'Mozilla/5.0 (Macintosh;...
反义是正则表达式中用以匹配特定范围之外字符的一种方法，例如\W表示匹配任何非字母数字字符。 重复是正则表达式中一个非常有用的构造，它允许指定一个字符或者字符组合重复的次数。例如，\d{3}将匹配任何三位数字...
根据给定的信息，本文将详细解析C#中如何使用正则表达式，并通过示例代码进一步阐述其应用方法。 ### C#中使用正则表达式的背景与意义 在软件开发过程中，经常需要处理字符串，例如验证用户输入是否符合特定格式...
虽然现在几乎所有的文本编辑器都支持正则表达式，但我在本教程中用的是 Visual Studio Code，不过你可以使用任何你喜欢的编辑器。另请注意，你通常需要在搜索输入框附近的某处打开 RegEx 开关。以下是在 VS Code 中...
8. **RegExpDemo**：这个文件很可能是示例代码或者测试工具的入口点，它可能包含了创建和测试正则表达式的函数、界面交互逻辑以及对用户输入的正则表达式进行验证和解析的功能。 使用这个C#正则表达式测试工具，...
`grep` 函数是Perl中用来遍历数组并筛选出满足条件的元素的函数，它可以接受一个正则表达式作为参数，返回所有与该模式匹配的元素。例如，`grep{/World/} @array` 将返回数组中包含 "World" 的元素。 元字符 `^` 和...
Java使用正则表达式获取子文本的方法示例 Java使用正则表达式获取子文本的方法示例主要介绍了Java使用正则表达式获取子文本的方法，结合实例形式分析了java针对子文本的正则操作相关函数与使用技巧。 知识点一：...
例如，如果你正在编写一个邮箱验证函数，可以先在测试器中用各种邮箱格式来验证你的正则表达式是否能够正确匹配。 总的来说，正则表达式是强大的文本处理工具，而正则表达式测试器则是学习和优化正则表达式不可或缺...
PCRE是一个开源的C语言库，它实现了Perl风格的正则表达式功能。这个库被广泛用于各种软件项目，包括Web服务器、数据库和文本处理工具等。版本8.35包含了对多种正则表达式特性的支持，如回溯限制、Unicode字符集支持...
### JavaScript经典正则表达式知识点解析 #### 一、概述 正则表达式是一种功能强大的文本处理工具，几乎在所有编程语言中都有提供。在JavaScript中，正则表达式主要用于字符串处理，包括但不限于： 1. **表单验证...