用JAVA如何实现UDP端口扫描器？

使用 DatagramSocket(int port) 建立socket（套间字）服务。
将数据打包到DatagramPacket中去
通过socket服务发送 （send()方法）
关闭资源
public static void main(String[] args) {

DatagramSocket ds = null; //建立套间字udpsocket服务

try {
ds = new DatagramSocket(8999); //实例化套间字，指定自己的port
} catch (SocketException e) {
Systemoutprintln("Cannot open port!");
Systemexit(1);
}

byte[] buf= "Hello, I am sender!"getBytes(); //数据
InetAddress destination = null ;
try {
destination = InetAddressgetByName("19216815"); //需要发送的地址
} catch (UnknownHostException e) {
Systemoutprintln("Cannot open findhost!");
Systemexit(1);
}
DatagramPacket dp =
new DatagramPacket(buf, buflength, destination , 10000);
//打包到DatagramPacket类型中（DatagramSocket的send()方法接受此类，注意10000是接受地址的端口，不同于自己的端口！）

try {
dssend(dp); //发送数据
} catch (IOException e) {
}
dsclose();
}
}
接收步骤：
使用 DatagramSocket(int port) 建立socket（套间字）服务。（我们注意到此服务即可以接收，又可以发送），port指定监视接受端口。
定义一个数据包（DatagramPacket），储存接收到的数据，使用其中的方法提取传送的内容
通过DatagramSocket 的receive方法将接受到的数据存入上面定义的包中
使用DatagramPacket的方法，提取数据。
关闭资源。
import javanet;

public class Rec {

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

DatagramSocket ds = new DatagramSocket(10000); //定义服务，监视端口上面的发送端口，注意不是send本身端口

byte[] buf = new byte[1024];//接受内容的大小，注意不要溢出

DatagramPacket dp = new DatagramPacket(buf,0,buflength);//定义一个接收的包

dsreceive(dp);//将接受内容封装到包中

String data = new String(dpgetData(), 0, dpgetLength());//利用getData()方法取出内容

Systemoutprintln(data);//打印内容

dsclose();//关闭资源
}
}

发送步骤：

使用 DatagramSocket(int port) 建立socket（套间字）服务。

将数据打包到DatagramPacket中去

通过socket服务发送 （send()方法）

关闭资源

import javaioIOException;  
import javanet;  
  
public class Send {  
  
    public static void main(String[] args)  {  
          
        DatagramSocket ds = null;  //建立套间字udpsocket服务  
          
        try {  
          ds = new DatagramSocket(8999);  //实例化套间字，指定自己的port  
        } catch (SocketException e) {  
            Systemoutprintln("Cannot open port!");  
            Systemexit(1);   
        }  
          
        byte[] buf= "Hello, I am sender!"getBytes();  //数据  
        InetAddress destination = null ;  
        try {  
            destination = InetAddressgetByName("19216815");  //需要发送的地址  
        } catch (UnknownHostException e) {  
            Systemoutprintln("Cannot open findhost!");  
            Systemexit(1);   
        }  
        DatagramPacket dp =   
                new DatagramPacket(buf, buflength, destination , 10000);    
        //打包到DatagramPacket类型中（DatagramSocket的send()方法接受此类，注意10000是接受地址的端口，不同于自己的端口！）  
          
        try {  
            dssend(dp);  //发送数据  
        } catch (IOException e) {  
        }  
        dsclose();  
    }  
}

接收步骤：

使用 DatagramSocket(int port) 建立socket（套间字）服务。（我们注意到此服务即可以接收，又可以发送），port指定监视接受端口。

定义一个数据包（DatagramPacket），储存接收到的数据，使用其中的方法提取传送的内容

通过DatagramSocket 的receive方法将接受到的数据存入上面定义的包中

使用DatagramPacket的方法，提取数据。

关闭资源。

import javanet;  
  
public class Rec {  
  
    public static void main(String[] args) throws Exception {  
          
        DatagramSocket ds = new DatagramSocket(10000);  //定义服务，监视端口上面的发送端口，注意不是send本身端口  
          
        byte[] buf = new byte[1024];//接受内容的大小，注意不要溢出  
          
        DatagramPacket dp = new DatagramPacket(buf,0,buflength);//定义一个接收的包  
          
        dsreceive(dp);//将接受内容封装到包中  
          
        String data = new String(dpgetData(), 0, dpgetLength());//利用getData()方法取出内容  
          
        Systemoutprintln(data);//打印内容  
          
        dsclose();//关闭资源     
    }  
}

