java学习之路 之 网络编程-练习题

最新推荐文章于 2023-03-25 12:45:00 发布
最新推荐文章于 2023-03-25 12:45:00 发布
阅读量3.3k 收藏 2
点赞数 3
分类专栏： 【JavaEE】 JavaEE-知识点详解（附带大量练习题） 文章标签： java 网络编程 socket 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_longshao/article/details/52433596
版权 
package com.atguigu.javase.net;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

// 客户端给服务器发送一个字符串，服务器收到后给客户端回复消息确认
public class NetTest {
	
	@Test
	public void server() {
		ServerSocket server = null; // 服务套接字
		Socket socket1 = null;
		
		InputStream is = null; // 网络输入流
		InputStreamReader isr = null;  // 转换流
		BufferedReader bufReader = null; // 缓冲流
		
		OutputStream os = null; // 网络输出流
		OutputStreamWriter osw = null; // 转换流
		BufferedWriter bufWriter = null; // 缓冲流
		try {
			server = new ServerSocket(9999); // 服务器绑定在端口号9999上
			socket1 = server.accept(); // accept方法会导致程序阻塞, 等待客户端的连接请求,  一旦接受就返回一个Socket对象
			System.out.println(socket1);
			
			is = socket1.getInputStream();
			isr = new InputStreamReader(is);
			bufReader = new BufferedReader(isr);
			
			String line = bufReader.readLine();
			System.out.println(line);
			
			os = socket1.getOutputStream();
			osw = new OutputStreamWriter(os);
			bufWriter = new BufferedWriter(osw);
			bufWriter.write("我收到了你的消息,请放心!!");
			bufWriter.newLine();
			bufWriter.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				bufWriter.close();
			} catch (Exception e2) {
			}
			try {
				socket1.close();
			} catch (Exception e2) {
			}
			try {
				server.close();
			} catch (Exception e2) {
			}
		}
	}
	
	@Test
	public void client() {
		Socket socket2 = null;
		OutputStream os = null;
		OutputStreamWriter osw = null;
		BufferedWriter bufWriter = null;
		
		InputStream is = null;
		InputStreamReader isr = null;
		BufferedReader bufReader = null;
		
		try {
			socket2 = new Socket("127.0.0.1", 9999); // 创建Socket对象的过程,就是发起请求的过程, 连接到服务器需要的信息是主机(IP)和端口Port
			System.out.println(socket2);
			os = socket2.getOutputStream(); // 获取输出流对象
			osw = new OutputStreamWriter(os); 
			bufWriter = new BufferedWriter(osw);
			
			bufWriter.write("你好服务器, 我是客户端 !!");
			bufWriter.newLine();
			bufWriter.flush(); // 把数据刷入网线
			
			is = socket2.getInputStream();
			isr = new InputStreamReader(is);
			bufReader = new BufferedReader(isr);
			String line = bufReader.readLine();
			System.out.println(line);
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufWriter.close();
			} catch (Exception e2) {
			}
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				socket2.close();
			} catch (Exception e2) {
			}
		}
	}
}	

class ExerServer {
	
	// 服务器主动给客户端 发送一个UTF8字符串, 客户端接收到这个字符串以反向处理再返回给服务器
	public static void main(String[] args) {
		ServerSocket server = null;
		Socket socket1 = null;
		BufferedWriter bufWriter = null;
		BufferedReader bufReader = null;
		try {
			server = new ServerSocket(8888);// 对象一旦创建成功, 标志此程序和端口8888绑定
			while (true) {
				System.out.println("服务器正在8888端口监听........");
				try {
					socket1 = server.accept();
					bufWriter = new BufferedWriter(new OutputStreamWriter(socket1.getOutputStream(), "UTF8"));
					bufReader = new BufferedReader(new InputStreamReader(socket1.getInputStream(), "UTF8"));
					
					bufWriter.write("随便写个字符串, 发送给客户端, 我是服务器");
					bufWriter.newLine();
					bufWriter.flush();
					
					String line = bufReader.readLine();
					System.out.println(line);
				} catch (Exception e) {
					
				} finally {
					try {
						bufReader.close();
					} catch (Exception e2) {
					}
					try {
						bufWriter.close();
					} catch (Exception e2) {
					}
					try {
						socket1.close();
					} catch (Exception e2) {
					}
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				server.close();
			} catch (Exception e2) {
			}
		}
	}
}

class ExerClient {
	// 客户端接收到这个字符串以反向处理再返回给服务器
	public static void main(String[] args) {
		Socket socket2 = null;
		BufferedReader bufReader = null;
		BufferedWriter bufWriter = null;
		try {
			socket2 = new Socket("localhost", 8888);
			bufReader = new BufferedReader(new InputStreamReader(socket2.getInputStream(), "UTF8"));
			bufWriter = new BufferedWriter(new OutputStreamWriter(socket2.getOutputStream(), "UTF8"));
			String line = bufReader.readLine();
			System.out.println(line);
			line = new StringBuilder(line).reverse().toString();
			bufWriter.write(line);
			bufWriter.newLine();
			bufWriter.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				socket2.close();
			} catch (Exception e2) {
			}
		}
	}
}

