javasocket傳數組

Ⅰ 使用java 1用socket程序發送和接收位元組數組 2用十六進制的形式顯示每個位元組裡面的內容

我們定義發送者和接收者，發送者作為客戶端，接收者作為服務端。

Sender.java

importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.Socket;
importjava.util.Arrays;

publicclassSender{

	in(String[]args)throwsException{
		//127.0.0.1代表本機地址，在8888埠上監聽
		Sendersender=newSender("127.0.0.1",8888);
		byte[]bytes={15,16,17,120};//對應的十六進制是0F101178
		sender.send(bytes);
		System.out.println("發送"+Arrays.toString(bytes)+"完畢！");
	}

	privatefinalStringhost;
	privatefinalintport;

	publicSender(Stringhost,intport){
		this.host=host;
		this.port=port;
	}

	privatevoidsend(byte[]bytes)throwsIOException{
		Socketsocket=newSocket(host,port);//建立和服務端的socket

		try(DataOutputStreamdos//建立輸出流
				=newDataOutputStream(socket.getOutputStream())){
			dos.write(bytes,0,bytes.length);//向輸出流寫入bytes
		}
	}
}

Receiver.java

importjava.io.DataInputStream;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;

publicclassReceiver{

	publicstaticvoidmain(String[]args)throwsException{
		Receiverreceiver=newReceiver(8888);
		receiver.receive();
	}

	;

	publicReceiver(intport)throwsIOException{
		serverSocket=newServerSocket(port);
	}

	privatevoidreceive()throwsIOException{
		System.out.println("等待客戶端連接...");
		Socketsocket=serverSocket.accept();
		try(DataInputStreamdis=newDataInputStream(socket.getInputStream())){
			byte[]bytes=newbyte[1024];//假設發送的位元組數不超過1024個
			intsize=dis.read(bytes);//size是讀取到的位元組數

			Stringhex=bytesToHex(bytes,0,size);
			System.out.println("接收到的byte數組的十六進制："+hex);
		}
	}

	/**
	*將byte數組轉化為十六進制字元串
	*
	*@parambytesbyte[]數組
	*@parambegin起始位置
	*@paramend結束位置
	*@returnbyte數組的十六進制字元串表示
	*/
	privateStringbytesToHex(byte[]bytes,intbegin,intend){
		StringBuilderhexBuilder=newStringBuilder(2*(end-begin));
		for(inti=begin;i<end;i++){
			hexBuilder.append(Character.forDigit((bytes[i]&0xF0)>>4,16));//轉化高四位
			hexBuilder.append(Character.forDigit((bytes[i]&0x0F),16));//轉化低四位
			hexBuilder.append('');//加一個空格將每個位元組分隔開
		}
		returnhexBuilder.toString().toUpperCase();
	}

}

運行，首先啟動服務端：

Ⅱ JAVA 問題，用socket編寫一個客戶端程序

給你一個我寫的示例，用的是基於TCP的Socket技術，你鍛煉一下，改一改，不會改再找我！
客戶端：
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class TcpClient {

public static void main(String[] args) throws Exception
{
//創建客戶端Socket服務，並且制定主機和ank
Socket s = new Socket("192.168.1.104",10002);//連接固定的主機和埠

//為了發送數據，獲取Socket中的輸入輸出流
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;

//讀取伺服器發過來的數據
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];

while((line = br.readLine())!=null)
{
out.write(line.getBytes());
if("886".equals(line))
break;

int len = in.read(buf);
String content = new String(buf,0,len);
System.out.println("Server:"+content);
}

s.close();

}
}

伺服器：
/*
* 需求分析：
* 使用TCP協議，寫伺服器端。做到伺服器能收到客戶端的信息，也能向客戶端發送信息
* */

package JavaNetProgramming;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class TcpServer {
public static void main(String[] args) throws Exception
{
//建立伺服器的Socket服務，並且監聽一個埠
ServerSocket ss = new ServerSocket(10002);
Socket s = ss.accept();
InputStream is = s.getInputStream();

//從伺服器端向客戶端發送數據
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;

while(true)
{
//通過accept()方法獲得客戶端傳過來的Socket對象

// System.out.println("getByNanme():"+s.getInetAddress());
System.out.print("getHostAddress():"+s.getInetAddress().getHostAddress());

//獲取客戶端發過來的數據，就要使用客戶端對象的讀取流來讀取數據

byte[] buf = new byte[1024];
int len = is.read(buf);//把流中數據讀到位元組數組中
String content = new String(buf,0,len);
System.out.println(" "+content);

if("886".equals(content))
break;
while((line = br.readLine())!=null)
{
out.write(line.getBytes());
break;
}

}

s.close(); //循環內有判斷語句,這句話才不出錯
ss.close();

}

}

Ⅲ 關於java UDP方面的一些問題

