用上TCP，先启动服务器的部分，之后开启客户端，之后用客户端发送信息给服务器

package TCP;

import java.io.*;

import java.net.*;

public class TCP服务器 {

public static void main(String[] args) throws Exception{

System.out.println("用TCP启动了服务器");

ServerSocket ServerSocket=new ServerSocket(8888);

while(true){

Socket Socket=ServerSocket.accept();

ObjectInputStream ObjectInputStream=

new ObjectInputStream(Socket.getInputStream());

byte[] b=new byte[1024*60]; 

ObjectInputStream.read(b);

if(new String(b,0,b.length).equals("break")){

Socket.close();

break;

}else{

System.out.println("给诗书画唱三连关注");

System.out.println("接收到的客户端发送来"

+ "的内容为"+new String(b,0,b.length));

}

}

ServerSocket.close();

}

}

package TCP;

import java.io.*;

import java.net.Socket;

import java.util.Scanner;

public class TCP客户端 {

public static void main(String[] args) throws Exception{

System.out.println("启动了客户端");

// 什么是Socket 在计算机通信领域,socket 被翻译为“套接字”,

// 它是计算机之间进行通信的一种约定或一种方式

Socket s=new Socket("localhost",8888);

Scanner s1=new Scanner(System.in);

while(true){

System.out.println("请输入内容");

String str=s1.next();

if(str.trim().equals("break")){

break;

}else{

ObjectOutputStream oos

=new ObjectOutputStream(s.getOutputStream());

oos.write(str.getBytes());

oos.flush();

System.out.println(2);

}

}

s.close();

}

}

用UDP协议来用客户端把当前的日期传给服务端

——————

package date;

import java.io.ByteArrayInputStream;

import java.io.ObjectInputStream;

import java.net.*;

import java.util.Date;

public class UDPfuWuDuan {

public static void main(String[] args) throws Exception{

System.out.println("服务器端启动成功！先启动服务端之后启动"

+ "客户端，"

+ "\n之后客户端会把当前的日期发送到服务端");

// datagram：

// 数据报; 数据包; 数据报文; 數據報; 数据表;

DatagramSocket DatagramSocket

=new DatagramSocket(23456);

byte[] byteArray1=new byte[1026];

DatagramPacket DatagramPacket=new DatagramPacket(byteArray1,

byteArray1.length);

DatagramSocket.receive(DatagramPacket);

byte[] byteArray=DatagramPacket.getData();

int len=DatagramPacket.getLength();

//用readObject()，读传入过来的数据。

//ByteArrayInputStream:可以得到字节，但是不能转int。

//ObjectInputStream：可以转int。

ByteArrayInputStream ByteArrayInputStream

=new ByteArrayInputStream(byteArray,0,len);

//

// ObjectInputStream为对象输入流,

// 把ByteArrayInputStream放到对象输入流的“()”里，

// 就可以把内容转为int类型的数据。

ObjectInputStream ObjectInputStream

=new ObjectInputStream(ByteArrayInputStream);

Date Date =(Date)ObjectInputStream.readObject();

System.out.println(Date.toLocaleString());

DatagramSocket.close();

}

}

package date;

import java.io.ByteArrayOutputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.net.*;

import java.util.Date;

import java.util.Scanner;

public class UDPkeHuDuanDate {

public static void main(String[] args) throws Exception{

//将字符串换为float或者Object

//ByteArrayOutputStream:将内容可以转为字节的流

// ObjectOutputStream:对象必须序列化，另外对象也要转为字节流

System.out.println("客户端启动了");

DatagramSocket DatagramSocket=new DatagramSocket(12345);

Date Date=new Date();

//int类型不能直接转字节数组

//ByteArrayOutputStream：转字节(不能读int)

//ObjectOutputStream:这个可以读int

ByteArrayOutputStream ByteArrayOutputStream

=new ByteArrayOutputStream();

ObjectOutputStream ObjectOutputStream

=new ObjectOutputStream(ByteArrayOutputStream);

ObjectOutputStream.writeObject(Date);

ObjectOutputStream.flush();

//

byte[] byteArray2=ByteArrayOutputStream.toByteArray();

DatagramPacket DatagramPacket2=new DatagramPacket(byteArray2,

byteArray2.length,new InetSocketAddress(

"localhost",23456));

DatagramSocket.send(DatagramPacket2);

DatagramSocket.close();

}

}

////传float和自定义一个用户名和密码试一下

//class yonghu implements Serializable{

//

//}

package TCP;

import java.net.*;

import java.io.*;

import java.util.*;