package com.atguigu.javase.net;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

class TestServer2 {
	// 接收从客户端发送的文件, 并保存在本地, 处理完后,给客户端反馈
	public static void main(String[] args) {
		ServerSocket server = null;
		Socket socket1 = null;
		InputStream is = null; // 网络输入流
		FileOutputStream fos = null; // 文件输出流
		OutputStream os = null; // 网络输出流
		try {
			server = new ServerSocket(6666);
			socket1 = server.accept();
			is = socket1.getInputStream();
			os = socket1.getOutputStream();
			
			fos = new FileOutputStream("girl2.jpg");
			byte[] buf = new byte[8192];
			int realCount = is.read(buf); // 从网络输入流中读取数据
			while (realCount != -1) {
				fos.write(buf, 0, realCount); // 把读到的数据写入本地文件中
				realCount = is.read(buf); // 网络的另一端关闭了输出 返回-1
			}
			os.write("接收完毕".getBytes()); // 通过网络输出流反馈一个字符串
			os.flush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (Exception e2) {
			}
			try {
				is.close();
			} catch (Exception e2) {
			}
			try {
				os.close();
			} catch (Exception e2) {
			}
			try {
				socket1.close();
			} catch (Exception e2) {
			}
			try {
				server.close();
			} catch (Exception e2) {
			}
			
		}
	}
}

class TestClient2 {
	// 发送一个本文件到服务器端 , 再接收服务器反馈
	public static void main(String[] args) {
		Socket socket2 = null;
		FileInputStream fis = null; // 读本地文件的输入流
		OutputStream os = null; // 发送文件,网络输出流
		InputStream is = null; // 网络输入流
		try {
			String host = "localhost";
			int port = 6666;
			socket2 = new Socket(host, port);
			os = socket2.getOutputStream();
			is = socket2.getInputStream();
			
			fis = new FileInputStream("girl.jpg");
			byte[] buf = new byte[8192];
			int realCount = fis.read(buf); //从文件输入流中获取数据
			while (realCount != -1) {
				// 1) 处理
				os.write(buf, 0, realCount); // 把读到的数据直接写入网络输出流
				// 2) 继续
				realCount = fis.read(buf);
			}
			socket2.shutdownOutput(); // 关闭输出流, 发送一个终止信号给网络另一端
			
			realCount = is.read(buf); // 从网络输入流中获取反馈信息,是一个字符串, 所以需要解码
			String line = new String(buf, 0, realCount);
			System.out.println(line);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				fis.close();
			} catch (Exception e2) {
			}
			try {
				os.close();
			} catch (Exception e2) {
			}
			try {
				is.close();
			} catch (Exception e2) {
			}
			try {
				socket2.close();
			} catch (Exception e2) {
			}
			
		}
	}
}


//使用UDP发送一个字符串
package com.atguigu.javase.net;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import org.junit.Test;

public class NetTest3 {
	
	@Test
	public void udpSender()  throws Exception {
		DatagramSocket ds = new DatagramSocket();
		byte[] data = "来一个数据,是一个字符串".getBytes();
		DatagramPacket dp = new DatagramPacket(data, 0, data.length, InetAddress.getByName("127.0.0.1"), 10000);
		ds.send(dp); // 把数据包发送给硬件
		ds.close();
	}
	
	@Test
	public void udpReceiver() throws Exception {
		DatagramSocket ds = new DatagramSocket(10000); // 绑定端口
		byte[] buf = new byte[8192];
		DatagramPacket dp = new DatagramPacket(buf, buf.length);
		// 接收数据
		ds.receive(dp); // 接收到的数据保存在DatagramPacket对象中
		
		String string = new String(buf, 0, dp.getLength());
		System.out.println(string);
		ds.close();
	}
}



package com.atguigu.javase.net;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

import org.junit.Test;
// 创建一个服务器可以接收从客户端传来的信息，并在控制台上打印输出，
// 客户端接收键盘输入的字符串，并发送到服务器，这里需要创建多线程，以防止多个客户端连接服务器时，其中一个服务器发生// 故障时，服务器仍能运行
class TcpService implements Runnable {

	private Socket socket1;
	
	public TcpService(Socket socket1) {
		this.socket1 = socket1;
	}
	