1端口占用编译器会报错，可以从错误看出来是不是端口被占用。没有专门的检测工具和方法
2DatagramSocket（在Java中使用UDP协议编程的相关类）
用于接收和发送UDP的Socket实例。该类有3个构造函数：
DatagramSocket()：通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让 *** 作系统分配一个可用的端口。
DatagramSocket(int port)：创建实例，并固定监听Port端口的报文。通常用于服务端
DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
DatagramSocket具有的主要方法如下：
1）receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。“阻塞”是一个专业名词，它会产生一个内部循环，使程序暂停在这个地方，直到一个条件触发。
　2）send(DatagramPacket dp)：发送报文dp到目的地。
　3）setSoTimeout(int timeout)：设置超时时间，单位为毫秒。
　4）close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。
希望对您有帮助谢谢

我把我的代码借鉴给你不知道能不能够帮助你!!!自己原创的
UDPServerjava:
import javanet;
import javautil;
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];
UDPClientjava:
import javanet;
import javautil;
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,bufflength);
private DatagramPacket outpacket ;
public void run() {
int i =0;
try{
socket=new DatagramSocket();
outpacket =new DatagramPacket(new byte[0] ,0,
InetAddressgetByName("127001"),PORT);
Scanner sc =new Scanner(Systemin);
while(schasNextLine()){
byte [] buff1 =scnextLine()getBytes();
outpacketsetData(buff1);
socketsend(outpacket);
socketreceive(inpacket);
Systemoutprintln(new String(buff,0,inpacketgetLength()));
}
}catch(Exception e){
eprintStackTrace();
}
}

public static void main(String []args){
new UDPClient()start();
}
/public UDPServer (DatagramSocket socket ,DatagramPacket inpacket,
DatagramPacket outpacket) {
thissocket = socket ;
thisinpacket = inpacket ;
thisoutpacket = outpacket ;
}/
};
MulticastSocketTestjava:
import javaawt;
import javanet;
import javaio;
import javautil;
//让该类实现Runnable接口，该类的实例可作为线程的target
public class MulticastSocketTest implements Runnable
{
//使用常量作为本程序的多点广播IP地址
private static final String BROADCAST_IP
= "230001";
//使用常量作为本程序的多点广播目的的端口
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 , inBufflength);
//定义一个用于发送的DatagramPacket对象
private DatagramPacket outPacket = null;
public void init()throws IOException
{
try
{
//创建用于发送、接收数据的MulticastSocket对象
//因为该MulticastSocket对象需要接收，所以有指定端口
socket = new MulticastSocket(BROADCAST_PORT);
broadcastAddress = InetAddressgetByName(BROADCAST_IP);
//将该socket加入指定的多点广播地址
socketjoinGroup(broadcastAddress);
//设置本MulticastSocket发送的数据报被回送到自身
socketsetLoopbackMode(false);
//初始化发送用的DatagramSocket，它包含一个长度为0的字节数组
outPacket = new DatagramPacket(new byte[0] , 0 ,
broadcastAddress , BROADCAST_PORT);
//启动以本实例的run()方法作为线程体的线程
new Thread(this)start();
//创建键盘输入流
scan = new Scanner(Systemin);
//不断读取键盘输入
while(scanhasNextLine())
{
//将键盘输入的一行字符串转换字节数组
byte[] buff = scannextLine()getBytes();
//设置发送用的DatagramPacket里的字节数据
outPacketsetData(buff);
//发送数据报
socketsend(outPacket);
}
}
finally
{
socketclose();
}
}

public void run()
{
try
{
while(true)
{
//读取Socket中的数据，读到的数据放在inPacket所封装的字节数组里。
socketreceive(inPacket);
//打印输出从socket中读取的内容
Systemoutprintln("聊天信息：" + new String(inBuff , 0 ,
inPacketgetLength()));
}
}
//捕捉异常
catch (IOException ex)
{
exprintStackTrace();
try
{
if (socket != null)
{
//让该Socket离开该多点IP广播地址
socketleaveGroup(broadcastAddress);
//关闭该Socket对象
socketclose();
}
Systemexit(1);
}
catch (IOException e)
{
eprintStackTrace();
}
}
}
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,bufflength);
socketreceive(inpacket) ;
Systemoutprintln(new String(buff,0,inpacketgetLength()));
byte [] sedData =new String("数据信息："+i)getBytes();
outpacket =new DatagramPacket(sedData,sedDatalength,inpacketgetSocketAddress());
socketsend(outpacket);
i++ ;
}
}catch(Exception e){
eprintStackTrace();
}
}

public static void main(String []args){
new UDPServer()start();
}
/public UDPServer (DatagramSocket socket ,DatagramPacket inpacket,
DatagramPacket outpacket) {
thissocket = socket ;
thisinpacket = inpacket ;
thisoutpacket = outpacket ;
}/
};

你说的还不清楚。Java网络编程使用Socket，同为一个网络下的主机时是肯定没问题的，不论同一局域网或广域网。如果内网跨越网关，我没做过试验，按我的理解，内网主机做客户端，独立主机做服务器应该可行，反之不行。

---