javatcp代碼

Ⅰ 用java編寫TCP文件傳輸程序

1.調用類java.lang.Math的成員方法「public static double random()」運算下面表達式10000次，
(int) (Math.random()*20+0.5)
統計其中生成的整數10，1，2，…，20的個數分別是多少，並輸出統計結果。

2.調用類java.lang.Math的成員方法「public static double random()」設法生成10個互不相同的從『a'到'z'字母，然後對這10個字母按從小到大的方式排序。輸出排序前的字母序列和排序後的字母序列。

3.編寫一個程序，要求輸入5個學生的成績（從0到100的整數），並將這5個數保存到文件「data.txt"中。然後再編寫一個程序，從文件「data.txt」中讀取這5個學生的成績，計算並輸出它們的平均數，然後再按照從小到大的順序輸出這5個學生的成績。

4.編寫一個程序，修改在上一題生成的文件「data.txt」中的文件內容，使得第三個學生的成績變成為這5個學生的平均成績，並在控制台窗口中輸出在修改之後的文件內容

Ⅱ java如何通過tcp發送指令

以下是一個展示java使用tcp通訊的簡單例子，包括伺服器和客戶端代碼：

/**
*TCPServer
*/
import java.io.*;
import java.net.*;
class TCPServer{
public static void main(String[] args)throws IOException{
ServerSocket listen = new ServerSocket(5050);

Socket server = listen.accept();
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
char c = (char)in.read();
System.out.println("收到:" + c);
out.write('s');

out.close();
in.close();
server.close();
listen.close();
}
}