	@Override
	public void run() {
		BufferedReader bufReader = null;
		try {
			bufReader = new BufferedReader(new InputStreamReader(socket1.getInputStream()));
			String line = bufReader.readLine();
			while (line != null) {
				System.out.println(line);
				line = bufReader.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				socket1.close();
			} catch (Exception e2) {
			}
		}
	}
	
}

class TestServer1 {
	
	public static void main(String[] args) {
		ServerSocket server = null;
		try {
			server = new ServerSocket(7777);
			while (true) {
				System.out.println("服务器在端口7777监听...");
				Socket socket1 = server.accept();
				new Thread(new TcpService(socket1)).start();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				server.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

class TestClient1 {
	
	public static void main(String[] args) {
		Socket socket2 = null;
		BufferedReader bufReader = null;
		BufferedWriter bufWriter = null;
		
		try {
			socket2 = new Socket("localhost", 7777);
			bufReader = new BufferedReader(new InputStreamReader(System.in));
			bufWriter = new BufferedWriter(new OutputStreamWriter(socket2.getOutputStream()));
			String line = bufReader.readLine();
			while (line != null) {
				bufWriter.write(line);
				bufWriter.newLine();
				bufWriter.flush();
				
				line = bufReader.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				bufWriter.close();
			} catch (Exception e2) {
			}
			try {
				socket2.close();
			} catch (Exception e2) {
			}
		}
	}
}



package com.atguigu.javase.net;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * 创建服务器和客户端，使得服务器和客户端可以互相打字进行交流
 */
class Tcp implements Runnable {
// 接收从网络获取到的信息，并在控制台上，打印输出	
private Socket socket;
	
	public Tcp(Socket socket) {
		this.socket = socket;
	}
	
	@Override
	public void run() {
		BufferedReader bufReader = null;
		try {
			bufReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String line = bufReader.readLine();
			while (line != null) {
				System.out.println(line);
				line = bufReader.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
			}
			try {
				socket1.close();
			} catch (Exception e2) {
			}
		}
	}
}

class TestServer3 {

	public static void main(String[] args) {
		// 创建客户端
		ServerSocket server = null;
		Socket socket1 = null;
		BufferedReader br = null; // 键盘输入流
		BufferedReader br1 = null; // 网络输入流
		BufferedWriter bw =null; // 网络输出流
		try {
			server = new ServerSocket(8888);
			System.out.println("服务器正在端口8888监听......");
			socket1 = server.accept();
			
			br = new BufferedReader(new InputStreamReader(System.in));
			bw = new BufferedWriter(new OutputStreamWriter(socket1.getOutputStream()));
			br1 = new BufferedReader(new InputStreamReader(socket1.getInputStream()));
			// 创建线程，并运行
			new Thread(new Tcp(socket1)).start();
			
			// 键盘输入的字符串并传给客户端
			String line = br.readLine();
			while (line != null) {
				bw.write(line);
				bw.newLine();
				bw.flush();
				
				line = br.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				br1.close();
			} catch (IOException e) {
			}
			try {
				bw.close();
			} catch (IOException e) {
			}
			try {
				socket1.close();
			} catch (IOException e) {
			}
			try {
				server.close();
			} catch (IOException e) {
			}
		}
	}
}


class TestClient3 {
	
	public static void main(String[] args) {
		Socket socket2 = null;
		BufferedReader br = null; // 网络输入流
		BufferedReader br2 = null; // 键盘输入流
		BufferedWriter bw = null; // 网络输出流
		try {
			socket2 = new Socket("127.0.0.1" ,8888);
			br = new BufferedReader(new InputStreamReader(socket2.getInputStream()));
			br2 = new BufferedReader(new InputStreamReader(System.in));
			bw = new BufferedWriter(new OutputStreamWriter(socket2.getOutputStream()));
			// 创建线程并运行
			new Thread(new Tcp(socket2)).start();
			
			// 接收键盘传入的字符串，并发送到服务器端
			String line2 = br2.readLine();
			while (line2 != null) {
				bw.write(line2);
				bw.newLine();
				bw.flush();
				line2 = br2.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bw.close();
			} catch (IOException e) {
			}
			try {
				br2.close();
			} catch (IOException e) {
			}
			try {
				br.close();
			} catch (IOException e) {
			}
			try {
				socket2.close();
			} catch (IOException e) {
			}
		}
	}
}

OnlyLove_longshao
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java网络编程考试题库
11-27
java网络编程考试题目，内含有Java网络编程期末复习题（I/O、多线程、网络编程、数据库操作），有答案
Java基础 网络编程练习
sun1995sun的博客
03-27 1350
1、编程题 Homework01.java Homework01Server.java Homework01Client.java 1、使用字符流的方式，编写一个客户端程序和服务器端程序 2、客户端发送"name",服务端接收到后，返回"我是nova",nova是你自己的名字 3、客户端发送"hobby",服务端接收到后，返回"编写java程序" 4、不是这两个问题，回复"你说啥呢" import java.io.*; import java.net.InetAddress; import j
finally中的return可以覆盖掉trycatch中的return语句
熊仙森滴Blog
05-09 1157
以下代码执行的结果显示是多少（）？ // 以下代码执行的结果显示是多少（）？ public class Demo{ public static void main(String[] args){ System.out.print(getNumber(0)); System.out.print(getNumber(1)); System.out...
Java基础实训训练 —— Socket通信
lele8103的博客
03-25 406
【代码】Java基础实训训练 —— Socket通信。
java网络编程习题_java网络编程复习题
weixin_28931507的博客
02-17 521
Java网络编程期末复习题(I/O、多线程、网络编程、数据库操作)一、单选题1、下列关于Java线程的说法那些是正确的()A、每一个Java线程可以看成由代码、一个真实的CPU以及数据三部份组成。B、创建线程的两种方法中，从Thread类中继承的创建方式可以防止出现多父类问题。C、Thread类属于java.util程序包。D、以上说法无一正确。2、运行下列程序, 会产生什么结果？()public...
Java面向对象编程上机-练习题汇总.doc
12-02
Java面向对象编程上机-练习题汇总.doc
java练习题-网络编程
11-20
java经典练习题 -网络编程 TCP Socket通信
练习题 - Java编程案例
最新发布
07-10
通过以上示例代码，我们可以根据用户输入的字符、数字、...这些示例可以帮助你了解如何在Java中处理用户输入并根据不同的情景进行逻辑判断。你可以根据这些示例代码，结合实际需求，开发更复杂和实用的Java应用程序。
Java面向对象之继承练习题.doc
08-04
刚开始学，需要简单题目加深对概念的理解
Java网络编程案例教程习题参考答案 .pdf
12-28
参考使用，欢迎下载
《Java网络编程》题库
03-11
《Java网络编程》题库
java网络编程基础习题+部分答案
06-24
java网络编程基础习题+部分答案(这里面的答案是正确的)
java网络编程——网络版题库程序
08-25
java网络编程——网络版题库程序（主要技术java+socket+多线程+mysql），程序是C/S 版本的，由于服务器端是java写的，所有客户端使用android也是很容易与服务器对接的
基于socket编程题的java聊天程序
11-29
基于socket编程题的java聊天程序 实现客户端 服务端通信、登录等功能。是毕业设计和课程设计必不可少的好资源
Java基础知识网络编程（TCP练习）
u013951760的博客
05-10 2297
练习：复制文本练习要求：把客户端的一个文件内容发到服务端，在服务端把数据存储到一个文件当中。相当于复制文件。import java.io.*; import java.net.*;class TxtCopyTestClient { public static void main(String[] args) throws Exception { Socket s=ne
Tomcat的使用（详细流程）
热门推荐
OnlyLove_longshao的博客
11-06 9万+
1、JavaWeb概念 Java web，是用java技术来解决相关web互联网领域的技术的总称。web包括：web服务器和web客户端两部分。 java在最早web客户端的应用有java applet程序，不过这种技术在很久之前就已经被淘汰了。java在服务器端的应用非常丰富， 比如Servlet，jsp和第三方框架等等。java技术对web领域的发展注入了强大的动力 简单的说，就是
SSM框架 之 Spring-AOP（面向切面编程）
OnlyLove_longshao的博客
12-10 1万+
1AOP概述 AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。 两种编程思想。是对面向对象编程的一种补充。 面向切面编程：是指在程序运行期间将某段代码，动态的切入到某个类的指定方法的指定位置的这种编程思想叫做面向切面编程。 AOP编程操作的主要对
实战项目助你掌握JavaSE知识
OnlyLove_longshao的博客
09-15 9974
目标 模拟实现一个基于文本界面的《团队人员调度软件》 熟悉Java面向对象的高级特性，进一步掌握编程技巧和调试技巧 主要涉及以下知识点： 类的继承和多态 对象的关联 static和final修饰符 特殊类的使用 异常处理 需求说明 模拟实现基于文本界面的《团队人员调度软件》。 该软件实现以下功能： 软件启动时，根据给定的数据创建公司部分成员列表（数组） 根据菜单提示，
java学习之路 之 Java集合练习题
OnlyLove_longshao的博客
08-21 8389
import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.ArrayList; import java.util.HashSet; import java.util.Set; import org.junit.Test; /** * 集合 : 解决批量的对象的
java编程练习题_java编程练习题
05-17
好的，以下是一些Java编程练习题： 1. 编写一个程序，输出1到100之间所有的素数。 2. 编写一个程序，计算斐波那契数列中第n个数的值。 3. 编写一个程序，输入一个字符串，输出该字符串中出现次数最多的字符及其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值