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过于频繁才突然记得的，如果你有兴趣用这个方法，可以一起讨论下。

方法三：
弄多个输入输出流，但是这个不建议