修改计算机网路

code/src/main/java/com/raorao/interview/toutiao/T.java

@@ -0,0 +1,11 @@
+package com.raorao.interview.toutiao;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-25-10:02
+ */
+public class T {
+
+}

code/src/main/java/com/raorao/interview/toutiao/t1/Main.java

@@ -0,0 +1,25 @@
+package com.raorao.interview.toutiao.t1;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-25-10:02
+ */
+public class Main {
+
+  public static void main(String[] args) {
+
+  }
+
+  private static void process(boolean[][] arr) {
+    int num = 1;
+    int m = arr.length;
+    int n = arr[0].length;
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+
+      }
+    }
+  }
+}

code/src/main/java/com/raorao/interview/toutiao/t2/Main.java

@@ -0,0 +1,88 @@
+package com.raorao.interview.toutiao.t2;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * 字符串.
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-25-10:31
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    int t = Integer.parseInt(scanner.nextLine());
+    List<String> ret = new ArrayList<>();
+    List<List<String>> inputs = new ArrayList<>();
+    for (int i = 0; i < t; i++) {
+      int n = Integer.parseInt(scanner.nextLine());
+      List<String> temp = new ArrayList<>();
+      while (n-- > 0) {
+        temp.add(scanner.nextLine());
+      }
+      inputs.add(temp);
+    }
+    for (List<String> list : inputs) {
+      ret.add(process(list));
+    }
+    for (String s : ret) {
+      System.out.println(s);
+    }
+
+  }
+
+  private static String process(List<String> strings) {
+    List<String> ret = new ArrayList<>();
+    for (int i = 0; i < strings.size(); i++) {
+      for (int j = i + 1; j < strings.size(); j++) {
+        ret.add(process(strings.get(i), strings.get(j)));
+      }
+    }
+    for (String s:ret){
+      if (s.equals("Yeah")){
+        return "Yeah";
+      }
+    }
+    return "Sad";
+  }
+
+  private static String process(String s1, String s2) {
+    char start = s2.charAt(0);
+    List<String> starts = find(s1, start);
+    for (String s : starts) {
+      if (s.equals(s2)) {
+        return "Yeah";
+      }
+    }
+    return "Sad";
+  }
+
+  private static List<String> find(String s1, char start) {
+    List<String> ret = new ArrayList<>();
+    for (int i = 0; i < s1.length(); i++) {
+      if (start == s1.charAt(i)) {
+        String tmp1 = s1.substring(i + 1, s1.length());
+        String tmp;
+        if (i == 0) {
+          tmp = tmp1;
+        } else {
+          tmp = tmp1 + s1.substring(0, i);
+        }
+        ret.add(start + tmp);
+        ret.add(start + invert(tmp));
+      }
+    }
+    return ret;
+  }
+
+  private static String invert(String s) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = s.length() - 1; i >= 0; i--) {
+      sb.append(s.charAt(i));
+    }
+    return sb.toString();
+  }
+}

code/src/main/java/com/raorao/interview/toutiao/t5/Main.java