/**
*TCPClient
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws IOException{
Socket client = new Socket("127.0.0.1" , 5050);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();

out.write('c');
char c = (char)in.read();
System.out.println("收到:" + c);
out.close();
in.close();
client.close();
}
}

Ⅲ java代碼TCP/IP網路通信伺服器客戶端，實現雙方信息交互。

packagecom.weixin.test;

importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.InetAddress;
importjava.net.ServerSocket;
importjava.net.Socket;

importorg.junit.Test;

publicclassScoketTest{
	
	@Test
	publicvoidclient()throwsException{
		
		InetAddressi=InetAddress.getByName("127.0.0.1");
		
		
		Sockets=newSocket(i,9000);
		
		OutputStreamoutputStream=s.getOutputStream();
		
		outputStream.write("服務端你好,我是客戶端哦!".getBytes());
		
		s.shutdownOutput();
		InputStreaminputStream=s.getInputStream();
		
		intlength=0;
		
		byte[]bytes=newbyte[1024];
		
		while((length=inputStream.read(bytes))!=-1){
			System.err.println(newString(bytes,0,length));
		}
		
		inputStream.close();
		outputStream.close();
		s.close();
	}
	
	
	@Test
	publicvoidserver()throwsException{
		
		ServerSocketserverSocket=newServerSocket(9000);
		
		Socketsocket=serverSocket.accept();
		
		InputStreaminputStream=socket.getInputStream();
		
		OutputStreamoutputStream=socket.getOutputStream();
		
		intlength=0;
		
		byte[]bytes=newbyte[1024];
		
		while((length=inputStream.read(bytes))!=-1){
			System.err.println(newString(bytes,0,length));
		}
		
		outputStream.write("客戶端你好，本王已收到!".getBytes());
		
		outputStream.close();
		inputStream.close();
		socket.close();
		serverSocket.close();
		
		
		
		
	}

}

Ⅳ 在Java中實現TCP協議編程中怎麼傳

在Java中實現TCP協議編程

ServerSocket：編寫TCP網路服務程序,首先要用到java.net.ServerSocket類用以創建伺服器Socket

構造方法：

ServerSocket(intport)：創建綁定到特定埠的伺服器套接字

ServerSocket(intport,intbacklog)：利用指定的backlog(伺服器忙時保持連接請求的等待客戶數量),創建伺服器套接字並將其綁定到指定的本地埠號。

ServerSocket(intport,intbacklog,InetAddressbindAddr)：使用指定的埠、偵聽backlog和要綁定到的本地IP地址創建伺服器。

Socket：客戶端要與伺服器建立連接,必須先創建一個Socket對象

常用構造方法

Socket(Stringhost,intport)：創建一個流套接字並將其連接到指定主機上的指定埠號。

Socket(InetAddressaddress,intport)：創建一個流套接字並將其連接到指定IP地址的指定埠號。

伺服器端程序調用ServerSocket類中的accept()方法等待客戶端的連接請求，一旦accept()接收了客戶端連接請求，該方法返回一個與該客戶端建立了專線連接的Socket對象，不用程序去創建這個Socket對象。建立了連接的兩個Socket是以IO流的方式進行數據交換的，Java提供了Socket類中的getInputStream()返回Socket的輸入流對象，getOutputStream()返回Socket的輸出流對象。

TCP伺服器與TCP客戶端間的數據的接受圖示：

用TCP實現伺服器與客戶端的「聊天」：

實例代碼：

客戶端：

packagecom.hbsi.net;

importjava.net.Socket;

importjava.io.*;

publicclassTcpClient{

publicstaticvoidmain(String[]args)throwsException{

//1.建立tcp客戶端socket，要確定要連接的伺服器ip，port

Sockets=newSocket("192.168.49.87",9009);

//獲取鍵盤錄入

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

//2.通過建立的socket，獲取輸出流對象

//數據輸出給伺服器端

OutputStreamout=s.getOutputStream();

BufferedWriterbwout=newBufferedWriter(newOutputStreamWriter(out));

//獲取伺服器端返回的數據

//讀取伺服器端發過來的信息InputStreamReader()

BufferedReaderbrin=newBufferedReader(newInputStreamReader(

s.getInputStream()));

Stringline=null;

while((line=br.readLine())!=null){

if(line.equals("over"))

break;

bwout.write(line);

bwout.newLine();

bwout.flush();

Stringstr=brin.readLine();

System.out.println("server:"+str);

}

br.close();

s.close();

}

}

伺服器端：

packagecom.hbsi.net;

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.InputStream;

importjava.io.InputStreamReader;

importjava.io.OutputStreamWriter;

importjava.net.ServerSocket;

importjava.net.Socket;

publicclassTcpServer{

publicstaticvoidmain(String[]args)throwsException{

//1.建立伺服器socket

ServerSocketss=newServerSocket(9009);

//2.調用accept()

Sockets=ss.accept();

System.out.println(s.getInetAddress().getHostAddress()

+"...connection");

//讀取客戶的信息的輸入流

InputStreamin=s.getInputStream();

BufferedReaderbrin=newBufferedReader(newInputStreamReader(in));

//向客戶端發送信息輸出流，服務端向客戶端返回信息OutputStreamWriter()

BufferedWriterbrout=newBufferedWriter(newOutputStreamWriter(

s.getOutputStream())); Stringline=null;

while((line=brin.readLine())!=null){

System.out.println("client:"+line);

brout.write(line.toUpperCase());//伺服器端收到信息後，將信息轉為大寫返回給客戶端toUpperCase()

brout.newLine();

brout.flush();

}

s.close();

ss.close();

}

}

Ⅳ java寫tcp客戶端測試類該怎麼寫

1.TCP服務端的程序編寫

package test;

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

public class MyTcp{
private BufferedReader reader;
private ServerSocket serverSocket;
private Socket socket;
/**
* 創建服務端的程序，讀取客戶端傳來的數據
*/
void getserver(){
try {
serverSocket = new ServerSocket(8998); //實例化服務端socket
System.out.println("伺服器套接字已經創建成功");
while (true) {
System.out.println("等待客戶機的連接:");
socket = serverSocket.accept(); //實例化socket對象
reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); //實例化BufferReader對象
getClientMessage();
}
} catch (Exception e) {
e.printStackTrace();
}

}

