「java串流」java串行

今天给各位分享java串流的知识，其中也会对java串行进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java XML解析详解
• 2、Java中的几个关于文件流的问题.
• 3、java如何对视频文件处理？包括拉流推流视频截取等？
• 4、java中352627java.io.EOFException是什么意思
• 5、求java大神请教一个问题，关于音频文件处理！
• 6、1． Java有几种内存？每一种内存有什么功能？哪一种内存速度快？

java XML解析详解

(I)Java通过DOM解析XML

1得到DOM解析器的工厂实例

DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();

得到javax.xml.parsers.DocumentBuilderFactory;类的实例就是我们要的解析器工厂

2从DOM工厂获得DOM解析器

DocumentBuilder dombuilder=domfac.newDocumentBuilder();

通过javax.xml.parsers.DocumentBuilderFactory实例的静态方法newDocumentBuilder()得到DOM解析器

3把要解析的XML文档转化为输入流，以便DOM解析器解析它

InputStream is=new FileInputStream("bin/library.xml");

InputStream是一个接口。

4解析XML文档的输入流，得到一个Document

Document doc=dombuilder.parse(is);

由XML文档的输入流得到一个org.w3c.dom.Document对象，以后的处理都是对Document对象进行的

5得到XML文档的根节点

Element root=doc.getDocumentElement();

在DOM中只有根节点是一个org.w3c.dom.Element对象。

6得到节点的子节点

NodeList books=root.getChildNodes();

for(int i=0;ibooks.getLength();i++){

Node book=books.item(i);

}

这是用一个org.w3c.dom.NodeList接口来存放它所有子节点的，还有一种轮循子节点的方法，后面有介绍

7取得节点的属性值

String email=book.getAttributes().getNamedItem("email").getNodeValue();

System.out.println(email);

注意，节点的属性也是它的子节点。它的节点类型也是Node.ELEMENT_NODE

8轮循子节点

