import java.io.*;
import java.net.Socket;
import java.util.ArrayList;

public class GreetingClient {
    public static void main(String [] args)
    {
        //服務(wù)端主機(jī)名
        String serverName = "localhost";
        //服務(wù)端口號(hào)
        int port = Integer.parseInt("6066");
        try {
            // 輸出服務(wù)端主機(jī)名與端口號(hào)
            System.out.println("連接到主機(jī)：" + serverName + " ，端口號(hào)：" + port);
            // 創(chuàng)建 Socket 對象，并嘗試連接到指定的服務(wù)器和端口
            Socket client = new Socket(serverName, port);
            // 輸出此套接字連接的端點(diǎn)的地址
            System.out.println("遠(yuǎn)程主機(jī)地址：" + client.getRemoteSocketAddress());
            // 獲取此套接字的輸出流
            OutputStream outToServer = client.getOutputStream();
            // 使用此套接字的輸出流創(chuàng)建 DataOutputStream 輸出流
            DataOutputStream out = new DataOutputStream(outToServer);
            // 以UTF-8編碼將字符串寫入基礎(chǔ)輸出流
            out.writeUTF("客戶端說：Hello from " + client.getLocalSocketAddress() + "\n");
            // 獲取此套接字的輸入流
            InputStream inFromServer = client.getInputStream();
            // 創(chuàng)建讀取鍵盤輸入內(nèi)容的 InputStreamReader
            InputStreamReader fingerboardReader = new InputStreamReader(System.in,"UTF-8");
            // 創(chuàng)建讀取服務(wù)端輸入內(nèi)容的 InputStreamReader
            InputStreamReader serverDataReader = new InputStreamReader(inFromServer,"UTF-8");
            // 創(chuàng)建存放在鍵盤讀取字符的數(shù)組集合
            ArrayList<Character> fingerboardList = new ArrayList<Character>();
            // 創(chuàng)建存放在服務(wù)端端讀取字符的數(shù)組集合
            ArrayList<Character> serverDataList = new ArrayList<Character>();
            do{
                // 判斷讀取鍵盤輸入內(nèi)容的 InputStreamReader 是否可以讀取
                if(fingerboardReader.ready()){
                    // 讀取鍵盤輸入內(nèi)容的 InputStreamReader 可以讀取
                    // 清空 存放鍵盤讀取字符的數(shù)組集合
                    fingerboardList.clear();
                    // 聲明 鍵盤輸入char變量
                    char fingerboardInputChar;
                    // 讀取鍵盤輸入內(nèi)容的 InputStreamReader 可以讀取，循環(huán)讀取，將讀取的內(nèi)容存入數(shù)組集合，一次輸入讀取完成后ready()返回NO
                    while (fingerboardReader.ready()) {
                        fingerboardInputChar = (char)fingerboardReader.read();;
                        fingerboardList.add(fingerboardInputChar);
                    }
                    // 創(chuàng)建可變字符串 StringBuilder 對象
                    StringBuilder fingerboardStringBuilder = new StringBuilder();
                    // 拼接 存放鍵盤讀取字符的數(shù)組集合 中的字符組成字符串
                    for (Character cha :fingerboardList){
                        fingerboardStringBuilder.append(cha);
                    }
                    // 將可變字符串 StringBuilder 對象 轉(zhuǎn)為字符串 String 對象
                    String fingerboardString = fingerboardStringBuilder.toString();
                    // 如果 轉(zhuǎn)換的字符串不是空的 并且不是一個(gè)換行符
                    if(!fingerboardString.isEmpty() && !fingerboardString.equals("\n")) {
                        // 使用此套接字的輸出流寫出數(shù)據(jù)
                        out.writeUTF("客戶端說：" + fingerboardString);
                        // 如果輸出Goodbye!，跳出循環(huán)
                        if (fingerboardString.equals("Goodbye!\n")) {
                            break;
                        }
                    }
                }
                // 判斷讀取客戶端輸入內(nèi)容的 InputStreamReader 是否可以讀取
                if(serverDataReader.ready()) {
                    // 讀取客戶端輸入內(nèi)容的 InputStreamReader 可以讀取
                    // 清空客戶端讀取字符的數(shù)組集合
                    serverDataList.clear();
                    // 聲明客戶端讀取char變量
                    char serverDataReaderChar;
                    // 讀取客戶端輸入內(nèi)容的 InputStreamReader 可以讀取，循環(huán)讀取，將讀取的內(nèi)容存入數(shù)組集合，一次輸入讀取完成后ready()返回NO
                    while (serverDataReader.ready()) {
                        serverDataReaderChar = (char) serverDataReader.read();
                        serverDataList.add(serverDataReaderChar);
                    }
                    // 創(chuàng)建可變字符串 StringBuilder 對象
                    StringBuilder dataReaderStringBuilder = new StringBuilder();
                    for (Character cha :serverDataList){
                        dataReaderStringBuilder.append(cha);
                    }
                    // 將可變字符串 StringBuilder 對象 轉(zhuǎn)為字符串 String 對象
                    String dataReaderString = dataReaderStringBuilder.toString();
                    // 打印服務(wù)端輸入內(nèi)容
                    System.out.print(dataReaderString);
                    // 服務(wù)端輸出Goodbye，跳出循環(huán)
                    if (dataReaderString.endsWith("Goodbye!\n")) {
                        break;
                    }
                }
            }while (true);
            // 關(guān)閉此套接字
            client.close();
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.ArrayList;

public class GreetingServer extends Thread {
    private ServerSocket serverSocket;

    public GreetingServer(int port) throws IOException
    {
        // 創(chuàng)建服務(wù)端Socket對象
        this.serverSocket = new ServerSocket(port);
        // Socket超時(shí)時(shí)間，設(shè)置為0時(shí)無限制，超時(shí)引發(fā)SocketTimeoutException
        this.serverSocket.setSoTimeout(0);
    }

    public void run() {
        try {
            // 輸出此套接字在其上偵聽的端口
            System.out.println("等待遠(yuǎn)程連接，端口號(hào)為：" + serverSocket.getLocalPort() + "...");
            // 偵聽并接受到此套接字的連接，該方法將阻塞，直到建立連接為止
            Socket server = serverSocket.accept();
            // 輸出此套接字連接的端點(diǎn)的地址
            System.out.println("遠(yuǎn)程主機(jī)地址：" + server.getRemoteSocketAddress());
            // 使用此套接字的輸出流創(chuàng)建 DataOutputStream 輸出流
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            // 以UTF-8編碼將字符串寫入基礎(chǔ)輸出流
            out.writeUTF("服務(wù)端說：謝謝連接我：" + server.getLocalSocketAddress() + "\n");
            // 創(chuàng)建讀取鍵盤輸入內(nèi)容的 InputStreamReader
            InputStreamReader fingerboardReader = new InputStreamReader(System.in,"UTF-8");
            // 創(chuàng)建讀取客戶端輸入內(nèi)容的 InputStreamReader
            InputStreamReader clientDataReader = new InputStreamReader(server.getInputStream(),"UTF-8");
            // 創(chuàng)建存放在鍵盤讀取字符的數(shù)組集合
            ArrayList<Character> fingerboardList = new ArrayList<Character>();
            // 創(chuàng)建存放在客戶端讀取字符的數(shù)組集合
            ArrayList<Character> clientDataList = new ArrayList<Character>();
            do{
                // 判斷讀取鍵盤輸入內(nèi)容的 InputStreamReader 是否可以讀取
                if(fingerboardReader.ready()){
                    // 讀取鍵盤輸入內(nèi)容的 InputStreamReader 可以讀取
                    // 清空 存放鍵盤讀取字符的數(shù)組集合
                    fingerboardList.clear();
                    // 聲明 鍵盤輸入char變量
                    char fingerboardInputChar;
                    // 讀取鍵盤輸入內(nèi)容的 InputStreamReader 可以讀取，循環(huán)讀取，將讀取的內(nèi)容存入數(shù)組集合，一次輸入讀取完成后ready()返回NO
                    while (fingerboardReader.ready()) {
                        fingerboardInputChar = (char)fingerboardReader.read();;
                        fingerboardList.add(fingerboardInputChar);
                    }
                    // 創(chuàng)建可變字符串 StringBuilder 對象
                    StringBuilder fingerboardStringBuilder = new StringBuilder();
                    // 拼接 存放鍵盤讀取字符的數(shù)組集合 中的字符組成字符串
                    for (Character cha :fingerboardList){
                        fingerboardStringBuilder.append(cha);
                    }
                    // 將可變字符串 StringBuilder 對象 轉(zhuǎn)為字符串 String 對象
                    String fingerboardString = fingerboardStringBuilder.toString();
                    // 如果 轉(zhuǎn)換的字符串不是空的 并且不是一個(gè)換行符
                    if(!fingerboardString.isEmpty() && !fingerboardString.equals("\n")) {
                        // 使用此套接字的輸出流寫出數(shù)據(jù)
                        out.writeUTF("服務(wù)端說：" + fingerboardString);
                        // 如果輸出Goodbye!，跳出循環(huán)
                        if (fingerboardString.equals("Goodbye!\n")) {
                            break;
                        }
                    }
                }
                // 判斷讀取客戶端輸入內(nèi)容的 InputStreamReader 是否可以讀取
                if(clientDataReader.ready()) {
                    // 讀取客戶端輸入內(nèi)容的 InputStreamReader 可以讀取
                    // 清空客戶端讀取字符的數(shù)組集合
                    clientDataList.clear();
                    // 聲明客戶端讀取char變量
                    char clientDataReaderChar;
                    // 讀取客戶端輸入內(nèi)容的 InputStreamReader 可以讀取，循環(huán)讀取，將讀取的內(nèi)容存入數(shù)組集合，一次輸入讀取完成后ready()返回NO
                    while (clientDataReader.ready()) {
                        clientDataReaderChar = (char) clientDataReader.read();
                        clientDataList.add(clientDataReaderChar);
                    }
                    // 創(chuàng)建可變字符串 StringBuilder 對象
                    StringBuilder dataReaderStringBuilder = new StringBuilder();
                    for (Character cha :clientDataList){
                        dataReaderStringBuilder.append(cha);
                    }
                    // 將可變字符串 StringBuilder 對象 轉(zhuǎn)為字符串 String 對象
                    String dataReaderString = dataReaderStringBuilder.toString();
                    // 打印客戶端輸入內(nèi)容
                    System.out.print(dataReaderString);
                    // 客戶端輸出Goodbye，跳出循環(huán)
                    if (dataReaderString.endsWith("Goodbye!\n")) {
                        break;
                    }
                }
            }while (true);
            // 關(guān)閉此套接字
            server.close();
            System.out.println("套接字已關(guān)閉");
        }catch(SocketTimeoutException s) {
            // Socket超時(shí)
            System.out.println("Socket timed out!");
        }catch(IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String [] args) {
        int port = Integer.parseInt("6066");
        try {
            Thread t = new GreetingServer(port);
            t.run();
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        InetAddress address = null;
        try {
            // 在給定主機(jī)名稱的情況下，確定主機(jī)的IP地址
            address = InetAddress.getByName("www.juejin.cn");
        }
        catch (UnknownHostException e) {
            System.exit(2);
        }
        // 輸出取此IP地址的主機(jī)名與IP地址字符串
        System.out.println(address.getHostName() + " = " + address.getHostAddress());
        System.exit(0);
    }
}

// 以上程序執(zhí)行結(jié)果為：
// www.juejin.cn = 111.132.34.239

public class Test {
    public static void main(String[] args) {
        System.out.println("端口是否真正在使用：" + isSocketAliveUitlitybyCrunchify("www.juejin.cn",80));
    }

    /**
     * 判斷主機(jī)端口是否已使用
     *
     * @param hostName 主機(jī)名
     * @param port 主機(jī)端口
     * @return boolean - true/false
     */
    public static boolean isSocketAliveUitlitybyCrunchify(String hostName, int port) {
        // 主機(jī)端口是否已使用，默認(rèn)否
        boolean isAlive = false;
        // 超時(shí)設(shè)置，單位毫秒
        int timeout = 2000;

        // 創(chuàng)建一個(gè)套接字
        SocketAddress socketAddress = new InetSocketAddress(hostName, port);
        Socket socket = new Socket();
        System.out.println("主機(jī)名: " + hostName + ", 主機(jī)端口: " + port);

        try {
            // 將此套接字連接到服務(wù)器
            socket.connect(socketAddress, timeout);
            // 關(guān)閉此套接字
            socket.close();
            // 連接未發(fā)生異常，說明主機(jī)端口是使用的
            isAlive = true;

        } catch (SocketTimeoutException exception) {
            System.out.println("套接字超時(shí)異常 " + hostName + ":" + port + ". " + exception.getMessage());
        } catch (IOException exception) {
            System.out.println(
                    "IO異常 - 無法連接到 " + hostName + ":" + port + ". " + exception.getMessage());
        }
        // 返回主機(jī)端口是否已使用的結(jié)果
        return isAlive;
    }
}

// 以上程序執(zhí)行結(jié)果為：
// 主機(jī)名: www.juejin.cn, 主機(jī)端口: 80
// 端口是否真正在使用：true

public class Test {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println("本地主機(jī)地址: " + addr.getHostAddress());
                String hostname = addr.getHostName();
        System.out.println("本地主機(jī)名: "+hostname);
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            InetAddress addr;
            Socket sock = new Socket("www.juejin.cn", 80);
            addr = sock.getInetAddress();
            System.out.println("連接到 " + addr);
            sock.close();
        } catch (java.io.IOException e) {
            System.out.println("無法連接 " + args[0]);
            System.out.println(e);
        }
    }
}

// 以上程序執(zhí)行結(jié)果為：
// 連接到 www.juejin.cn/111.132.34.240