private void getClientMessage() {
try {
while (true) {
System.out.println("客戶機傳來的信息是："+reader.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
MyTcp myTcp = new MyTcp(); //創建本類對象
myTcp.getserver();
}
}
2.TCP客戶端程序編寫

package test;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.channels.WritableByteChannel;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.BevelBorder;

public class MyTcpClient extends JFrame{
private PrintWriter printWriter;
Socket socket;
private JTextField jTextField = new JTextField();
private JTextArea jTextArea = new JTextArea();
Container container;
/**
* 創建的Tcp客戶端程序
*/

public MyTcpClient (String title) {
super(title);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
container = this.getContentPane();
final JScrollPane jScrollPane = new JScrollPane();
jScrollPane.setBorder(new BevelBorder(BevelBorder.RAISED)); //顯示邊框
getContentPane().add(jScrollPane,BorderLayout.CENTER);
jScrollPane.setViewportView(jTextArea);
container.add(jTextField,"South"); //將文本框放在窗體下面
jTextField.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
printWriter.println(jTextField.getText()); //將文本框的信息寫入流（為下面的輸出流寫入信息做准備）
jTextArea.append(jTextField.getText() + "\n");
jTextArea.setSelectionEnd(jTextArea.getText().length());
jTextField.setText(null);
}
});
}

private void connect() {
jTextArea.append("嘗試連接中...\n");
try {
socket = new Socket("127.0.0.1",8998);
printWriter = new PrintWriter(socket.getOutputStream(),true); //將printwriter中的信息流寫入到套接字的輸出流傳送給服務端
jTextArea.setText("已完成連接\n\n");
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
MyTcpClient myTcpClient = new MyTcpClient("向伺服器發送數據");
myTcpClient.setSize(500,200);
myTcpClient.setVisible(true);
myTcpClient.connect();
}
}

3.效果展示
<1>先將服務端的程序跑起來

<2>再將客戶端的程序跑起來

<3>.客戶端和服務端進行交互

Ⅵ 求 基於java的Modbus/TCP協議 源代碼

public static void TestModbus() throws Exception{
IpParameters params = new IpParameters();
params.setHost("localhost");//地址
params.setPort(502);//埠
ModbusFactory factory = new ModbusFactory();
ModbusMaster master = factory.createTcpMaster(params, true);

// 初始化
try {
master.init();
readHoldingRegistersTest(master,1,0,3);

} catch (ModbusInitException e) {
e.printStackTrace();
} finally {
master.destroy();
}

}