for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){

if(node.getNodeType()==Node.ELEMENT_NODE){

if(node.getNodeName().equals("name")){

String name=node.getNodeValue();

String name1=node.getFirstChild().getNodeValue();

　...

if(node.getNodeName().equals("price")){

String price=node.getFirstChild().getNodeValue();

...

Java通过SAX解析XML

Simple API for XML（简称SAX）是个循序存取XML的解析器API。

一个实现SAX的解析器（也就是“SAX Parser”）以一个串流解析器的型式作用，拥有事件驱动API。由使用者定义回调函数，解析时，若发生事件的话会被调用。SAX事件包括：

XML 文字 节点

XML 元素 节点

XML 处理指令

XML 注释

Java代码

person

user

username谢成志/username

password6626310xie/password

sex男/sex

birthday1988/11/28/birthday

headpic

pictitleermao/pictitle

picurlimages/head1.jpg/picurl

/headpic

/user

/person

此为下面即将解析度简单xml结构，并将其封装成一个User对象。

////////////////////////////////////////////////////////////////////////////////////

Java代码

span style="font-family: courier new,courier; font-size: small;"package com.xcz.xml;

import java.io.File;

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

import com.xcz.util.SaxUtil;

public class Sax4XML {

public static void main(String[] args) {

try {

//1.获取factory

SAXParserFactory factory = SAXParserFactory.newInstance();

//2.获取parser

SAXParser parser = factory.newSAXParser();

//3.获取解析时的监听器对象

SaxUtil su = new SaxUtil();

//4.开始解析

parser.parse(new File("src/user-params.xml"), su);

System.out.println(su.getUser());

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

/span

////////////////////////////////////////////////////////////////////////////////////

Java代码

span style="font-family: courier new,courier; font-size: small;"package com.xcz.util;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

import com.xcz.po.HeadPic;

import com.xcz.po.User;

/**

* 定义xml解析时的监听类

*

* 实现方式有很多，可以实现接口：ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler

* 但我们常用的继承：DefaultHandler

*/

public class SaxUtil extends DefaultHandler {

private User user;

private HeadPic headPic;

private String content;

private SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");

@Override

public void characters(char[] ch, int start, int length)

throws SAXException {

content = new String(ch, start, length);

}

//当解析到文本开始时触发

@Override

public void startDocument() throws SAXException {

super.startDocument();

}

//当解析到文本结束时触发

@Override

public void endDocument() throws SAXException {

super.endDocument();

}

//当解析到元素开始时触发

@Override

public void startElement(String uri, String localName, String name,

Attributes attributes) throws SAXException

{

if("user".equals(name))

{

user = new User();

}

if("headpic".equals(name))

{

headPic = new HeadPic();

}

}

//当解析到元素结束时触发

@Override

public void endElement(String uri, String localName, String name)

throws SAXException

{

if("username".equals(name))

{

user.setUsername(content);

}

if("password".equals(name))

{

user.setPassword(content);

}

if("sex".equals(name))

{

user.setSex(content);

}

if("birthday".equals(name))

{

try {

user.setBirthday(sdf.parse(content));

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

if("pictitle".equals(name))

{

headPic.setPicTitle(content);

}

if("picurl".equals(name))

{

headPic.setPicUrl(content);

user.setHeadPic(headPic);

}

}

public User getUser(){

return user;

}

}/span

[优点]

(1).节约内存开销

SAX解析器在某些方面优于DOM风格解析器，因为SAX解析器的内存使用量一般远低于DOM解析器使用量。DOM解析器在任何处理开始之前，必须将xml以整棵树放在内存，所以DOM解析器的内存使用量完全根据输入资料的大小。相对来说，SAX解析器的内存内容，是只基于XML档案的最大深度（XML树的最大深度）和单一XML项目上XML属性储存的最大资料。

(2)解析速度快

因为SAX事件驱动的本质，处理文件通常会比DOM风格的解析器快。

[缺点]

SAX事件驱动的模型对于XML解析很有用，但它确实有某些缺点。

某些种类的XML验证需要存取整份文件。例如，一个DTD IDREF属性需要文件内有项目使用指定字串当成DTD ID属性。要在SAX解析器内验证，必须追踪每个之前遇过的ID和IDREF属性，检查是否有任何相符。更甚者，一个IDREF找不到对应的ID，使用者只会在整份文件都解析完后才发现，若这种连结对于建立有效输出是重要的，那用在处理整份文件的时间只是浪费。

Java中的几个关于文件流的问题.

至于PipedInputStream（抱歉你可能写错了）

在官方网的解释是这样的：

传送输入流应该连接到传送输出流；传送输入流会提供要写入传送输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能会死锁该线程。传送输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。

ADPipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信.一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道.PipedOutputStream可以向管道中写入数据,PipedIntputStream可以读取PipedOutputStream向管道中写入的数据.这两个类主要用来完成线程之间的通信.一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据.

PipedInputStream与PipedOutputStream类的编程实例(两个线程间进行通信的实例程序)

//Sender.java 发送者，这个线程主要用于向另一个线程发送数据

import java.io.*;

public class Sender extends Thread{ //表明是个线程类

private PipedOutputStream out = new PipedOutputStream(); //发送者是要向外面写数据，所以发送者内部创建PipedOutputStream对象用于向外写数据

public PipedOutputStream getOutputStream(){ //返回管道输出流对象

return out;

}

//这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行

public void run(){ //这里的run方法用于向PipedOutputStream中写入一串数据

字串2

String strInfo = new String("hello,receiver!");

try{ //write和close方法都可能有异常出现

out.write(StrInfo.getBytes());

out.close();

}

catch(Exception e){

e.printStackTrace();

}

}

}

//Receiver.java //接收者，也是一个线程类

import java.io.*;

public class Receiver extends Thread{

private PipedInputStream in = new PipedInputStream(); //接受者是要读取外面的数据，所以接受者内部创建PipedInputStream对象用于读取外面的数据

public PipedInputStream getInputStream(){ //返回管道输入流对象

return in;

}

//这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行

public void run(){ //这里的run方法用于接收数据

byte[] buf = new byte[1024]; //字节数组

try{ //read和close方法都可能有异常出现

int len = in.read(buf); //读取数据，len表示实际读取到的内容（长度）

System.out.println("the following message comes from sender:\n" = new String(buf ,o,len) );

字串8

in.close();

}

catch(Exception e){

e.printStackTrace();

}

}

}

//PipedStreamTest.java //启动类

import java.io.*;

public calss PipedStreamTest{

public static void main(String[] args) throws Exception {

Sender t1 = new Sender(); //创建发送者对象;

Receiver t2 = new Receiver(); //创建接收者对象;

PipedOutputStream out = t1.getOutputStream();

PipedInputStream in = t2.getIntStream();

out.connect(in); //用于连接到PipedInputStream上,与in.connect(out)等价,connect方法有异常出现的可能

t1.start(); //启动线程

t2.start(); //启动线程

}

}

PipedWriter和PipedReader类，它用来处理字符文本的管道通信.

使用管道流类，可以实现名个/doc/"程序模块之间的松耦合通信,这样我们在/doc/"程序中就可以灵活的将多个这样的模块的输入流与输出流相联，然后以拼装成满足各种应用的/doc/"程序,而不用对模块内部进行修改.使用管道连接的模块具有强内聚弱耦合的特点,若模块被替换或被拆卸不会影响到其他的模块.

字串7

java如何对视频文件处理？包括拉流推流视频截取等？

推流工具OBS Studio

首先在网上下载该工具.然后安装.然后按照如下步骤操作

打开软件点击设置

然后按照如下顺序,先点击串流--服务选择自定义--填写流服务地址

点击下面的加号,选择你想推到服务器的视频文件

然后点击推流,致此就行了

拉流软件VLC media player

首先下载该软件,并打开.

点击媒体,然后选择打开网络串流,填写流服务地址,点击播放.支持刚才推到流服务上的视频,就可以在这里播放了简单的

如无法正常展示请点击“”一键反馈“

内容不错,鼓励一下~

java中352627java.io.EOFException是什么意思

EOFException表示输入过程中意外地到达文件尾或流尾的信号,导致异常，其实这个是正常的，只是告诉你，该把使用流的对象都关闭一下。

求java大神请教一个问题，关于音频文件处理！

自己看吧!!!

package wav;

import javax.sound.sampled.*;

import java.io.*;

import java.net.*;

/**

* 播放音乐(支援WAV, AIFF, AU) 2011/10/09

*

* 2012/12/08

* 1.增加播放结束时callback

* 2.修正bug: 无限次播放时，无法stop()

*

* @version 2

* @author Ray(吉他手)

*/

public class AudioPlayer{

private AudioInputStream currentSound;

private Clip clip;

private float gain;

private FloatControl gainControl;

//控制声道,-1.0f:只有左声道, 0.0f:双声道,1.0f右声道

private float pan;

private FloatControl panControl;

//控制静音 开/关

private boolean mute;

private BooleanControl muteControl;

//播放次数,小於等於0:无限次播放,大於0:播放次数

private int playCount;

private DataLine.Info dlInfo;

private Object loadReference;

private AudioFormat format;

//音乐播放完毕时，若有设定回call的对象，则会通知此对象

private AudioPlayerCallback callbackTartet;

private Object callbackObj ;

private boolean isPause;

public AudioPlayer(){

AudioPlayerInit();

}

public void AudioPlayerInit(){

currentSound = null;

clip = null;

gain = 0.5f;

gainControl = null;

pan = 0.0f;

panControl = null;

mute = false;

muteControl = null;

playCount = 0;

dlInfo = null;

isPause = false;

}

/**

* 设定要接收音乐播放完时事件的对象

* @param cb 接收callback的对象

* @param obj callback回来的物件

*/

public void setCallbackTartet(AudioPlayerCallback cb, Object obj){

callbackTartet = cb;

callbackObj = obj;

}

/**

* 设定播放次数,播放次数,小於等於0:无限次播放,大於0:播放次数

* @param c

*/

public void setPlayCount(int c){

if(c -1){

c = -1;

}

playCount = c - 1;

}

/**

* 指定路径读取音档,回传true:播放成功,false:播放失败

* @param filePath

* @param obj 目前物件放置的package路径

*/

public boolean loadAudio(String filePath){

try {

loadAudio(new File(filePath));

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

/**

* 指定路径读取音档,使用目前物件放置的package当相对路径root,null时不使用物件路径为root

* @param filePath

* @param obj 目前物件放置的package路径

* @return 回传true:播放成功,false:播放失败

*/

public boolean loadAudio(String filePath, Object obj){

try {

if(obj != null){

loadAudio(obj.getClass().getResourceAsStream(filePath));

}else{

loadAudio(new File(filePath));

}

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

/**

* 从远端读取音档

*/

public void loadAudio(URL url) throws Exception{

loadReference = url;

currentSound = AudioSystem.getAudioInputStream(url);

finishLoadingAudio();

}

/**

* 读取本地端音档

* @param file

* @throws Exception

*/

public void loadAudio(File file) throws Exception{

loadReference = file;

currentSound = AudioSystem.getAudioInputStream(file);

finishLoadingAudio();

}

/**

* 从串流读取音档

* @param iStream

* @throws Exception

*/

public void loadAudio(InputStream iStream) throws Exception{

loadReference = iStream;

if (iStream instanceof AudioInputStream){

currentSound = (AudioInputStream)iStream;

} else {

currentSound = AudioSystem.getAudioInputStream(iStream);

}

finishLoadingAudio();

}

/**

* load完音档後，进行播放设定

*/

protected void finishLoadingAudio() throws Exception {

format = currentSound.getFormat();

dlInfo = new DataLine.Info(Clip.class, format, ((int) currentSound.getFrameLength() * format.getFrameSize()));

clip = (Clip) AudioSystem.getLine(dlInfo);

clip.open(currentSound);

clip.addLineListener(

new LineListener() {

public void update(LineEvent event) {

if (event.getType().equals(LineEvent.Type.STOP)){

if(!isPause){

if(callbackTartet != null){

callbackTartet.audioPlayEnd(callbackObj);

}

close();

}

}

}

}

);

}

/**

* 播放音档

*/

public void play(){

if(clip != null){

clip.setFramePosition(0);

clip.loop(playCount);

}

}

/**

* 恢复播放音档

*

*/

public void resume(){

isPause = false;

if(clip != null){

clip.setFramePosition(clip.getFramePosition());

clip.loop(playCount);

}

}

/**

* 暂停播放音档

*/

public void pause(){

isPause = true;

if(clip != null){

clip.stop();

}

}

/**

* 停止播放音档,且将音档播放位置移回开始处

*/

public void stop(){

if(clip != null){

clip.stop();

}

}

/**

* 设定音量

* @param dB 0~1,预设为0.5

*/

public void setVolume(float dB){

float tempB = floor_pow(dB,1);

//System.out.println("目前音量+"+tempB);

gain = tempB;

resetVolume();

}

/**

* @param min 要无条件舍去的数字

* @param Num 要舍去的位数

*

*/

private float floor_pow(float min, int Num){

float n = (float)Math.pow(10, Num);

float tmp_Num = ((int)(min*n))/n;

return tmp_Num ;

}

/**

* 重设音量

*/

protected void resetVolume(){

gainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);

//double gain = .5D; // number between 0 and 1 (loudest)

float dB = (float) (Math.log(gain) / Math.log(10.0) * 20.0);

gainControl.setValue(dB);

}

/**

* 设定声道,-1.0f:只有左声道, 0.0f:双声道,1.0f右声道

* @param p

*/

public void setPan(float p){

pan = p;

resetPan();

}

/**

* 重设单双道、双声道

*/

protected void resetPan(){

panControl = (FloatControl) clip.getControl(FloatControl.Type.PAN);

panControl.setValue(this.pan);

}

/**

* 设定静音状态,true:静音,false:不静音

* @param m

*/

public void setMute(boolean m){

mute = m;

resetMute();

}

/**

* 重设静音状态

*

*/

protected void resetMute(){

muteControl = (BooleanControl) clip.getControl(BooleanControl.Type.MUTE);

muteControl.setValue(mute);

}

/**

*

* @return

*/

public int getFramePosition(){

try {

return clip.getFramePosition();

} catch (Exception e) {

return -1;

}

}

/**

* 取得音档格式

* @return

*/

public AudioFormat getCurrentFormat(){

return format;

}

/**

* 取得音档的串流

* @return

*/

public AudioInputStream getAudioInputStream(){

try {

AudioInputStream aiStream;

if (loadReference == null){

return null;

} else if (loadReference instanceof URL) {

URL url = (URL)loadReference;

aiStream = AudioSystem.getAudioInputStream(url);

} else if (loadReference instanceof File) {

File file = (File)loadReference;

aiStream = AudioSystem.getAudioInputStream(file);

} else if (loadReference instanceof AudioInputStream){

AudioInputStream stream = (AudioInputStream)loadReference;

aiStream = AudioSystem.getAudioInputStream(stream.getFormat(), stream);

stream.reset();

} else {

InputStream inputStream = (InputStream)loadReference;

aiStream = AudioSystem.getAudioInputStream(inputStream);

}

return aiStream;

} catch (Exception e) {

e.printStackTrace();

return null;

}

}

/**

* 目前音档是否已存在

* @return

*/

public boolean isAudioLoaded(){

return loadReference!= null;

}

/**

* 取得剪辑音档

* @return

*/

public Clip getClip() {

return clip;

}

/**

* 关闭音档

*/

public void close(){

try {

if (clip != null)

clip.close();

if (currentSound != null)

currentSound.close();

loadReference = null;

} catch (Exception e){

//System.out.println("unloadAudio: " + e);

e.printStackTrace();

}

currentSound = null;

clip = null;

gainControl = null;

panControl = null;

dlInfo = null;

loadReference = null;

muteControl = null;

callbackTartet = null;

callbackObj = null;

}

// public static void main(String [] args){

//

// }

}

1． Java有几种内存？每一种内存有什么功能？哪一种内存速度快？

有六个地方都可以存储数据：

(1) 寄存器(Registers)。这是速度最快的存储场所，因为寄存器其他所有存储媒介都不同：它位于处理器内部。不过，寄存器的数量十分有限，所以寄存器是根据需要由编译器适当地分配。作为一个程序员，我们对此没有直接的控制权，也没办法在程序里头感觉到寄存器的任何存在迹象。

(2) Stack(栈)。位于一般的RAM（random-access memory，随机访问内存）中。处理器通过其指针(“栈指针”，stack pointer)获得处理的直接支持。栈指针若向下(后)移，会分配新的内存；若向上(前)移，则会释放那些内存。这是一种特别快、特别有效率的数据存储方式，速度仅次于寄存器。由于Java编译器有责任产生“将stack指针前后移动”的程序代码，所以它必须能够完全掌握它所编译的程序中“存在stack里头的所有数据的实际大小和存活时间”。如此一来便会限制程序的弹性。由于这个限制，尽管有些Java数据要存储在栈里——特别是对象句柄，但Java对象并不放到其中。

(3) Heap(堆)。Heap是一种通用性质的内存存储空间（也存在于RAM中），用来置放所有Java对象。“内存堆”或“堆”（Heap）胜过stack之处在于，编译器不需知道究竟得从堆里分配多少存储空间，也不需知道从堆上分配的空间究竟要存活多长的时间。因此，用堆存储数据时会得到更大的灵活性。要求创建一个对象时，只需用new即可。执行这些代码时，会在堆里分配空间。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会比从栈里分配花掉更长的时间（假设你真的可以在Java中像C++一样地从stack上产生对象的话）！

(4) 静态存储空间(Static storage)。这儿的“静态”（Static）是指“位于固定位置”（也在RAM里头）。静态存储空间存放着“程序运行期间”一直存在的数据。可用static关键字将某个对象内的特定成员设为静态，但Java对象本身永远都不会置入静态存储空间。

(5) 常量存储空间(Constant storage)。常量值通常被直接置于程序代码里头。因为它们永远都不会改变，所以也是安全的。有的常数需要严格地保护，所以可考虑将它们置入只读存储器（read-only memory,ROM）中。

(6) 非RAM存储空间(Non-RAM storage)。若数据完全存活于程序之外，则程序不运行时数据仍继续存在，脱离了程序的控制范围。其中两个最主要的例子便是“串流化对象（streamed objects）”和“持久性对象（persistent objects）”。在串流化对象形式中，对象会被转换为一连串的字节(bytes)流，这些bytes通常会被传送给另一台机器。而在持久性对象形式中，对象被存储于磁盘，即使程序运行结束，这些对象还能够继续保有。这种类型的存储空间的特点在于，它们能够将对象转换为可存储于其他媒介的形式，并在需要时，将所存储的数据还原成可存储于RAM中的一般对象。Java提供了对“轻量级持久性（Lightweight persistence）”的支持。新版本有可能提供更完善的解决方案。

针对你的补充我也补充一下:堆内存和栈内存确实是我们常常用的东西,比如

Animal a = new Animal();

这个时候相当于在堆内存中开辟了一个空间保存了Animal的信息以及着块空间的内存地址,然后在栈内存中划了一小快空间保存了堆中的内存地址,这个时候我们就可以说引用a指向Animal()了.

可是有时候,有个静态类.Animal,里面有个静态方法speak();

那么可以这么直接调用Animal.sepak();

这个时候既没有new,也没有Animal a=??;

所以既没有在堆中开辟空间也没有在栈内存中开辟空间 ,

可是方法确实能执行,一切程序都运行在内存里,那么证明有新的内存区,就是静态空间了.

当然还有常量什么的等等

java串流的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java串行、java串流的信息别忘了在本站进行查找喔。