1

2018-09-10 11:50:48 +08:00 · 2018-09-10 11:50:48 +08:00 · 23956d6bea
commit 23956d6bea
parent 5494c1d488
12 changed files with 318 additions and 2 deletions
--- a/code/src/main/java/com/raorao/Test.java
+++ b/code/src/main/java/com/raorao/Test.java
@ -1,5 +1,7 @@
 package com.raorao;

+import java.util.Scanner;
+
 /**
 * .
 *
@ -11,7 +13,10 @@ public class Test {
  private int a;

  public static void main(String[] args) {
-
+    String[] s = new String[10];
+    System.out.println(s.length);
+    System.out.println(s[0]);
+    Scanner scanner = new Scanner(System.in);
  }

 }
--- a/code/src/main/java/com/raorao/interview/Killer.java
+++ b/code/src/main/java/com/raorao/interview/Killer.java
@ -0,0 +1,48 @@
+package com.raorao.interview;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-07-16:39
+ */
+public class Killer {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    int n = scanner.nextInt();
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      list.add(scanner.nextInt());
+    }
+
+    int count = 0;
+    while (!check(list)) {
+      for (int i = list.size() - 1; i >= 0; i--) {
+        if (i - 1 >= 0 && list.get(i - 1) > list.get(i)) {
+          list.remove(i);
+        }
+      }
+      count++;
+    }
+    System.out.println(count);
+
+  }
+
+  private static boolean check(List<Integer> list) {
+    if (list.size() == 1) {
+      return true;
+    } else {
+      for (int i = 0; i < list.size() - 1; i++) {
+        if (list.get(i) > list.get(i + 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
--- a/code/src/main/java/com/raorao/interview/alibaba/q1/Main.java
+++ b/code/src/main/java/com/raorao/interview/alibaba/q1/Main.java
@ -0,0 +1,28 @@
+package com.raorao.interview.alibaba.q1;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-07-19:45
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    int N = scanner.nextInt();
+    int[] arr = new int[N];
+    for (int i = 0; i < N; i++) {
+      arr[i] = scanner.nextInt();
+    }
+    if (N < 6) {
+      System.out.println(0);
+      return;
+    }
+
+
+  }
+
+}
--- a/code/src/main/java/com/raorao/interview/alibaba/q2/Main.java
+++ b/code/src/main/java/com/raorao/interview/alibaba/q2/Main.java
@ -0,0 +1,54 @@
+package com.raorao.interview.alibaba.q2;
+
+import java.util.Scanner;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-07-20:05
+ */
+public class Main {
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    String[] temp = scanner.nextLine().split(",");
+    Point target = new Point(Integer.parseInt(temp[0]), Integer.parseInt(temp[1]));
+    temp = scanner.nextLine().split(",");
+
+    int n = temp.length / 2;
+    Point[] points = new Point[n];
+    for (int i = 0; i < n; i += 2) {
+      points[i] = new Point(Integer.parseInt(temp[i]), Integer.parseInt(temp[i + 1]));
+    }
+
+    int min = Integer.MAX_VALUE;
+    int max = Integer.MIN_VALUE;
+    for (int i = 0; i < n; i++) {
+
+    }
+
+  }
+
+  private static double s(Point a, Point b, Point c) {
+    double l1 = Math.sqrt((a.x - b.x) ^ 2 + (a.y - b.y) ^ 2);
+    double l2 = Math.sqrt((a.x - c.x) ^ 2 + (a.y - c.y) ^ 2);
+    double l3 = Math.sqrt((b.x - c.x) ^ 2 + (b.y - c.y) ^ 2);
+    double p = (l1 + l2 + l3) / 2;
+    return Math.sqrt(p * (p - l1) * (p - l2) * (p - l3));
+  }
+
+  static class Point {
+
+    int x;
+    int y;
+
+    public Point() {
+    }
+
+    public Point(int x, int y) {
+      this.x = x;
+      this.y = y;
+    }
+  }
+}
--- a/code/src/main/java/com/raorao/java/althorithm/KMP.java
+++ b/code/src/main/java/com/raorao/java/althorithm/KMP.java
@ -0,0 +1,30 @@
+package com.raorao.java.althorithm;
+
+/**
+ * .
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-07-18:10
+ */
+public class KMP {
+
+  public static void main(String[] args) {
+    int count = 0;
+    for (int i = 0; i < 1000; i++) {
+      if (i % 2 != 0 && i % 3 != 0 && i % 5 != 0) {
+        count++;
+      }
+    }
+    System.out.println(count);
+  }
+
+  public static void find(char[] source, char[] pattern) {
+
+  }
+
+//  private static char[] getPMT(char[] pattern) {
+//    char[] ret = new char[pattern.length];
+//
+//  }
+
+}
--- a/code/src/main/java/com/raorao/java/base/InternTest.java
+++ b/code/src/main/java/com/raorao/java/base/InternTest.java
@ -0,0 +1,22 @@
+package com.raorao.java.base;
+
+/**
+ * String 类的Intern方法测试.
+ *
+ * 说明：Intern方法可以将堆区的String放到常量池中，最终返回的是常量池中的String
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-10-10:14
+ */
+public class InternTest {
+
+  public static void main(String[] args) {
+    String a = "hello";
+    String b = "hello";
+    String c = new String("hello");
+    System.out.println(a == b);
+    System.out.println(a == c);
+    c = c.intern();
+    System.out.println(a == c);
+  }
+}
--- a/code/src/main/java/com/raorao/java/load/BreakAgent.java
+++ b/code/src/main/java/com/raorao/java/load/BreakAgent.java
@ -0,0 +1,34 @@
+package com.raorao.java.load;
+
+import java.lang.reflect.Method;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * 破坏双亲委派模型.
+ *
+ * @author Xiong Raorao
+ * @since 2018-09-10-9:12
+ */
+public class BreakAgent {
+
+  public static void main(String[] args) throws ClassNotFoundException {
+
+    TreeSet
+  }
+
+  public static class Object {
+
+    public void say() {
+      System.out.println("say hello!");
+    }
+  }
+
+  public static class MyLoader extends ClassLoader {
+
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+      return super.findClass(name);
+    }
+  }
+}
--- a/interview/java/base.md
+++ b/interview/java/base.md
@ -47,6 +47,8 @@
    - [静态内部类](#静态内部类)
 - [java 代码块](#java-代码块)
    - [代码块执行顺序](#代码块执行顺序)
+    - [继承类的执行顺序](#继承类的执行顺序)
+    - [调用时机](#调用时机)
 - [java 多态](#java-多态)
    - [多态实现的几种方式](#多态实现的几种方式)
    - [向上转型](#向上转型)
@ -969,6 +971,26 @@ Iterator it = s.iterator();得到的it的真正类型是KeyIterator，是Iterato

 静态代码块 > 构造代码块 > 构造函数

+## 继承类的执行顺序
+
+父类静态代码块 > 子类静态代码块 > 父类代码块 > 父类构造函数 > 子类代码块 > 子类构造函数
+
+## 调用时机
+
+当一个类被主动使用时，Java虚拟就会对其初始化，如下六种情况为主动使用：
+
+1 当创建某个类的新实例时（如通过new或者反射，克隆，反序列化等）
+2 当调用某个类的静态方法时
+3 当使用某个类或接口的静态字段时（除了常量字段）
+4 当调用Java API中的某些反射方法时，比如类Class中的方法，或者java.lang.reflect中的类的方法时
+5 当初始化某个子类时，如果父类没有初始化，则会先初始化父类
+6 当虚拟机启动某个被标明为启动类的类（即包含main方法的那个类）
+
+**不会初始化的情况（被动引用）**
+1 通过子类引用父类的静态字段，不会触发子类的初始化
+2 通过数组来定义引用类，不会触发此类的初始化
+3 常量在编译的时候就存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此也不会触发定义该常量的类的初始化。
+
 # java 多态

 多态体现为父类引用变量可以指向子类对象：父类类型 变量名 = new 子类类型(); 
--- a/interview/java/jvm.md
+++ b/interview/java/jvm.md
@ -32,6 +32,7 @@
    - [可视化工具](#可视化工具)
 - [类文件结构](#类文件结构)
 - [虚拟机类加载机制](#虚拟机类加载机制)
+    - [步骤](#步骤)
 - [虚拟机字节码执行引擎](#虚拟机字节码执行引擎)
    - [运行时栈帧](#运行时栈帧)
    - [方法调用](#方法调用)
@ -493,6 +494,27 @@ jstack | Stack Trace for Java, 显示虚拟机的线程快照

 [类加载机制](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E8%99%9A%E6%8B%9F%E6%9C%BA.md#%E4%B8%89%E7%B1%BB%E5%8A%A0%E8%BD%BD%E6%9C%BA%E5%88%B6)

+## 步骤
+
+1 加载：通过类名来获取定义该类的二进制字节流，将字节流的静态存储结构转化为方法区的运行时数据结构，生成一个Class对象，作为方法区这个类的各种数据的访问入口
+
+2 验证：验证Class文件的格式是否正确，是否危害jvm的安全，符号引用验证
+
+3 准备：正式为类变量分配内存并设置类变量初始值的阶段。
+
+4 解析：将常量池内的符号引用替换为直接引用的过程。类或接口的解析，字段解析，类方法解析，接口方法解析
+
+5 初始化：执行构造器的\<clinit\>()方法的过程，该方法是编译器自动收集类的所有类变量的赋值动作和静态语句块中语句合并产生的，编译器收集的顺序由语句在 源文件中出现的顺序所决定。
+
+```java
+public class Test{
+    static{
+        System.out.println(i);// 这里编译不通过，报非法前项引用错误，因为在地方，无法访问到i变量，因为clinit按顺序访问。解决方法：将i的定义放到static块前面
+    }
+    static int i = 1;
+}
+```
+
 # 虚拟机字节码执行引擎

 执行引擎是Java逊尼基最核心的组成部分之一，在java虚拟机规范中定义了虚拟机字节码执行引擎的概念模型。
--- a/interview/linux/linux.md
+++ b/interview/linux/linux.md
@ -55,6 +55,8 @@
        - [分割命令](#分割命令)
        - [参数代换](#参数代换)
        - [减号-的作用](#减号-的作用)
+- [Linux 共享内存](#linux-共享内存)
+- [Linux 进程通信（IPC）的方式](#linux-进程通信ipc的方式)

 <!-- /TOC -->
 # 文件管理
@ -1847,4 +1849,25 @@ finger root bin daemon adm ?...

 上面这个例子是说：『我将 /home 里面的文件给他打包，但打包的数据不是纪录到文件，而是传送到 stdout； 经过管线后，将 tar -cvf - /home 传送给后面的 tar -xvf - 』。后面的这个 - 则是取用前一个命令的 stdout， 因此，我们就不需要使用 file 了！这是很常见的例子喔！注意注意！

+# Linux 共享内存

+共享内存是最快的IPC，但是需要编程者自己实现共享内存的互斥访问。
+
+内存共享： 两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。
+
+![](https://files.jb51.net/file_images/article/201707/2017071010565722.png)
+
+# Linux 进程通信（IPC）的方式
+
+管道（PIPE）、命名管道（FIFO）、消息队列、共享内存、信号（Signal）、信号量（Semaphore）、套接字、内存映射
+
+管道和命名管道的区别：
+
+对于命名管道FIFO来说，IO操作和普通管道IO操作基本一样，但是两者有一个主要的区别，在命名管道中，管道可以是事先已经创建好的，比如我们在命令行下执行
+mkfifo myfifo
+就是创建一个命名通道，我们必须用open函数来显示地建立连接到管道的通道，而在管道中，管道已经在主进程里创建好了，然后在fork时直接复制相关数据或者是用exec创建的新进程时把管道的文件描述符当参数传递进去。
+一般来说FIFO和PIPE一样总是处于阻塞状态。也就是说如果命名管道FIFO打开时设置了读权限，则读进程将一直阻塞，一直到其他进程打开该FIFO并向管道写入数据。这个阻塞动作反过来也是成立的。如果不希望命名管道操作的时候发生阻塞，可以在open的时候使用O_NONBLOCK标志，以关闭默认的阻塞操作。
+
+
+参考文档：
+- [linux基础——linux进程间通信（IPC）机制总结](https://blog.csdn.net/a987073381/article/details/52006729)
--- a/interview/nowcoder/error.md
+++ b/interview/nowcoder/error.md
@ -1 +1,10 @@
 # 错题记录
+
+# java 自动拆装箱问题
+
+包装类的“==”运算在不遇到算术运算的情况下不会自动拆箱
+包装类的equals()方法不处理数据转型
+
+[题目链接](https://www.nowcoder.com/test/question/done?tid=18342982&qid=3794#summary)
+
+#
--- a/interview/struct/algorithm.md
+++ b/interview/struct/algorithm.md
@ -7,3 +7,22 @@
 # 堆排序的原理

 - [图解排序算法(三)之堆排序](https://www.cnblogs.com/chengxiao/p/6129630.html)
+
+# 求TOPk的问题
+
+1. 使用小顶堆求Topk
+2. 使用快速查找法找到第K大的元素，剩下的一边就是topK
+3. 全排序
+
+# KMP算法
+
+一种字符串查找算法
+
+参考链接：
+
+- [从头到尾彻底理解KMP](https://blog.csdn.net/v_july_v/article/details/7041827)
+- [阮一峰讲解](http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html)
+
+# LRU实现
+
+最小访问的算法实现