我把我的代碼借鑒給你..不知道能不能夠幫助你..!!!自己原創的
UDPServer.java:
import java.net.*;
import java.util.*;
public class UDPServer extends Thread {
private static final int PORT=10000 ;

private static final int DATA_LEN=2046 ;

private byte []buff =new byte[DATA_LEN];

UDPClient.java:

import java.net.*;
import java.util.*;
public class UDPClient extends Thread {
private static final int PORT=10000 ;

private static final int DATA_LEN=2046 ;

private byte []buff =new byte[DATA_LEN];

private DatagramSocket socket ;

private DatagramPacket inpacket =new DatagramPacket(buff,buff.length);

private DatagramPacket outpacket ;

public void run() {
int i =0;
try{
socket=new DatagramSocket();
outpacket =new DatagramPacket(new byte[0] ,0,
InetAddress.getByName("127.0.0.1"),PORT);
Scanner sc =new Scanner(System.in);
while(sc.hasNextLine()){
byte [] buff1 =sc.nextLine().getBytes();
outpacket.setData(buff1);
socket.send(outpacket);
socket.receive(inpacket);
System.out.println(new String(buff,0,inpacket.getLength()));
}
}catch(Exception e){
e.printStackTrace();
}
}

public static void main(String []args){
new UDPClient().start();
}

/*public UDPServer (DatagramSocket socket ,DatagramPacket inpacket,
DatagramPacket outpacket) {
this.socket = socket ;
this.inpacket = inpacket ;
this.outpacket = outpacket ;
}*/
};

MulticastSocketTest.java:
import java.awt.*;
import java.net.*;
import java.io.*;
import java.util.*;

//讓該類實現Runnable介面，該類的實例可作為線程的target
public class MulticastSocketTest implements Runnable
{
//使用常量作為本程序的多點廣播IP地址
private static final String BROADCAST_IP
= "230.0.0.1";
//使用常量作為本程序的多點廣播目的的埠
public static final int BROADCAST_PORT = 30000;
//定義每個數據報的最大大小為4K
private static final int DATA_LEN = 4096;

//定義本程序的MulticastSocket實例
private MulticastSocket socket = null;
private InetAddress broadcastAddress = null;
private Scanner scan = null;
//定義接收網路數據的位元組數組
byte[] inBuff = new byte[DATA_LEN];
//以指定位元組數組創建准備接受數據的DatagramPacket對象
private DatagramPacket inPacket =
new DatagramPacket(inBuff , inBuff.length);
//定義一個用於發送的DatagramPacket對象
private DatagramPacket outPacket = null;
public void init()throws IOException
{
try
{
//創建用於發送、接收數據的MulticastSocket對象
//因為該MulticastSocket對象需要接收，所以有指定埠
socket = new MulticastSocket(BROADCAST_PORT);
broadcastAddress = InetAddress.getByName(BROADCAST_IP);
//將該socket加入指定的多點廣播地址
socket.joinGroup(broadcastAddress);
//設置本MulticastSocket發送的數據報被回送到自身
socket.setLoopbackMode(false);
//初始化發送用的DatagramSocket，它包含一個長度為0的位元組數組
outPacket = new DatagramPacket(new byte[0] , 0 ,
broadcastAddress , BROADCAST_PORT);
//啟動以本實例的run()方法作為線程體的線程
new Thread(this).start();
//創建鍵盤輸入流
scan = new Scanner(System.in);
//不斷讀取鍵盤輸入
while(scan.hasNextLine())
{
//將鍵盤輸入的一行字元串轉換位元組數組
byte[] buff = scan.nextLine().getBytes();
//設置發送用的DatagramPacket里的位元組數據
outPacket.setData(buff);
//發送數據報
socket.send(outPacket);
}
}
finally
{
socket.close();
}
}

public void run()
{
try
{
while(true)
{
//讀取Socket中的數據，讀到的數據放在inPacket所封裝的位元組數組里。
socket.receive(inPacket);
//列印輸出從socket中讀取的內容
System.out.println("聊天信息：" + new String(inBuff , 0 ,
inPacket.getLength()));
}
}
//捕捉異常
catch (IOException ex)
{
ex.printStackTrace();
try
{
if (socket != null)
{
//讓該Socket離開該多點IP廣播地址
socket.leaveGroup(broadcastAddress);
//關閉該Socket對象
socket.close();
}
System.exit(1);
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

public static void main(String[] args)
throws IOException
{
new MulticastSocketTest().init();
}
}

private DatagramSocket socket ;

private DatagramPacket inpacket ;

private DatagramPacket outpacket ;

public void run() {
int i =0;
try{
socket=new DatagramSocket(PORT);
while(true){
inpacket=new DatagramPacket(buff,buff.length);
socket.receive(inpacket) ;
System.out.println(new String(buff,0,inpacket.getLength()));
byte [] sedData =new String("數據信息："+i).getBytes();
outpacket =new DatagramPacket(sedData,sedData.length,inpacket.getSocketAddress());
socket.send(outpacket);
i++ ;
}
}catch(Exception e){
e.printStackTrace();
}
}

public static void main(String []args){
new UDPServer().start();
}

/*public UDPServer (DatagramSocket socket ,DatagramPacket inpacket,
DatagramPacket outpacket) {
this.socket = socket ;
this.inpacket = inpacket ;
this.outpacket = outpacket ;
}*/
};

Ⅳ java socket如何實現客戶端與客戶端的交互

問題一：客復戶端接收可以採制用下列步驟：
1、無論客戶端還是伺服器都要有能力構造實體bean（比如叫做userbean，存放用戶信息），構造userlist封裝userbean數組。並且，上述類要支持序列化和反序列化。
2、服務端將list
userlist序列化，然後利用serversocket發送。
3、客戶端利用socket接收，對userlist反序列化，遍歷userbean數組得到每一個用戶的信息。
問題二：對於socket，不存在得到還是得不到的——
你要利用tcp、udp協議先要構造和初始化socket才行。
客戶端socket和服務端socket進行全雙工通信。
即使是最簡單im演示程序，用戶的好友列表都應該考慮在伺服器端持久化和管理。
客戶端程序要想得到其好友列表，只需要執行一次」請求/響應」即可。寫這方面的程序，可以參考xmpp相關技術。

Ⅳ 求java中的socket程序DataInputStream用法，求具體代碼！

DataOutputStream out=socket.getOutputStream();

out.writeInt(123);
out.writeByte(....);
out.writeShort(...);

DataInputStream in=socket.getInputStream();

out.readInt();
out.readByte();
out.readShort();

Ⅵ java socket 如何發送一個結構體消息，java中結構體是個什麼概念...

有一個socket 程序，一端是c++寫的socket 服務程序
另一端是Java寫客戶端程序，兩者之間需要通信。
c++/c接收和發送的都是結構體，而Java是直接發送的位元組流或者byte 數組。

解決方法：c++/c socket 在發送結構體的時候其實發送的也是位元組流。因為結構體本身也是內存中的一塊連續數據。問題就變成了如何把結構體手動轉成位元組的問題了
採用類似的報頭：
// packet head
typedef struct tagPacketHead{
long PacketID;
long PacketLen;

}PacketHead;此時套介面的讀寫方式為先讀報頭，在報頭中取出數據負載的長度，然後再讀相應位元組的數據。

包頭後面跟上包體，其中包體的長度，就是上面結構體中的PacketLen，Clinet首先接受包頭，因為包頭是兩邊約定好的，所以可以直接Receive一個定長的消息，也就是這個包頭的長度的消息，從包頭中取得包體的長度後，就可以再次Receive一個包體長度的消息了。那麼Java中如何發送一個結構體呢？下面是解決方法：

使用C/S模式，Client為VC6開發，Server為Java，通過Socket通信。
package org.charry.org;
import java.net.*;
/**
*
* 位元組轉換，參考網路文章
*/
class Packet {
private byte[] buf = null;
/**
* 將int轉為低位元組在前，高位元組在後的byte數組
*/
private static byte[] toLH(int n) {
byte[] b = new byte[4];
b[0] = (byte) (n & 0xff);
b[1] = (byte) (n >> 8 & 0xff);
b[2] = (byte) (n >> 16 & 0xff);
b[3] = (byte) (n >> 24 & 0xff);
return b;
}
/**
* 將float轉為低位元組在前，高位元組在後的byte數組
*/
private static byte[] toLH(float f) {
return toLH(Float.floatToRawIntBits(f));
}
/**
* 構造並轉換
*/
public Packet(int packetID, int packetLen, String packetBody) {
byte[] temp = null;
buf = new byte[packetBody.getBytes().length + 8];
temp = toLH(packetID);
System.array(temp, 0, buf, 0, temp.length);
temp = toLH(packetLen);
System.array(temp, 0, buf, 4, temp.length);
System.array(packetBody.getBytes(), 0, buf, 8, packetBody.length());
}
/**
* 返回要發送的數組
*/
public byte[] getBuf() {
return buf;
}
/**
* 發送測試
*/
public static void main(String[] args) {
try {
String tmp = 「test string!」;
Socket sock = new Socket(」127.0.0.1″, 8888);
sock.getOutputStream().write(
new Packet(123, tmp.length(), tmp).getBuf());
sock.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
如果需要用Java 接收結構體的話只需要將上面過程逆過來即可。

Ⅶ java中socket不斷接收數據問題

其實，方法有幾個。
方法一：
定義一個MsgObject的消息類，裡面存放的為發送的消息內容（專記得序列化）。屬然後再用ObjectOutputStream來把該類弄成一個輸出流發送出去。然後客戶端就用
ObjectInputStream in=new ObjectInputStream(socket.getInputStream());
MsgObject obj=(MsgObject)in.getObject();就能夠得到一個消息類對象了。。
不會的就追問下，我之前是這樣做過的。

方法二：
如果你會json格式，那麼就更加簡單了，直接把你的消息放到json數組裡面。。
這種方法沒試過，我近期使用json過於頻繁才突然記得的，如果你有興趣用這個方法，可以一起討論下。

方法三：
弄多個輸入輸出流，但是這個不建議