public class TCP_fuWuQi {

//现在是每个人的Socket保存在对应的线程里

//声明一个集合用来保存每个线程，打印的时候就是遍历保存

//线程的集合，

static Vector<fuwuqi_jieshou> v_xiancheng=new Vector<fuwuqi_jieshou>();

public static void main(String[] args) throws Exception{

System.out.println("服务器启动了");

//1.定义服务器对象

ServerSocket ss=new ServerSocket(12345);

//2.使用服务器对象进行堵塞性接收数据

System.out.println("服务器等待用户传输数据");

while(true){

Socket s=ss.accept();

System.out.println("一个用户建立了链接");

fuwuqi_jieshou fj= new fuwuqi_jieshou(s);

//将每个人的线程保存在线程集合里

v_xiancheng.add(fj);

new Thread(fj).start();

}

// 每一个客户端访问服务器他们使用的是自己的额Socket，

// 现在造成的原因是多个人去访问的时候，他们用的是同一个Socket

// 就会造成堵塞，当前Socket没有被释放掉，其他Socket进不来，就会

// 造成只有一个人可以说话

//

// 如何解决:

// 让每一个访问服务器的Socket单独放入到一个线程里，每个线程放入

// 的Socket不一致,多个线程的Socket不同，调用哪个线程的Socket就是

// 哪个人在说话

// 单独写一个线程类，让访问服务器的Socket通过构造方法传入到线程

// 类里

//原因是因为多个用户访问服务器的时候，他们会进行排队，

//第一个用户满意访问完，第二个用户是不能访问的

//每一个人访问服务器就给当前用户单独开启一个线程

//3.接收Socket里发送的数据

//群聊

//假如有三个客户端，客户端1说一句话，客户端2

//和客户端3收到信息,相应的也是一样

}

}

//接收的线程类

class fuwuqi_jieshou implements Runnable{

Socket s=null;//已经可以得到每个人的Socket对象

//每个人的流应该也要是自己的

DataInputStream dis=null;

DataOutputStream dos=null;

public fuwuqi_jieshou(Socket s){

try {

this.s=s;

dis=new DataInputStream(s.getInputStream());

dos=new DataOutputStream(s.getOutputStream());

} catch (Exception e) {

}

}

@Override

public void run() {

while(true){

try {

String str=dis.readUTF();

System.out.println(str);

//谁发给服务器的内容服务器再讲这个

//内容返回给谁

//而是遍历整个线程集合，判断每个线程是不是属于

//发送信息的线程，如果是的时候什么都不做

//不是的时候就将这个内容转发给其他线程

//取出他们Socket,进行转发

for(fuwuqi_jieshou i:TCP_fuWuQi.v_xiancheng){

if(i==this){

//属性发送信息的线程,那就跳过

continue;

}else{

//取出他们的Socket

Socket s=i.s;

//取出他们的输出流

DataOutputStream dos=new DataOutputStream(s.getOutputStream());

dos.writeUTF(str);

dos.flush();

}

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

package TCP;

import java.net.*;

import java.util.Scanner;

import java.io.*;

public class TCP_keHuDuan {

public static void main(String[] args) throws Exception{

Scanner s1=new Scanner(System.in);

//客户端发送数据到服务器，服务器返回数据给

//发送数据的客户端

System.out.println("客户端3启动了");

//1.定义发送给谁?

Socket s=new Socket("localhost",12345);

new Thread(new kehu_fasong(s)).start();

new Thread(new kehu_jieshou(s)).start();

}

}

//它只需要得到输出流即可

class kehu_fasong implements Runnable{

Socket s=null;

Scanner s1=new Scanner(System.in);

DataOutputStream dos=null;

public kehu_fasong(Socket s){

try {

this.s=s;

dos=new DataOutputStream(s.getOutputStream());

} catch (Exception e) {

// TODO: handle exception

}

}

@Override

public void run() {

while(true){

System.out.println("请输入内容");

String str=s1.next();

try {

dos.writeUTF(str);

dos.flush();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

//接收只需要接收的线程即可

class kehu_jieshou implements Runnable{

Socket s=null;

DataInputStream dis=null;

public kehu_jieshou(Socket s){

try {

this.s=s;

dis=new DataInputStream(s.getInputStream());

} catch (Exception e) {

// TODO: handle exception

}

}

@Override

public void run() {

while(true){

String str;

try {

str = dis.readUTF();

System.out.println(str);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

UDP传输

udp传输数据就好像在大海上运输货物，DatagramSocket就像的两个通信港口的码头，DatagramPacket就像在两端运输货物的轮船

• 发送端（send）

• 创建DatagramSocket,随机端口号

• 创建DatagramPacket,制定数据，长度，地址和端口

• 使用DatagramSocket发送DatagramPacket

• 关闭DatagramSocket

• 异常处理

一旦成功创建一个Socket类的实例，可以用它来发送和接收字节流，发送时调用getOutputStream方法获取一个java.io.OutputStream对象，接收远程对象发送来的信息可以调用getInputStream方法来返回一个java.io.InputStream对象。 

（以下观点仅供参考，不一定准确，其实这个世上几乎没有什么是可靠的，都是不一定准确的，最重要的是努力提升自己各个方面的价值等）

“包”(Packet)是TCP/IP协议通信传输中的数据单位，一般也称“数据包”。在局域网中，“包”是包含在“帧”里的。

datagram（数据报）：在网络层中的传输单元（例如IP）。

一个datagram可能被压缩成一个或几个packets，在数据链路层中传输。