public class IPDemo {
	public static void main(String[] args) throws UnknownHostException {
		// 获取本地主机ip地址对象。
		InetAddress ip = InetAddress.getLocalHost();
		System.out.println(ip.getHostAddress());//192.168.1.167
		System.out.println(ip.getHostName());//PC201508162051
		// // 获取其他主机的ip地址对象。只要输入iP或域名
		InetAddress byName = InetAddress.getByName("PC201508162051");// PC201508162051/192.168.1.167
		InetAddress byName2 = InetAddress.getByName("www.baidu.com");// www.baidu.com/61.135.169.121
		System.out.println(byName);
		System.out.println(byName2);
	}
}

/*  
 * 发送键盘录入信息  
 */  
public class UDPSend2 {  
    public static void main(String[] args) throws Exception {  
        DatagramSocket ds = new DatagramSocket();  
        BufferedReader bfr = new BufferedReader(  
                new InputStreamReader(System.in));  //转换流，转成字节
        String line = null;  
      
       byte[] buf = null;  
        DatagramPacket dp = null;  
        while ((line = bfr.readLine()) != null) {  
            buf = line.getBytes();  
            dp = new DatagramPacket(buf, buf.length,  
                    InetAddress.getByName("192.168.229.1"), 10000);
//192.168.1.255广播地址，在这个频段里的所有ip都可以接收，聊天室  
            ds.send(dp);  
              
            if("886".equals(line)){  
                break;  
            }  
        }  
        ds.close();  
        buf.clone();  
    }  
}  

public class UDPChatDemo {  
    public static void main(String[] args) throws IOException {  
        DatagramSocket sendSocket = new DatagramSocket();  
        DatagramSocket ReceiveSocket = new DatagramSocket(10002);  
          
        new Thread(new ChatSend(sendSocket)).start();  
        new Thread(new ChatReceive(ReceiveSocket)).start();  
    }  
}  

• 建立服务端的socket服务，ServerSocket，并监听一个端口  
• 获取连接过来的客服端对象，通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。  
• 客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。  
• 关闭服务端（可选）  

public class TCPServerDemo {
	public static void main(String[] args) throws IOException {
		// 建立服务端的socket服务，并监听一个端口
		ServerSocket ss = new ServerSocket(10003);
		// 通过accept方法获取连接过来的客户端对象
		Socket socket = ss.accept();
		String ip = socket.getInetAddress().getHostAddress();
		System.out.println(ip + "......connected");
		// 获取客户端发过来的数据，那么要使用客户端对象的读取流来获取数据
		InputStream in = socket.getInputStream();
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf, 0, len));
		socket.close();// 关闭客户端
		ss.close();// 关闭服务端，可选的操作
	}
}

/*  
 * 需求：建立一个文本转换服务器。  
 * 客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。  
 * 而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。  
 *   
 * 分析：  
 * 客户端  
 * 既然是操作设备上的数据，那就可以使用IO技术，并按照io操作规律来思考  
 * 源：键盘录入  
 * 目的：网络设备，网络输出流  
 * 而且操作的是文本数据，可以用字符流  
 *   
 * 步骤： 
 * 1、建立服务  
 * 2、获取键盘输入  
 * 3、将数据发给客户端  
 * 4、获取服务端返回的数据  
 * 5、结束，关闭资源  
 */  
class TransClient {  
    public static void main(String[] args) throws UnknownHostException,  
            IOException {  
        Socket s = new Socket(InetAddress.getLocalHost(), 10005);  
        BufferedReader bfrb = new BufferedReader(new InputStreamReader(  
                System.in));  
  
        // 定义目的，将数据写入socket输出流，发给服务器  
        OutputStream out = s.getOutputStream();  
        OutputStreamWriter ow = new OutputStreamWriter(out);  
        BufferedWriter bfw = new BufferedWriter(ow);  
  
        // 定义读取流  
        InputStream in = s.getInputStream();  
        InputStreamReader is = new InputStreamReader(in);  
        BufferedReader bfr = new BufferedReader(is);  
  
        String line = null;  
        while ((line = bfrb.readLine()) != null) {  
            bfw.write(line);  
            bfw.newLine();  
            bfw.flush();  
  
            // 读取数据  
            String data = bfr.readLine();  
            System.out.println(data);  
        }  
  
        bfrb.close();  
        s.close();  
    }  
}  
  
/*  
 * 服务端： 源：socket读取流 目的：socket输出流。  
 */  
class TransServer {  
    public static void main(String[] args) throws IOException {  
        ServerSocket ss = new ServerSocket(10005);  
        Socket s = ss.accept();  
  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip + "....connected");  
  
        InputStream in = s.getInputStream();  
        InputStreamReader isr = new InputStreamReader(in);  
        BufferedReader bfr = new BufferedReader(isr);  
  
        // 目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。  
        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(  
                s.getOutputStream()));  
          
        String line = null;  
        while((line=bfr.readLine()) != null){  
            bufOut.write(line.toUpperCase());  
            bufOut.newLine();  
            bufOut.flush();  
        }  
        s.close();  
        ss.close();  
    }  
}  
  
public class TCPTransText{  
    public static void main(String[] args) {  
        new TransClient();  
        new TransServer();  
    }  
}  

/*  
 * 客户端  
 */  
class TextClient {  
    public static void main(String[] args) throws UnknownHostException,  
            IOException {  
        Socket s = new Socket(InetAddress.getLocalHost(), 10007);  
  
        File file = new File("AwtDemo.java");  
  
        BufferedReader bfr = new BufferedReader(new FileReader(file));  
  
        // 将数据写入到socket流中  
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
  
        String line = null;  
        while ((line = bfr.readLine()) != null) {  
            out.println(line);  
        }  
        // 关闭客户端的输出流。相当于给流中加入一个结束标记-1.  
        // 结束标记很重要，不然TCP中程序停不下来  
        s.shutdownOutput();  
  
        // 接收服务端发过来的数据  
        BufferedReader bfrs = new BufferedReader(new InputStreamReader(  
                s.getInputStream()));  
  
        String data = bfrs.readLine();  
        System.out.println(data);  
  
        bfr.close();  
        s.close();  
    }  
}  
  
class TextServer {  
    public static void main(String[] args) throws IOException {  
        ServerSocket ss = new ServerSocket(10007);  
        Socket s = ss.accept();// 接收客户端的socket流  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip + "....connected");  
  
        //建立读取客户端数据的流  
        BufferedReader bfr = new BufferedReader(new InputStreamReader(  
                s.getInputStream()));  
        //建立文件，关联流  
        PrintWriter out = new PrintWriter(new FileWriter("server.java"),true);  
          
        String line = null;  
        while((line=bfr.readLine()) != null){  
            out.println(line);  
        }  
          
        //建立给客户端回馈机制  
        PrintWriter outToC = new PrintWriter(s.getOutputStream(),true);  
        outToC.println("上传成功");  
          
        out.close();  
        s.close();  
        ss.close();  
    }  
}