java InputStream 文件读写网络UDP/TCP

java io流传输操作

字节流和字符流的区别：

读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，字符流就是：字节流+编码表。

处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

纯文本数据优先考虑字符流别的字节流

常用字节流：

FileInputStream //字符流读文件

FileOutputStream //字符流写文件

BufferedInputStream //带缓冲区的读文件

BufferedOutputStream //带缓冲区写文件

字符流：

Writer Reader

FileReader //文件读

FileWriter //文件写

BufferedReader //缓存读操作

BufferedWriter //缓存写操作

创建一个可以往文件中写入字符数据的字符输出流对象，如果文件不存在，则会自动创建。如果文件存在，则会被覆盖。

因为不同系统换行符号不同所以，可以调用系统函数获得换行符号，便于不同系统移植

private static final String LINE_SEPARATOR = System.getProperty("line.separator"); //换行符

FileWriter fw = new FileWriter("demo.txt",true);  //创建一个文件
fw.write("abcde"+LINE_SEPARATOR+"hahaha");        //数据写入到临时存储缓冲区中。
fw.flush();                                       //数据缓冲区刷到文件中
fw.close();                                       //这个其实会自动调用 flush；上面那样写 可以实时保存

读文件单个字符模式

FileReader fr = new FileReader("demo.txt");      //打开要读的文件
int ch = 0;
while((ch=fr.read())!=-1){                       //文件结束符 为 -1 ，获得单个字符
    System.out.println((char)ch);                
}
fr.close();

单个字符读，操作次数多，浪费资源，于是出现多个字符缓冲区方式读取

FileReader fr = new FileReader("demo.txt");
char[] buf = new char[1024];                  //一次读取 1024字节
int len = 0;
while((len=fr.read(buf))!=-1){
    System.out.println(new String(buf,0,len));
}
fr.close();

一个文件读取写入另一个文件规范的写法考虑抛异常

FileReader fr = null;
FileWriter fw = null;
try {
    fr = new FileReader("a.txt");
    fw = new FileWriter("b.txt");
			
    char[] buf = new char[BUFFER_SIZE];//缓冲区。 
    int len = 0;
			
    while((len=fr.read(buf))!=-1){
        fw.write(buf, 0, len);
    }
			
} catch (Exception e) {
	throw new RuntimeException("读写失败");
}finally{

    if(fw!=null)  //证明打开的文件不为空
        try {
	    fw.close();
	} catch (IOException e) {
	    e.printStackTrace();
	}
    if(fr!=null)
	try {
	    fr.close();
	} catch (IOException e) {
	    e.printStackTrace();
	}
}

java本身带了缓存对象，可以直接调用文件打开操作

FileWriter fw = new FileWriter("buf.txt");
BufferedWriter bufw = new BufferedWriter(fw);    //
String line = null;
while((line=bufr.readLine())!=null){          //一次 读一行
    System.out.println(line);
}

FileWriter fw = new FileWriter("buf.txt");
BufferedWriter bufw = new BufferedWriter(fw);
bufw.write("abcdef"+x);
bufw.newLine();
bufw.flush();
bufw.close();                           //关闭缓冲区 防止内存泄露  这个不需要关闭 文件

字节流例子

FileInputStream fis = new FileInputStream("bytedemo.txt");
byte[] buf = new byte[1024];		
int len = 0;
		
while((len=fis.read(buf))!=-1){                    //文件没结束
    System.out.println(new String(buf,0,len));
}


FileOutputStream fos = new FileOutputStream("bytedemo.txt");
		
fos.write("abcdefg".getBytes());	         //文件中写入数据	
//fos.flush();
fos.close();//关闭资源动作要完成。

拷贝一首MP3文件

FileInputStream fis = new FileInputStream("c:\\0.mp3");	
BufferedInputStream bufis = new BufferedInputStream(fis);      //缓冲区方式
	
FileOutputStream fos = new FileOutputStream("c:\\2.mp3");
BufferedOutputStream bufos = new BufferedOutputStream(fos);
		
int ch = 0;	
while((ch=bufis.read())!=-1){
    bufos.write(ch);
}
	
bufos.close();                //关闭缓存区
bufis.close();

字符/字节流直接的转换 InputStreamReader、OutputStreamWriter

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); 字节流到字符流

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt")));

字符流道字节流转换桥

java网络通信 UDP函数

DatagramSocket ds = new DatagramSocket(10000);         //UDP 绑定端口

while(true){

    byte[] buf = new byte[1024];
    DatagramPacket dp = new DatagramPacket(buf,buf.length);       //UDP包对象
	
    ds.receive(dp);//阻塞式的。
	
    //4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
    String ip = dp.getAddress().getHostAddress();
    int port = dp.getPort();
    String text = new String(dp.getData(),0,dp.getLength());    //数据
	
    System.out.println(ip+":"+port+":"+text);	
}

ds.close();

UDPsend

DatagramSocket ds = new DatagramSocket();           
	
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
	
while((line=bufr.readLine())!=null){
			
    byte[] buf = line.getBytes();   
    DatagramPacket dp = 
    new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),10000);  //udp发送包
    ds.send(dp);    
		
    if("886".equals(line))
        break;
}

ds.close();

TCP通信对象客户端

Socket socket = new Socket("192.168.1.100",10002);          //服务器IP 端口
	
OutputStream out = socket.getOutputStream();	 //输出的信息
out.write("tcp 输出".getBytes());

InputStream in = socket.getInputStream();        //接收到的信息
byte[] buf = new byte[1024];
	
int len = in.read(buf);
	
String  text = new String(buf,0,len);
	
System.out.println(text);                

socket.close();

服务器端

ServerSocket ss = new ServerSocket(10002);

Socket s = ss.accept();                             //获得客户端对象
		
String ip = s.getInetAddress().getHostAddress();   //获得客户端IP
		
InputStream in = s.getInputStream();    //接收到的客户端数据
byte[] buf = new byte[1024];
		
int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(ip+":"+text);
		
OutputStream out = s.getOutputStream();   //发送到客户端数据
out.write("收到".getBytes());
		
s.close();
ss.close();

来源：oschina

链接：https://my.oschina.net/u/274829/blog/313874

标签

java

文件读写

网络UDP/TCP

java InputStream 文件读写 网络UDP/TCP

java InputStream 文件读写网络UDP/TCP