java解析器代码 java 解码

java解析lrc文件代码

lrc可以通过如下util工具类进行转换，如果想知道结果是否读取的有问题，可以直接用记事本打开lrc文件的，之后和输出结果比对一下就行。

创新互联专注于金塔企业网站建设,响应式网站开发,成都做商城网站。金塔网站建设公司,为金塔等地区提供建站服务。全流程定制网站建设，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务

package com.routon.utils;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import android.util.Log;

/**

* parse lrc file tool

* eg：

* utilLrc lrc = new utilLrc("/sdcard/test.lrc");

* get song name : String title = lrc.getTitle();

* get performer name : String artist = lrc.getArtist();

* get album name: String album = lrc.getAlbum();

* get lrcmaker name: String lrcMaker = lrc.getLrcMaker();

* get song list: ListStatement list = lrc.getLrcList();

*

* @author xuweilin

*

*/

public class utilLrc {

private static String TAG = "utilLrc";

public class Statement {

private double time = 0.0; //time, 0.01s

private String lyric = ""; //song word

/*

* get time

*/

public double getTime() {

return time;

}

/*

* set time

*/

public void setTime(double time) {

this.time = time;

}

/*

* set time.format:mm:ss.ms

*/

public void setTime(String time) {

String str[] = time.split(":|\\.");

this.time = Integer.parseInt(str[0])*60+Integer.parseInt(str[1])+Integer.parseInt(str[2])*0.01;

}

/*

* get lrc word

*/

public String getLyric() {

return lyric;

}

/*

* set lrc word

*/

public void setLyric(String lyric) {

this.lyric = lyric;

}

}

private BufferedReader bufferReader = null;

private String title = "";

private String artist = "";

private String album = "";

private String lrcMaker = "";

private ListStatement statements = new ArrayListStatement();

/*

*

* fileName

*/

public utilLrc(String fileName) throws IOException{

FileInputStream file = new FileInputStream(fileName);

bufferReader = new BufferedReader(new InputStreamReader(file, "utf-8"));

readData();

}

/*

* read the file

*/

private void readData() throws IOException{

statements.clear();

String strLine;

while(null != (strLine = bufferReader.readLine()))

{

if("".equals(strLine.trim()))

{

continue;

}

if(null == title || "".equals(title.trim()))

{

Pattern pattern = Pattern.compile("\\[ti:(.+?)\\]");

Matcher matcher = pattern.matcher(strLine);

if(matcher.find())

{

title=matcher.group(1);

continue;

}

}

if(null == artist || "".equals(artist.trim()))

{

Pattern pattern = Pattern.compile("\\[ar:(.+?)\\]");

Matcher matcher = pattern.matcher(strLine);

if(matcher.find())

{

artist=matcher.group(1);

continue;

}

}

if(null == album || "".equals(album.trim()))

{

Pattern pattern = Pattern.compile("\\[al:(.+?)\\]");

Matcher matcher = pattern.matcher(strLine);

if(matcher.find())

{

album=matcher.group(1);

continue;

}

}

if(null == lrcMaker || "".equals(lrcMaker.trim()))

{

Pattern pattern = Pattern.compile("\\[by:(.+?)\\]");

Matcher matcher = pattern.matcher(strLine);

if(matcher.find())

{

lrcMaker=matcher.group(1);

continue;

}

}

int timeNum=0;

String str[] = strLine.split("\\]");

for(int i=0; istr.length; ++i)

{

String str2[] = str[i].split("\\[");

str[i] = str2[str2.length-1];

if(isTime(str[i])){

++timeNum;

}

}

for(int i=0; itimeNum;++i)

{

Statement sm = new Statement();

sm.setTime(str[i]);

if(timeNumstr.length)

{

sm.setLyric(str[str.length-1]);

}

statements.add(sm);

}

}

sortLyric();

}

/*

* judge the string is or not date format.

*/

private boolean isTime(String string)

{

String str[] = string.split(":|\\.");

if(3!=str.length)

{

return false;

}

try{

for(int i=0;istr.length;++i)

{

Integer.parseInt(str[i]);

}

}

catch(NumberFormatException e)

{

Log.e(TAG, "isTime exception："+e.getMessage());

return false;

}

return true;

}

/*

* sort the word by time.

*/

private void sortLyric()

{

for(int i=0;istatements.size()-1;++i)

{

int index=i;

double delta=Double.MAX_VALUE;

boolean moveFlag = false;

for(int j=i+1;jstatements.size();++j)

{

double sub;

if(0=(sub=statements.get(i).getTime()-statements.get(j).getTime()))

{

continue;

}

moveFlag=true;

if(subdelta)

{

delta=sub;

index=j+1;

}

}

if(moveFlag)

{

statements.add(index, statements.get(i));

statements.remove(i);

--i;

}

}

}

/**

* get title

* @return

*/

public String getTitle(){

return title;

}

/**

* get artist

* @return

*/

public String getArtist(){

return artist;

}

/**

* get album

* @return

*/

public String getAlbum(){

return album;

}

/**

* get lrc maker

* @return

*/

public String getLrcMaker(){

return lrcMaker;

}

/**

* get song list

* @return

*/

public ListStatement getLrcList(){

return statements;

}

}

编写一个Java程序，使用DOM解析器解析下列XML文件

用dom4j解析，非常快，具体怎么解析

SAXReader reader = new SAXReader();

String filePath = "c:/abc.xml";

File file = new File(filePath);