public static void main(String[] args) {
try {
TestModbus();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}

private static void readHoldingRegistersTest(ModbusMaster master,
int slaveId, int start, int len) {
try {
// ReadInputRegistersRequest request = new ReadInputRegistersRequest(
// slaveId, start, len);
// ReadInputRegistersResponse response = (ReadInputRegistersResponse) master
// .send(request);
ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(
slaveId, start, len);
ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master
.send(request);
if (response.isException()) {
System.out.println("Exception response: message="
+ response.getExceptionMessage());
} else {
ByteQueue byteQueue= new ByteQueue(12);
response.write(byteQueue);
System.out.println(byteQueue);

System.out.println(Arrays.toString(response.getShortData()));
short[] list = response.getShortData();
for(int i = 0; i < list.length; i++){
System.out.print(list[i] + " ");
}
}
} catch (ModbusTransportException e) {
e.printStackTrace();
}
}

Ⅶ java如何通過tcp向指定的IP發送指令並獲得返回的包

以下是一個展示java使用tcp通訊的簡單例子，包括伺服器和客戶端代碼：

/**
*TCPServer
*/
import java.io.*;
import java.net.*;
class TCPServer{
public static void main(String[] args)throws IOException{
ServerSocket listen = new ServerSocket(5050);

Socket server = listen.accept();
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
char c = (char)in.read();
System.out.println("收到:" + c);
out.write('s');

out.close();
in.close();
server.close();
listen.close();
}
}

/**
*TCPClient
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws IOException{
Socket client = new Socket("127.0.0.1" , 5050);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();

out.write('c');
char c = (char)in.read();
System.out.println("收到:" + c);
out.close();
in.close();
client.close();
}
}

Ⅷ 怎麼用java寫一個針對各種不同請求的TCP服務端

伺服器監聽埠 做個無限循環 接到一個連接就創建一個通道線程，並將通道線程存儲到一個list集合中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/*
* 4.用socket通訊寫出多個客戶端和一個伺服器端的通訊，
* 要求客戶發送數據後能夠回顯相同的數據（回顯功能）（實用TCP方式）。
*/
public class Test4Server {

// 主入口
public static void main(String[] args) throws IOException {
scoketServer();
}

// 開啟的tcp8888監聽埠
public static void scoketServer() throws IOException {
ServerSocket server = new ServerSocket(8888);
while (true) {
// 未連通前線程阻塞，連通後開啟一個socket通道線程後繼續監聽8888埠
Socket socket = server.accept();
System.out.println(socket.getInetAddress().getHostAddress()
+ "連接進入");
new SocketThread(socket).start();
}
}

}

// 一個伺服器埠中監聽多個客服端通道線程
class SocketThread extends Thread {
// 所有通道寫入流的集合
private static List<PrintWriter> list =new ArrayList<PrintWriter>();

private BufferedReader bufferedReader;
private PrintWriter printWriter;

public SocketThread(Socket socket) throws IOException {
this.bufferedReader = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
this.printWriter = new PrintWriter(socket.getOutputStream());
list.add(printWriter);
}

@Override
public void run() {
String string = null;
while (true) {
try {
// 伺服器在通道中讀到的信息回顯給客服端
string = bufferedReader.readLine();
System.out.println("客服端信息：" + string);
for(PrintWriter printWriter:list ){
printWriter.write("伺服器回顯：" + string + "\r\n");
printWriter.flush();
}
} catch (IOException e) {

}
}

}
}

客服端代碼 可以用在區域網中用多台來連接測試

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Test4Client {
public static Object obj = new Object();

// 客服端的主入口
public static void main(String[] args) throws IOException {
socketClient();
}

// 與伺服器連通地址本機（127.0.0.1），區域網中其他機器是（伺服器在區域網中的ip地址） 埠都是8888
public static void socketClient() throws IOException {
Socket socket = new Socket("127.0.0.1", 8888);
if (socket.isConnected()) {
// 如果連接成功了就開啟寫和讀的進程
new writer(socket).start();
new read(socket).start();
} else {
System.out.println("伺服器未開啟");
}
}
}

// 寫入到通道的線程
class writer extends Thread {
@SuppressWarnings("unused")
private Socket socket;
private PrintWriter printWriter;
private Scanner scanner = new Scanner(System.in);
private String str = null;

public writer(Socket socket) throws IOException {
this.socket = socket;
this.printWriter = new PrintWriter(socket.getOutputStream());

}

@Override
public void run() {
scanner.useDelimiter("\r\n");

while (true) {
System.out.print("請輸入信息：");
// 產生掃描器的線程阻塞
str = scanner.next();
System.out.println("我說："+str);
printWriter.write(str + "\r\n");
printWriter.flush();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

// 從通道中讀取的線程
class read extends Thread {
private Socket socket;
private BufferedReader bufferedReader;
private String str = null;

public read(Socket socket) throws IOException {
this.socket = socket;
this.bufferedReader = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
}

@Override
public void run() {
while (true) {

try {
str = bufferedReader.readLine();
System.out.println(str);
} catch (IOException e) {
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
}
}

Ⅸ 求一段最簡單的java的TCP文件傳輸的代碼，多謝了。

就收ServerSocket和Socket的使用，一個監聽，一個連接，將文件寫入到輸出流中，接收端獲取輸入流，完畢之後關閉連接，監聽端自然斷開。文件接收完畢，結束。代碼原先有，現在找不到了。

Ⅹ 用java編寫一個能進行簡單TCP/IP通信的C/S程序

import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer
{
public static void main(String[] args) throws Exception
{
// 創建伺服器端的socket對象
ServerSocket ss = new ServerSocket(5000);

// 監聽連接
Socket socket = ss.accept();
// 直到連接建立好之後代碼才會往下執行

System.out.println("Connected Successfully!");

}

}

import java.net.Socket;

public class TcpClient
{
public static void main(String[] args) throws Exception
{
Socket socket = new Socket("127.0.0.1", 5000);
}

}