IO流之流转换在TCP网络编程的应用
IO流的概述和分类
什么是IO流,其作用为?
IO可以拆开来理解
I ---- Input -> 输入 读取
O ---- Output -> 输出 写出
读取和写出都是针对数据而言的, 所以, IO流就是用来处理设备之间的数据传输
常见应用:
文件复制
文件上传
文件下载
IO流的分类
按照类型分:
字节流 (图片 音频 视频)
字符流 (文本文件 通过对字节的编码解码来实现)
按照流向分:
输入流:
用来读取数据的:
输出流:
用来写出数据的
继承体系:
字节流&字符流的抽象父类
字节流：
InputStream 字节输入流
OutputStream 字节输出流
字符流：
Reader 字符输入流
Writer 字符输出流
字节输出流
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.FileOutputStream
字节输入流
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.FileInputStream
字节缓冲输出流
BufferedOutputStream:
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.FilterOutputStream
继承者 java.io.BufferedOutputStream
字节缓冲输入流
BufferedInputStream
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.FilterInputStream
继承者 java.io.BufferedInputStream
字符输出流
java.lang.Object
继承者 java.io.Writer
继承者 java.io.OutputStreamWriter
字符输入流
java.lang.Object
继承者 java.io.Reader
继承者 java.io.InputStreamReader
字符缓冲输出流
java.lang.Object
继承者 java.io.Writer
继承者 java.io.BufferedWriter
字符缓冲输入流
java.lang.Object
继承者 java.io.Reader
继承者 java.io.BufferedReader
字节输出流写数据
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.FileOutputStream
public abstract class OutputStream implements Closeable, Flushable
此抽象类是表示输出字节流的所有类的超类
输出流接受输出字节并将这些字节发送到某个接收器。
需要定义 OutputStream子类的应用程序必须始终提供至少一种可写入一个输出字节的方法。
public class FileOutputStream extends OutputStream
FileOutputStream:
文件输出流是用于将数据写入 File或 FileDescriptor的输出流
构造方法：
FileOutputStream(String name):
创建一个向具有指定名称的文件中写入数据的输出文件流。
字节流写数据的步骤：
A:创建字节输出流对象
B:调用写数据的方法
C:释放资源
方法摘要
写出数据的三个方法:
public void write(int b):一次写一个字节
public void write(byte[] b):一次写一个字节数组
public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
String类中的方法
byte[] getBytes() 将字符串转换为字节数组
字节流输入流读数据
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.FileInputStream
public abstract class InputStream extends Objectimplements Closeable
此抽象类是表示字节输入流的所有类的超类
public class FileInputStream extends InputStream
字节流读数据的步骤：
A:创建字节输入流对象
B:调用读数据的方法
C:释放资源
public int read(byte[] b):
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
返回值是读入缓冲区的字节总数，也就是实际的读取个数
如果因为已经到达文件末尾而没有更多的数据，则返回 -1
[code]public class CopyJpgTest {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("d:\\mn.jpg");
// 封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
// 读写数据
// 方式1：一次读取一个字节，一次写一个字节
int by;
while((by=fis.read())!=-1) {
fos.write(by);
}
// 方式2：一次读取一个字节数组，一次写一个字节数组的一部分
byte[] bys = new byte[1024];
int len;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
// 释放资源
fos.close();
fis.close();
}
}
字节缓冲流的作用是?
字节流一次读写一个数组的速度比一次读写一个字节的速度快很多
这是加入了数组这样的缓冲区效果，java本身在设计的时候
也考虑到了这样的设计思想，所以提供了字节缓冲区流
字节缓冲输出流
BufferedOutputStream:
java.lang.Object
继承者 java.io.OutputStream
继承者 java.io.FilterOutputStream
继承者 java.io.BufferedOutputStream
public class FilterOutputStream extends OutputStream
public BufferedOutputStream extends FilterOutputStream
BufferedOutputStream
该类实现缓冲的输出流。
通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统
FileOutputStream fos = new FileOutputStream("a.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
上面的两句等价于下面的这一句
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
public BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流
为什么字节缓冲流的构造方法需要传入一个OutputStream
字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作
字节缓冲输入流
BufferedInputStream
java.lang.Object
继承者 java.io.InputStream
继承者 java.io.FilterInputStream
继承者 java.io.BufferedInputStream
public class FilterInputStream extends InputStream
public class BufferedInputStream extends FilterInputStream
[code]public class CopyAviTest {
public static void main(String[] args) throws IOException {
//记录开始时间
long start = System.currentTimeMillis();
//method1();//共耗时：9464毫秒
// method2();//共耗时：19毫秒
// method3();//共耗时：106毫秒
method4();//共耗时：7毫秒
//记录结束时间
long end = System.currentTimeMillis();
System.out.println("共耗时："+(end-start)+"毫秒");
}
//缓冲字节流一次读写一个字节数组
private static void method4() throws IOException {
//封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("P6.jpg"));
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
byte[] bys = new byte[1024];
int len;
while((len=bis.read(bys))!=-1) {
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
//缓冲字节流一次读写一个字节
private static void method3() throws IOException {
//封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("P6.jpg"));
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));
int by;
while((by=bis.read())!=-1) {
bos.write(by);
}
bos.close();
bis.close();
}
//基本字节流一次读写一个字节数组
private static void method2() throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("P6.jpg");
//封装目的地
FileOutputStream fos = new FileOutputStream("copy.jpg");
byte[] bys = new byte[1024];
int len;
while((len=fis.read(bys))!=-1) {
fos.write(bys,0,len);
}
fos.close();
fis.close();
}
//基本字节流一次读写一个字节
private static void method1() throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("P6.jpg");
//封装目的地
FileOutputStream fos = new FileOutputStream("copy.jpg");
int by;
while((by=fis.read())!=-1) {
fos.write(by);
}
fos.close();
fis.close();
}
}
转换流指的是?
转换流其实就是一个字符流。
转换流 = 字节流 + 编码表
转换流的构造方法
字符流：
Reader 字符输入流
Writer 字符输出流
字符输出流
java.lang.Object
继承者 java.io.Writer
继承者 java.io.OutputStreamWriter
public class OutputStreamWriter extends Writer
OutputStreamWriter 是字符流通向字节流的桥梁
构造方法
public OutputStreamWriter(OutputStream out)
根据默认编码把字节流的数据转换为字符流
public OutputStreamWriter(OutputStream out,String charsetName)
根据指定编码把字节流数据转换为字符流
字符输入流
java.lang.Object
继承者 java.io.Reader
继承者 java.io.InputStreamReader
public class InputStreamReader extends Reader
InputStreamReader 是字节流通向字符流的桥梁
构造方法
public InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader
public InputStreamReader(InputStream in,String charsetName)
创建使用指定字符集的 InputStreamReader
[code]public class ConversionStreamDemo {
public static void main(String[] args) throws IOException {
//public OutputStreamWriter(OutputStream out)//使用默认编码
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
//public OutputStreamWriter(OutputStream out,String charsetName)//使用指定编码
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"GBK");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"UTF-8");
//调用写数据的方法
//继承 子类调用父类方法
//public class OutputStreamWriter extends Writer
osw.write("你好");
//释放资源
osw.close();
System.out.println("------------------------");
//public InputStreamReader(Inp
1c6f3
utStream in)//使用默认编码
//InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
//public InputStreamReader(InputStream in,String charsetName)//使用指定编码
//InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"GBK");
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"UTF-8");
//读数据：一次读取一个字符数据
int ch;
while((ch=isr.read())!=-1) {
System.out.print((char)ch);
}
//释放资源
isr.close();
}
}
字符缓冲输出流
java.lang.Object
继承者 java.io.Writer
继承者 java.io.BufferedWriter
public class BufferedWriter extends Writer
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
构造方法：
public BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流
//注意:使用输出流写数据时 应该写一行 换一行 刷新一行
字符缓冲输入流
java.lang.Object
继承者 java.io.Reader
继承者 java.io.BufferedReader
public class BufferedReader extends Reader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了
构造方法：
public BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流
方法摘要
BufferedWriter
void newLine():
写入一个行分隔符,这个行分隔符是由系统决定的
BufferedReader
String readLine():
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
字符打印流
printWriter
printWriter(OutputStream os)
printWriter(Writer w)
printWriter(OutputStream os,boolean autoFlush)
printWriter(Writer w,boolean autoFlush)想要开启自动刷新 就给true
println(String s);//该方法起到写入/换行/刷新 三合一
[code]/*
* 方式一:
* 字符缓冲流特殊功能复制Java文件
*
* 数据源：
* BufferedStreamDemo.java---BufferedReader
* 目的地：
* Copy.java---BufferedWriter
*
* 方式二:
* public PrintWriter(OutputStream out,boolean autoFlush)
* 通过现有的 OutputStream 创建新的 PrintWriter。
* 此便捷构造方法创建必要的中间 OutputStreamWriter
* 后者使用默认字符编码将字符转换为字节。
*/
public class CopyJavaTest {
public static void main(String[] args) throws IOException {
method1();
}
//掌握方式一二即可
public static void method1() throws IOException{
//封装数据源
BufferedReader br = new BufferedReader(new FileReader("OutputStreamWriterDemo.java"));
//封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy3.java"));
//方式一
//读写数据
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
public static void method2() throws IOException{
//封装数据源
BufferedReader br = new BufferedReader(new FileReader("OutputStreamWriterDemo.java"));
PrintWriter pw = new PrintWriter(new FileWriter("Copy4.java"),true);
String line = null;
while((line = br.readLine())!=null){
//写入、换行、刷新三合一
pw.println(line);
}
br.close();
pw.close();
}
//缓冲字符流一次读写一个字符串
private static void method3() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
//缓冲字符流一次读写一个字符数组
private static void method4() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
bw.write(chs, 0, len);
}
bw.close();
br.close();
}
//缓冲字符流一次读写一个字符
private static void method5() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
int ch;
while((ch=br.read())!=-1) {
bw.write(ch);
}
bw.close();
br.close();
}
// 基本字符流一次读写一个字符数组
private static void method6() throws IOException {
FileReader fr = new FileReader("d:\\林青霞.txt");
FileWriter fw = new FileWriter("窗里窗外.txt");
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs, 0, len);
}
fw.close();
fr.close();
}
// 基本字符流一次读写一个字符
private static void method7() throws IOException {
FileReader fr = new FileReader("d:\\林青霞.txt");
FileWriter fw = new FileWriter("窗里窗外.txt");
int ch;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
fw.close();
fr.close();
}
}
序列化和反序列化流
ObjectInputStream
ObjectInputStream(inputStream is)
readObject() -> Object
ObjectOutputStream
ObjectOutputStream(OutputStream os)
成员方法:writeObject(Object obj)
[code]/*
* 序列化:
* 将对象从内存持久化到硬盘文件中 ObjectOutputStream
* 反序列化:
*
*/
public class ObjectOutputStreamTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
write();
read();
}
public static void write() throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Object.txt"));
Student s = new Student("it001", "张曼玉", 35, "北京");//堆内存
oos.writeObject(s);//持久化到"Object.txt"
oos.close();
}
public static void read() throws IOException, ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Object.txt"));
Object obj = ois.readObject();
if(obj instanceof Student){
Student s = (Student)obj;
System.out.println(s);
}
}
}
[code]/*
定义一个学生类。
学生：
学号，姓名，年龄，所在城市
it001,张曼玉,35,北京
it002,王祖贤,33,上海
it003,林青霞,30,西安
*/
//实现序列化接口 表明该类可以序列化操作
public class Student implements Serializable{
/**
*
*/
private static final long serialVersionUID = -8002618292803495097L;
private String id;
private String name;
private int age;
private String city;
public Student() {
}
public Student(String id, String name, int age, String city) {
this.id = id;
this.name = name;
this.age = age;
this.city = city;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + ", city=" + city + "]";
}
}
IO流转换在TCP网络编程的应用
[code]
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/*
使用TCP协议发送数据
创建发送端Socket对象（创建连接）
获取输出流对象
发送数据
释放资源
*/
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.println("Client:");
System.out.println();
// method1();
// method2();
// method3();
// method4();
// method5();
method6();
}
//字节流
public static void method1() throws IOException, IOException{
//创建发送端Socket对象
Socket s = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
// Socket s = new Socket(InetAddress.getLocalHost(), 9999);
//获取输出流对象
OutputStream os = s.getOutputStream();
//数据源
String st = "Hello TCP I'm method1";
//发送数据
os.write(st.getBytes());
//释放资源
s.close();
}
//字符缓冲输流
public static void method2() throws IOException, IOException{
// 创建发送端socket对象
Socket s = new Socket("127.0.0.1", 9999);
//获取输出流
//这是客户端将来和服务端建立起连接之后 连接到双方的字节输出流
OutputStream os = s.getOutputStream();
//字符流
OutputStreamWriter osw = new OutputStreamWriter(os);
//字符缓冲流
BufferedWriter bw = new BufferedWriter(osw);
//发送数据
String str = "Hello TCP I'm method2";
bw.write(str);
bw.flush();
bw.close();
//释放资源
s.close();
}
//字符缓冲输流
public static void method3() throws IOException, IOException{
// 创建发送端socket对象
Socket s = new Socket("127.0.0.1", 9999);
//获取输出流
//字节输出流->字符输出流->字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//发送数据
String str = "Hello TCP I'm method3";
bw.write(str);
bw.flush();
bw.close();
//释放资源
s.close();
}
//字符打印流
public static void method4() throws IOException, IOException{
// 创建发送端socket对象
Socket s = new Socket("127.0.0.1", 9999);
//获取输出流
//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//字符打印流 封装socket对象中的字节流
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);//启动自动刷新
//发送数据给服务端
String line = "Hello TCP I'm method4";
pw.println(line);
pw.close();
// 释放资源
s.close();
}
//客户端键盘录入服务器控制台输出
public static void method5() throws IOException, IOException{
// 创建发送端socket对象
Socket s = new Socket("127.0.0.1", 9999);
//获取输出流
//字节输入流->字符输入流->字符缓冲输入流
//键盘录入数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
String line = null;
line = br.readLine();
//写数据
pw.println(line);
// 释放资源
s.close();
}
//客户端读取文本文件服务器控制台输出
public static void method6() throws IOException, IOException{
// 创建发送端socket对象
Socket s = new Socket("127.0.0.1", 9999);
//读文件
BufferedReader br = new BufferedReader(new FileReader("Client.txt"));
//发数据给服务端
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line = null;
while((line = br.readLine())!=null){
bw.write(line);
System.out.println(line);
}
bw.close();
// 释放资源
s.close();
}
}
[code]
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/*
使用TCP协议接收数据
创建接收端Socket对象
监听（阻塞）
获取输入流对象
获取数据
输出数据
释放资源
*/
public class Server {
public static void main(String[] args) throws IOException {
System.out.println("Server:");
System.out.println();
// method1();
// method2();
// method3();
// method4();
// method5();
// method6();
method7();
}
//字节流
public static void method1() throws IOException, IOException{
System.out.println("method1:");
//创建接收端Socket对象
ServerSocket ss = new ServerSocket(9999);
//监听（阻塞）
Socket s = ss.accept();
//获取输入流对象
InputStream is = s.getInputStream();
//获取数据
byte[] bt = new byte[1024];
int len = is.read(bt);//用于存储读到的字节个数
//输出数据
/*
* public String(byte[] bytes,int offset,int length)
* 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String
* 新 String 的长度是字符集的函数，因此可能不等于该子数组的长度
*/
InetAddress address = s.getInetAddress();
System.out.println("client ---> " + address.getHostName());
System.out.println(new String(bt,0,len));
//释放资源
ss.close();
}
//字符缓冲流
public static void method2() throws IOException, IOException{
System.out.println("method2:");
// 创建服务端socket
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = br.readLine();
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
//释放资源
s.close();
}
//客户端键盘录入服务器控制台输出
public static void method3() throws IOException, IOException{
// 创建服务端socket
System.out.println("Server method3");
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
System.out.println("wait...");
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = br.readLine();
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
//释放资源
s.close();
}
//客户端键盘录入服务器写到文本文件
public static void method4() throws IOException, IOException{
System.out.println("Server method4");
// 创建服务端socket
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = br.readLine();
//写数据到文件
//默认覆盖
// BufferedWriter bw = new BufferedWriter(new FileWriter("Server.txt"));
//指定追加
BufferedWriter bw = new BufferedWriter(new FileWriter("Server.txt",true));
bw.write(line);
bw.newLine();
bw.flush();
bw.close();
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
//释放资源
s.close();
}
//客户端键盘录入服务器写到文本文件
public static void method5() throws IOException, IOException{
// 创建服务端socket
System.out.println("Server method5");
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = br.readLine();
//写数据到文件
//封装socket对象中的字节流
PrintWriter pw = new PrintWriter("Server.txt");
//把数据发送给服务端
pw.println(line);
pw.close();
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
//释放资源
s.close();
}
//客户端读取文本文件服务器控制台输出
public static void method6() throws IOException, IOException{
// 创建服务端socket
System.out.println("Server method6");
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
System.out.println("wait...");
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = null;
while((line = br.readLine())!=null){
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
}
//释放资源
s.close();
}
//客户端读取文本文件服务器写到文本文件
public static void method7() throws IOException, IOException{
// 创建服务端socket
System.out.println("Server method7");
ServerSocket ss = new ServerSocket(9999);
// 让服务端socket对象进入监听状态 看是否有发送端对服务端进行连接
Socket s = ss.accept();
// 获取输入流对象 读取来自发送端的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// 解析数据
String line = br.readLine();
//写数据到文件
//封装socket对象中的字节流
PrintWriter pw = new PrintWriter("Server.txt");
//把数据发送给服务端
pw.println(line);
pw.close();
String ip = s.getInetAddress().getHostName();
System.out.println(ip + ":" + line);
//释放资源
s.close();
}
}
- Linux网络编程 - TCP高级应用：socket文件描述符属性控制
- Linux 网络编程 之 TCP状态转换
- Rhyme/ java TCP网络编程 聊天室（群聊与私聊）TCP、多线程、IO流编程完整代码实现
- python网络编程之udp 与 tcpsocket的应用
- 网络层、传输层、应用层、端口通信协议编程接口 - http，socket，tcp/ip 网络传输与通讯知识总结
- 网络编程TCP的一些基本应用操作
- 【tcp网络编程】用Socket建立一个简单的文本转换服务器
- 网络编程之TCP应用
- TCP/IP模型解读+联系生活中应用+网络编程实现
- 黑马程序员-java网络编程以及IO流的应用
- Java网络编程（tcp在服务器上应用多线程）
- 黑马程序员_Java网络编程之TCP应用
- 网络编程二：TCP传输、TCP双向传输、文本转换、并发上传图片、客户端并发登录
- 详解Linux服务器最大tcp连接数 网络编程 在tcp应用中，server事先在某个固定端口监听，client主动发起连接，经过三路握手后建立tcp连接。那么对单机，其最大并发tcp连接数是多少？
- TCP/IP网络层级结构及其应用服务(一)
- 找呀志_java网络编程（4）TCP/IP、Http和Socket差额
- Windows Phone 7 网络编程之天气预报应用
- 嵌入式成长轨迹26 【Linux应用编程强化】【中嵌第二阶段】【Linux网络应用】
- 黑马程序员-网络编程之TCP传输小总结
- 高性能网络编程7--tcp连接的内存使用