Document document = reader.read(file);// 读取XML文件

Element root = document.getRootElement();// 得到根节点

Element select = root.element("select");

for (Iterator i = select.nodeIterator(); i.hasNext();) {

Object obj = i.next();

String content = "";

if (obj instanceof Text) {

content = ((Text)obj).getText().replaceAll("\n", "").trim();

java代码解析

一楼的说的够全面了,不过稍有误解.

再来表示抱歉,我对编程语言中的中文名词非常不了解,所以如果以下的回复对你的阅读或者理解造成困难,请见谅.

1.首先,要明白这个问题的答案,需要了解call (pass) by value 和 call (pass) by reference 的区别.简单来说:

call by value通常是复制这个parameter的值去另外一块内存里,然后传给function, 所以在method/function里边对这个变量的所有变更,实际上都是对复制过来的镜像进行操作,不会对原本的variable有任何影响.

call by reference是将parameter的reference传给function,简单点理解就是直接把variable传给function.所以说这个variable的值是可以被function改变的.这个用法在c/c++中非常常见,用法是variable_name.

2.再来,在Java里边,你可以很简单的理解为: Java中只有call by value, 也就是说,所以所有传给function的parameter本身都不会被改变. (这是最简单直白的理解,当然也有另一种常从sun的人那边听到的说法:Java是call by value + call by reference by value)

3.那么现在的问题就是为什么第二个结果是2了. 首先说一下sun官方的解释: 对于reference type在作为parameter/argument的时候,也是call by value, 但是在你拥有足够权限时(比方说那个变量是public的, 不是final的等等各种符合的情况),可以修改这个object中fields的值(也就是属于这个object(严谨点讲是an instance of the object) 内部的变量, 在你的例子中, ko 里边的 a 就是一个field, 所以update(ko)会使ko.a变成2).

4.如果你是一个有过c/c++学习经验的人或者你以上的解释很难理解,以下这种说法或许更适合你 (当然了,这只是大多包括我在内有c经验的人的一种理解方式)

这里可以引入一个新的概念,pointer. 这是一种比较特殊的变量,它内部所储存的东西,其实只是另外一个变量的内存地址. 如果对内存没有概念,你可以把它简单理解为是风筝的线轴,虽然看它本身看不出什么端倪,但是顺着摸过去总会找到风筝,看到它是什么样子. 以pointer方式理解Java的人,通常会说: Type variable = new Type(); 这个过程中,最后生成的这个variable其实就是一个pointer,而不是instance本身.

在Java中, 有c/c++经验的人通常认为Java是call by value.同时,当一个变量用在储存reference type的时候,实际上储存的是它的pointer,这也一样可以解释为什么ko.a会有2这个结果,因为虽然pointer被传到function里边时,本身是call by value,无法被改变.但这并不影响function本身对这个pointer指向的object的内容做任何改变. 当然,再次声明,这只是一种帮助有c/c++经验的人理解的方法. Sun本身严正声明Java里边没有pointer这个东西的存在.

5. 再来解释一下为什么说楼上所说的(或者说楼上引用的)理解略有偏差.

引用"我们上面刚学习了JAVA的数据类型，则有：值类型就是按值传递的，而引用类型是按引用传递的" 这句话很明显的有两点错误. 第一点,如果我上面所说的,Java是没有call by reference的.

第二点,暂且假设Java里边是有call by reference的, 这句话依然不成立.

Java中的变量有两种类型: primitive types 和 reference type.

primitive type包括byte, short, int, long, char, boolean, float和double.

而这8种之外的所有的,都是reference type.

下面是一段对你的贴上来的code的一点延伸,希望可以帮助你更好的理解Java中的argument / parameter到底是如何运作的.

public class Test {

public static void main(String[] args) {

int a = 1;

Koo koo = new Koo();

Object o = new Integer(1);

Koo newKoo = new Koo();

update(a);

update(koo);

update(o);

update(newKoo);

newUpdate(newKoo);

System.out.println(a);

System.out.println(koo.a);

System.out.println(o);

System.out.println(newKoo.a);

}

static void update(int a) {

a++;

}

static void update(Koo koo) {

koo.a++;

}

static void update(Object o) {

o = (int) (Integer.parseInt(o.toString()) + 1);

}

static void newUpdate(Koo koo) {

koo = new Koo();

}

}

class Koo {

int a = 1;

}

/*

o = (int) (Integer.parseInt(o.toString()) + 1); 这一行中的(int)纯粹是多余的,是否有这个casting对code本身没有任何影响. 如果你高兴也可以用

o = new Integer(Integer.parseInt(o.toString()) + 1);

或者干脆

o = Integer.parseInt(o.toString()) + 1;

*/

以上这些code运行之后会得到1 2 1 2的结果. 后面两个结果可以很好的说明, 即使对objects (reference type variables) 来看, Java所应用的也并不是call by reference. 否则的话,以上code运行结果应该是1 2 2 1

希望你可以真正理解这个新的例子中,产生1212这个结果的原因,从而对Java中的arguments有一个系统全面的认识.

图片是相关资料的链接,知道里貌似不能加网址

详解Java解析XML的四种方法

1、DOM生成和解析XML方式

为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。

2、SAX生成和解析XML方式

为解决DOM的问题，出现了SAX。SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；

3、DOM4J生成和解析XML方式

OM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

4、JDOM生成和解析XML

为减少DOM、SAX的编码量，出现了JDOM；优点：20-80原则，极大减少了代码量。使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan文档。