@@ -0,0 +1,67 @@
+package com.raorao.interview.toutiao.t5;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-25-11:30
+ */
+public class Main {
+
+  private static final String ERR = "cannot_answer";
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    String[] line1 = scanner.nextLine().split(" ");
+    int n = Integer.parseInt(line1[0]);
+    int m = Integer.parseInt(line1[1]);
+    char[] y = new char[n];
+    int[] k = new int[n];
+    char[] x = new char[n];
+    char[][] q = new char[m][2];
+    for (int i = 0; i < n; i++) {
+      String line = scanner.nextLine();
+      String[] eq = line.split(" = ");
+      y[i] = eq[0].charAt(0);
+      String[] eq2 = eq[1].split(" - ");
+      k[i] = Integer.parseInt(eq2[0]);
+      x[i] = eq2[1].charAt(0);
+    }
+    for (int i = 0; i < m; i++) {
+      String line = scanner.nextLine();
+      String[] eq = line.split(" - ");
+      q[i][0] = eq[0].charAt(0);
+      q[i][1] = eq[1].charAt(0);
+    }
+
+    String[] ret = new String[2];
+    for (int i = 0; i < m; i++) {
+      ret[i] = process(y, k, x, q[i]);
+    }
+    for (String s : ret) {
+      System.out.println(s);
+    }
+  }
+
+  private static String process(char[] y, int[] k, char[] x, char[] q) {
+    int index1 = getIndex(y, q[0]);
+    int index2 = getIndex(x, q[1]);
+    if (index1 != -1 && index2 != -1 && index1 != index2) {
+      int res = k[index1] - k[index2];
+      return String.valueOf(res);
+    }
+    return ERR;
+  }
+
+  private static int getIndex(char[] chars, int q) {
+    for (int i = 0; i < chars.length; i++) {
+      if (q == chars[i]) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+}

code/src/main/java/com/raorao/java/socket/TCPClient.java

@@ -0,0 +1,45 @@
+package com.raorao.java.socket;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.InputStreamReader;
+import java.net.Socket;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-27-22:40
+ */
+public class TCPClient {
+
+  public static void main(String[] args) throws Exception {
+    //创建两个String类型的字符串用来发送和接受
+    String sentence;
+    String modifiedSentence;
+
+    //创建输入流，用来接受键盘输入
+    BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
+
+    //创建一个Socket类型的 clientSocket 用来发起服务器和客户机之间的连接
+    Socket clientSocket = new Socket("127.0.0.1", 6789);
+
+    //创建向服务器发送信息的输出流
+    DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
+
+    //创建输入流，用来接收来自服务器的字节流
+    BufferedReader inFormServer = new BufferedReader(
+        new InputStreamReader(clientSocket.getInputStream()));
+
+    //读流数据
+    sentence = inFromUser.readLine();
+
+    //向服务器发送sentence的字节数据
+    outToServer.writeBytes(sentence + '\n');
+
+    //获取字节流数据为String
+    modifiedSentence = inFormServer.readLine();
+
+    System.out.println("Form Server :" + modifiedSentence);
+  }
+}

code/src/main/java/com/raorao/java/socket/TCPServer.java

@@ -0,0 +1,46 @@
+package com.raorao.java.socket;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.InputStreamReader;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.channels.Channel;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-27-22:39
+ */
+public class TCPServer {
+
+  public static void main(String[] args) throws Exception {
+    String clientSentence;
+    String capitalizedSentence;
+
+    //服务器Socket用来建立连接
+    ServerSocket welcomeSocket = new ServerSocket(6789);
+
+    while (true) {
+
+      //用这个连接来获取和发送，自客户端发的数据流
+      Socket connectionSocket = welcomeSocket.accept();
+
+      //获取来自客户端的字节流
+      BufferedReader inFromClient = new BufferedReader(
+          new InputStreamReader(connectionSocket.getInputStream()));
+
+      //发送更改后的数据流
+      DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
+
+      //读取字节成String字符串
+      clientSentence = inFromClient.readLine();
+
+      capitalizedSentence = clientSentence.toUpperCase() + '\n';
+
+      outToClient.writeBytes(capitalizedSentence);
+    }
+  }
+
+}

code/src/main/java/com/raorao/java/socket/UDPClient.java

@@ -0,0 +1,60 @@
+package com.raorao.java.socket;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-27-22:29
+ */
+public class UDPClient {
+
+  public static void main(String[] args) throws Exception {
+    //读取键盘输入的字节流
+    BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
+
+    //为客户机创建了一个传输信息的门，但是并没与向TCP那样建立连接
+    DatagramSocket clientSocket = new DatagramSocket();
+
+    //这行代码调用了DNS查询，查询主机名对应的IP地址，后面要用这个地址来向服务器发送信息
+    InetAddress IPAddress = InetAddress.getByName("localhost");
+
+    //需要发送的字节数组
+    byte[] sendData;
+
+    //接受的字节数组
+    byte[] receiveData = new byte[1024];
+
+    String sentence = inFromUser.readLine();
+
+    //将字符串转为字节放入sendData
+    sendData = sentence.getBytes();
+
+    //UDP数据报分组，里面包含想要发送的内容以及目的地址等信息
+    DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
+
+    //用这个‘门’来发送这个数据包
+    clientSocket.send(sendPacket);
+
+    //获取数据报分组
+    DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
+
+    //用‘门’获取数据报
+    clientSocket.receive(receivePacket);
+
+    //将获取的数据报转为String类型数据
+    String modifiedSentence = new String(receivePacket.getData());
+
+    System.out.println("From Server:" + modifiedSentence);
+
+    //关闭这个门
+    clientSocket.close();
+
+  }
+
+}

code/src/main/java/com/raorao/java/socket/UDPServer.java

@@ -0,0 +1,46 @@
+package com.raorao.java.socket;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-08-27-22:19
+ */
+public class UDPServer {
+
+  public static void main(String[] args) throws IOException {
+    DatagramSocket serverSocket = new DatagramSocket(9876);
+    byte[] receiveData = new byte[1024];
+
+    byte[] sendData;
+
+    while(true){
+
+      DatagramPacket receivePacket = new DatagramPacket(receiveData,receiveData.length);
+
+      serverSocket.receive(receivePacket);
+
+      String sentence = new String(receivePacket.getData());
+
+      InetAddress IPAddress = receivePacket.getAddress();
+
+      int port = receivePacket.getPort();
+
+      String capitalized = sentence.toUpperCase();
+
+      sendData = capitalized.getBytes();
+
+      DatagramPacket sendPacket = new DatagramPacket(sendData,sendData.length,IPAddress,port);
+
+      serverSocket.send(sendPacket);
+      System.out.println("Recived: " + sentence +  "from " + IPAddress + ":" + port);
+      System.out.println("Send back:" + capitalized);
+    }
+
+  }
+}

code/src/main/java/com/raorao/java/test/A.java

@@ -1,11 +0,0 @@
-package com.raorao.java.test;
-
-/**
- * .
- *
- * @author Xiong Raorao
- * @since 2018-08-10-23:27
- */
-public class A {
-
-}

interview/answer.md

@@ -237,9 +237,16 @@ Cache就是加快读取的速度，分为磁盘缓存和CPU缓存。
 
 ## UDP为什么不可靠
 
-UDP只有一个socket接受缓冲区，没有socket发送缓冲区，即只要有数据就发，不管对方是否可以正确接受。而在对方的socket接受缓冲区满了之后，新来的数据报无法进入到socket接受缓冲区，此数据报就会被丢弃，udp是没有流量控制的，故UDP的数据传输是不可靠的。
+1. socket 缓冲区
 
-⑴当客户发送请求报文后，等待服务器的应答，客户进程收到一个应答后，就将其存放到该套接字的接收缓冲区中，此时，如果刚好有其他进程给该客户的这个端口地址发送了一个数据报，则客户的套接字会误以为是服务器的应答，也会将其存放到这个接收缓冲区中。这样在客户的接收缓冲区中会出现噪声数据。
-⑵当客户发送请求报文后，等待服务器的应答，但是由于UDP协议是不可靠的，数据在网络中传输有可能会丢失。
-⑶由于通信前没有事先建立联系，客户在发送请求时不知道服务器的状态。
-⑷由于通信前双方的处理能力未知且没有流量控制机制，发送端发送数据是并不清楚接收端的接收能力，如果快速设备无限制地向慢速设备发送UDP数据报，可能会由于接收方的接收缓冲区溢出而丢失大量数据，而且这种丢失对于通信双方而言都是不清楚的。
+应用程序通过调用send, read方法向网络上发送应用数据，该过程中由于应用程序调用send/write的速度同网络介质发送数据的速度存在差异，所以，应用通过socket发往网络上的的数据会先被缓存，即socket发送缓冲区，等待网络空闲时再发送出去。同样，socket从网络上接受到的数据，也会被缓存，即socket接受缓冲区，等待应用程序把数据从中读出。其中，应用程序调用send发送数据，是将数据拷贝到socket的内核发送缓冲区中，然后send便会返回，即send返回后，数据并不一定发送到目的地去了，send仅仅是把数据拷贝到socket的内核发送缓冲区。
+
+2. TCP可靠数据传输原理
+
+每个Tcp socket在内核中都有一个发送缓冲区和一个接受缓冲区。tcp协议要求对端在接受到tcp数据报之后，要对其序号进行ACK，只有当接受到一个tcp数据报的ACK之后，才
+
+可以把这个tcp数据报从socket的发送缓冲区清除，另外tcp还有一个流量控制功能，tcp的socket接受缓冲区接受到网络上来的数据缓存起来后，如果应用程序一直没有读取，socket接受缓冲区满了之后，发生的动作是：通知对端TCP协议中的窗口关闭，这便是滑动窗口的实现，保证TCP socket接受缓冲区不会溢出，因为对方不允许发送超过所通知窗口大小的数据， 这就是TCP的流量控制，如果对方无视窗口大小而发出了超过窗口大小的数据，则接收方TCP将丢弃它。这两点保证了tcp是可靠传输的。
+
+3. UDP不可靠数据传输原理
+
+UDP只有一个socket接受缓冲区，没有socket发送缓冲区，即只要有数据就发，不管对方是否可以正确接受。而在对方的socket接受缓冲区满了之后，新来的数据报无法进入到socket接受缓冲区，此数据报就会被丢弃，udp是没有流量控制的，故UDP的数据传输是不可靠的。

interview/network/http.md

@@ -1,6 +1,7 @@
 <!-- TOC -->
 
 - [Http常见状态码](#http常见状态码)
+- [http 和 https 的区别](#http-和-https-的区别)
 
 <!-- /TOC -->
 # Http常见状态码
@@ -30,3 +31,7 @@
 
 500 internal sever error，表示服务器端在执行请求时发生了错误
 503 service unavailable，表明服务器暂时处于超负载或正在停机维护，无法处理请求
+
+# http 和 https 的区别
+
+