笔试ing..不断记录耶~

🐇一、方法

StringBuilder的一些特殊方法

因为StringBuilder可以修改内容，String类内容无法修改，所以它具有一些String不具有的一些方法。

1.reserve方法——反转

public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("hello world");
        System.out.println(sb.reverse());
        System.out.println(sb);
    }


//结果：
dlrow olleh
dlrow olleh

可以看到sb本身也被修改了 

2.delete( int start, int end )——删除指定范围的内容

StringBuilder sb = new StringBuilder("hello world");
sb.delete(5,10);
System.out.println(sb);
//输出:hellod

从输出结果可以看到索引为10的‘d’并没有被删除（要记得索引下标是从0开始的），也就是说这是一个左闭右开区间 [5,10) 。Java中区间的取值一般来说都是左闭右开区间。

3.insert ( int start ,插入的数据 ）在索引为start的位置插入数据

StringBuilder sb = new StringBuilder("hello world");
//System.out.println(sb.reverse());
sb.insert(5,"呵呵");
System.out.println(sb);
//输出结果：hello呵呵 world

String与char [ ] 类型和byte[ ]的转换

1.String -> char[ ]

  String str  = "hello";
    char[] a = str.toCharArray();
    System.out.println(Arrays.toString(a));
    //输出：[h, e, l, l, o]

2.获取字符串中索引下标对应的字符,通过遍历也可实现String -> char[ ]

String str  = "hello";
char b = str.charAt(1);
System.out.println(b);
//输出：e

3.char[ ] -> String

char[] a = {'a','b','c','1','2'};
String str =new  String(a);//全部转换
String str1 = new String(a,1,3);//部分转换
System.out.println(str);
System.out.println(str1);
//结果:abc12
       bc1

4.String -> byte[ ]

String str  = "hello world";
byte[] b = str.getBytes();
System.out.println(Arrays.toString(b));

//输出结果：[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]

char 通常是处理文本内容时使用，byte一般在网络传输或者输入输出中(读写文件)使用例如判断网速时默认单位就是byte。

字符串常用操作

字符串的比较

equals方法
equalsIgnoreCase方法——不区分大小写的比较
compareTo方法——比较两个字符串大小关系

      String str = "hello";
        String str1 = "Hello";
        System.out.println(str.equals(str1));
        System.out.println(str.equalsIgnoreCase(str1));
        System.out.println(str.compareTo(str1));
//输出结果：
false
true
32

输出的32是大小写字母的ASCLL相差的单位

字符串查找

上表中最常使用的是第一个方法，代码示例如下：

String str = "hello";
System.out.println(str.contains("ell"));
System.out.println(str.contains("world"));
//结果：
true
false

其他的几种方法读者下去可以多多尝试

字符串替换

replaceAll (a , b )——将字符串中所有a换成b
replaceFirst ( a, b )——替换首个内容

String str = "hello";
String str1 = str.replaceAll("l","h");
String str2 = str.replaceFirst("l","h");
System.out.println(str1);
System.out.println(str2);
//结果：hehho
       hehlo

要记住，String的所有修改操作的内部都是创建一个新的字符，一定要记住字符串的不可变性！！！

字符串拆分

public String[ ] split (String regex ) ——将全部字符串拆分
public String[ ] split (String regex，int limit)——部分拆分，限制个数

        String str = "hello Java I came";
        String[] str1 = str.split(" ");//按空格拆分
        String [] str2 = str.split(" ",2);//按空格拆成2个
        System.out.println(Arrays.toString(str1));
        System.out.println(Arrays.toString(str2));
//输出结果：[hello, Java, I, came]
           [hello, Java I came]

注意事项：
一些特殊字符作为分割符号时要转义处理，|、*、+ 前面加上“\”,如果是“.” 前面加上“\”

       String str = "192.168.1.1";
        String[] sr1 = str.split("\\.");
        System.out.println(Arrays.toString(sr1));
        //输出结果：[192, 168, 1, 1]
字符串截取

substring方法

        String str = "helloworld";
        System.out.println(str.substring(5));//从索引开始截取到结尾
        System.out.println(str.substring(5,8));//截取部分，左闭右开区间
//结果:world
       wor

其他操作方法

双端队列方法

queue.peek() == queue.peekFirst() 查看队首元素
queue.peekLast() 查看队尾元素
queue.add() == queue.addFirst() 从队首添加元素
queue.addLast() 从队尾添加元素
queue.poll() == queue.pollFirst() 删除队首元素
queue.pollLast() 删除队尾元素
queue.removeFirst() 删除并返回队首元素
queue.removeLast() 删除并返回队尾元素

🐱 二、Jmeter性能指标

指标一：响应时间

响应时间：对请求做出响应所需要的时间，是用户感知软件性能的主要指标，响应时间包括：

• 用户客户端呈现时间
• 请求/响应数据网络传输时间
• 应用服务器处理时间
• 数据库系统处理时间

响应时间多少合理？

对于一个web系统，普通接受的响应时间标准是2、5、8秒。
2秒钟之内响应客户是非常好的
5秒钟之内响应客户是可以接受的
8秒钟是客户能够接受的响应的上限

指标二：并发用户数

在线用户数跟内存关系最大 web-session放在内存里，如果内存小，而用户量很大则支撑不住
并发：用于从业务的角度模拟真实用户访问同时访问。
并发数：同时访问系统的用户数。
在C/S或B/S结构的应用，系统的性能主要有服务器决定。服务器在大量用户同时访问时，压力最大。
并发分为：

1. 严格并发：很多用户同时对某一个按钮进行点击
2. 广义并发：很多用户对不同按钮进行点击操作，各做各的

用户数包括：系统用户数（软件系统注册的用户总数）；在线用户数（某时间段内访问的用户数，这些用户只是在线，但不一定同时做某一件事情）；并发用户数（某一个事件同时向软件系统提交请求的用户数）
问题：组长 小李，你测试下这个web系统的性能，看能够支持多少并发？ 小李：我咋搞？
在确定并发用户数量之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作），然后基于场景获得其并发用户数
场景场景：访问网站首页、登录功能、核心业务功能、个人中心

  示例
一个OA系统，该系统有3000个用户，平均每天大约有400个用户访问系统，对一个典型用户来说，一天只在8小时内使用该系统，且从登录到退出该系统的平均时间为4小时。
 C=nL/T=4004/8=200 C^=200+3根号C 如果系统不熟悉，并发用户     数咋算？
 并发用户数量的统计的方法目前还没有准确的公式 不同系统会有不同的并发特点
 例如OA系统统计并发用户数量的经验公式：使用系统用户数量*（5%-20%）

指标三：吞吐量

• 性能测试：指单位时间内系统处理用户的请求数
• 从业务角度看：吞吐量可以用：请求数/秒、页面数/秒、人数/天或处理页面数/小时等单位来衡量用请求数/秒或页面数/秒来衡量
• 从网络角度看：吞吐量可以用：字节/秒来衡量
  对于交互式应用来说，吞吐量指标反映的是服务器承受的压力，他能够说明系统的负载能力
  TPS：每秒事务数 -> 吞吐率

公式：F=VUR/T=1001/5=20

计算 当没有遇到性能瓶颈的时候，吞吐量与虚拟用户数之间存在一定的联系，可以采用一下公式计算： F=VUR/T=100/5=20 
其中F为吞吐量，VU表示虚拟用户个数，R标识每个虚拟用户发出的请求数，T表示性能测试所用的时间

指标四：性能计数器

性能计数器：是描述服务器或操作系统性能的一些数据指标。
比如：内存 CPU 磁盘等资源使用率等

指标五：思考时间

Think Time：消息和消息之间发送的间隔时间
从业务角度看，这个时间指用户进行操作时每个请求之间的时间间隔
在做性能测试时，为了模拟这样的时间间隔，引入了思考时间这个概念，来更加真实的模拟用户的操作。

  思考时间： 什么是多快好省？ 多–并发量 快-----延时、响应时间 ：客户感知的感应时间：端到端的 好–稳定性（长时间运行） 省—资源使用率 什么是环境初始化？ 没有经过初始化的性能环境=没有作用的环境
（运维：Linux系统注入网络延时的方法可以进行模拟 数据库：数据库导出来）

🐖三、计算机网络模型

七层模型任务和功能

①应用层（FTP、SMTP、HTTP、DNS、TELNET）：

• 任务：提供系统与用户的接口
• 功能：文件访问、访问与控制、电子邮件服务；

②表示层：

负责处理在两个内部数据表示结构不同的通信系统之间交换信息的表示格式，为数据加密和解密以及为提高传输效率提供必需的数据压缩以及解压等功能；

③会话层

• 任务：不同主机上各进程间的对话；
• 功能：管理主机间的会话进程，包括建立、管理以及中止进程间的会话，是一种端到端的服务；

④传输层（TCP、UDP）：

• 任务：负责主机中两个进程间的通信；
• 功能：为端到端连接提供可靠的服务；为端到端连接提供流量控制、差错控制、服务质量等管理服务；
• 传输单位：报文段（TCP）或用户数据包（UDP）；

⑤网络层（ICMP、ARP、RARP、IP、IGMP、OSPF）：

• 任务：将传输层传下来的报文封装成分组；选择合适的路由，使得传输层传下来的分组能够交付到目的主机（路径选择）；
• 功能：为传输层提供服务；组包和拆包；拥塞控制；
• 传输单位：数据报；
• 所实现的硬件：路由器；

⑥数据链路层（PPP、HDLC、SDLC、STP、ARQ）：

• 任务：将网络层传输先来的IP数据报封装组成帧；
• 功能：链路连接的建立，拆除和分离；帧定界和帧同步；差错检测；
• 传输单元：帧；
• 所实现的硬件：交换机，网桥；

⑦物理层

• 任务：透明传输比特流；
• 功能：为数据端设备提供传送数据通路；
• 传输单位：比特；
• 所实现的硬件：集线器、中继器；

🐒四、笔试知识点

1、get和post区别

• GET请求在URL中传送的参数是长度有限制的（1024字节），而POST没有；
• GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息；
• GET参数通过URL传递，POST放在Request body;
• GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留；
• GET请求只能进行url编码，而POST支持多种编码方式；
• GET请求会被浏览器主动Cache，而POST不会，除非手动设置；
• GET产生的URL地址可以被Bookmark，而POST不可以；
• GET请求在浏览器回退时是无害的，而POST会再次提交请求。

2、贪心算法

又称为贪婪算法，是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而使问题的得到全局最优解。
贪心算法

3、动态规划算法

核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法；
与分治算法类似，但不同的是动态规划子问题不相互独立；
动态规划可以通过填表的方式来逐步推进，得到最优解。

0-1背包

4、分治策略算法

设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

算法

5、并发和并行

并发与并行是两个既相似又不同的概念；
并发性： 又称共行性，是指能处理多个同时性活动的能力；并发是同一个cpu上运行多个程序；
并行性： 是指同时发生的两个并发事件，（两个或两个以上事件或活动在同一时刻发生）具有并发的含义，而并发则不一定并行，也亦说并发事件之间不一定要同一时刻发生。

6、索引长度计算

• 所有的索引字段，如果没有设置 Not Null，则需要加一个字节(这也是我们为什么建议建表时不要有 Null 字段的原因之一)。
• 对于定长字段，int 类型占四个字节、date 占三个字节、char(n) 占 N 个字符。
• 对于变成字段 varchar(n)，则是 N 个字符 + 两个字节。
• 不同的字符集，一个字符占用的字节数不同。latin1编码的，一个字符占用一个字节，gbk编码的，一个字符占用两个字节，utf8编码的，一个字符占用三个字节。
• 索引长度 char()、varchar() 索引长度的计算公式：
  Character Set：（utf8mb4=4,utf8=3,gbk=2,latin1=1) * 列长度 + 1(允许 Null) + 2(变长列)
  索引计算

7、Redis分区

• 分区可以让Redis管理更大的内存，Redis将可以使用所有机器的内存。如果没有分区，你最多只能使用一台机器的内存。
• 分区使Redis的计算能力通过简单地增加计算机得到成倍提升；
• Redis的网络带宽也会随着计算机和网卡的增加而成倍增长。

8、如何保证缓存和数据库的一致性

• 将要提高应用性能，可以引入缓存来解决
• 引入缓存后，就要考虑缓存和数据库一致性的问题，建议，更新数据库，删除缓存
• 更新数据库 + 删除缓存的方案，在并发场景下无法保证缓存与数据保持一致性，且存在缓存资源浪费和机器性能浪费的情况。
• 并发场景下的延迟双删策略，这个延迟时间很难评估，所以推荐【先更新数据库，再删除缓存】的方案
• 在【先更新数据库，再删除缓存】的方案下，为了保证两步都能执行成功，需要配合【消息队列】或【订阅变更日志】的方案来做，其本质是通过重试的方式保证数据一致性。
• 在【先更新数据库，再删除缓存】方案下，【读写分离 +
  主从延迟】也会导致缓存和数据库不一致，解次问题的方案是【延迟双删】，凭借经验发送【延迟消息】到队列中，延迟删除缓存，同时要也要控制主从库延迟（可以通过暂时剔除延迟高的节点，延迟低的时候再将节点加入集群），尽可能降低不一致发生的概率。

9、圈复杂度

圈复杂度（Cyclomatic complexity，简写CC）也称为条件复杂度，是一种代码复杂的的衡量标准，它可以用来衡量一个模块判定结构的复杂程度，数量上变现为独立现行路径条数，也可以理解覆盖所有的可能情况最少使用的测试用例数。圈复杂度大说明程序代码的判断逻辑复杂，可能质量低且难于测试和维护。程序的可能错误和高的圈复杂度有着很大的关系。

圈复杂度计算方法

①点边计算法：

 V(G) = E - N + 2
 E表示控制流图中边的数量；N表示控制流图中节点的数量；

②节点判定法：
圈复杂度实际上就等于判定节点的数量再加上1，也即控制流图的区域数，计算公式：

V(G) = P + 1
其中P为判定节点数；
判定节点：if语句、while语句、for语句、case语句、catch语句、and和or布尔操作、？三目运算符

圈复杂度详解

10、abstract不能和private,final,static同时使用

Java中和abstract冲突不能共存的修饰符有三个：private、final、static

• private：abstract修饰方法只有方法声明，没有方法实现。抽象方法的意义在于子类实现，而private修饰后为私有，子类不能继承，也不能使用，所以二者冲突，不能共存；
• final：abstract修饰的类，该类中方法子类继承之后需要重写的，可是final修饰的类不能被继承，也没有子类，方法更不能得到重写。所以而这冲突，不能共存；
• static：static修饰的是静态方法，可以直接被调用，而abstract修饰的类中只有方法声明，没有方法实现，不能被直接调用，所以而这冲突，不能共存。

11、多线程Thread类常用方法

常用方法

• 1、start（）：启动当前线程
• 2、run（）：通常需要重写Thread类中的此方法，将创建的线程要执行的操作写在此方法中。
• 3、currentThread（）：静态方法，返回执行当前代码的线程
• 4、getName（）：获取当前线程的名字，与3一起使用可得到正在执行的线程的名字
• 5、setName（）：设置当前线程的名字
• 6、yield（）：释放当前cpu的执行权
• 7、join（）：在线程a中调用线程b的join（）；此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
• 8、stop（）：已过时，强制结束当前线程。
• 9、sleep（long millitime）：休眠millitime毫秒
• 10、isAlive（）：判断当前线程是否存活

其他方法

• 1、wait（）：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
• 2、notify（）：执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，会唤醒优先级高的。
• 3、notifyAll（）：执行此方法,会唤醒所有被wait的线程。

说明：

• 1、三个方法必须使用在同步代码块或同步方法中
• 2、三个方法的调用者都必须是同步代码块或同步方法中的同步监视器，否则会抛出异常。
• 3、三个方法都是定义在java.lang.Object类中。

面试题：
sleep（）和wait（）的异同？

1、相同点：都可使当前的线程进入到阻塞状态。

2、不同点：

• ①两个方法声明的位置不同，Thread类中声明sleep（），Object类中声明wait（）。
• ②调用的要求不同：sleep（）可以在任意场景下使用，wait（）必须在同步代码块或同步方法中。
• ③是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep（）不会释放锁，wait（）会释放锁。

12、内存中的堆、栈和静态区的使用

• 堆区：专门用来保存对象的实例（new 创建的对象和数组），实际上也只是保存对象的属性值，属性的类型和对象本身的类型标记等，并不保存对象的方法；
• 栈区：对象实例在heap中分配好以后，需要在stack中保存一个4字节的heap内存地址，用来定位该对象实例在heap中的位置，便于找到该对象实例；
• 静态区/方法区：方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量，方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。全局变量和静态变量的存储是放在一起的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

13、TCP、UDP区别

• 1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接
• 2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
• 3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流；UDP是面向报文的、UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
• 4、每一条TCP连接只能是点到点的；UDP支持一对一，一对多，多对一和多对多的交互通信
• 5、TCP首部开销20字节；UDP的首部开销小，只有8个字节
• 6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

14、Linux系统版本查询命令

• lsb_release -a : 即可列出所有版本信息
• cat / etc / redhat- release ：这种方法适合redhat系统的linux

15、DNS简述和作用

DNS服务器是计算机域名系统（Dpmain Name System 或 Domain Name Service）的缩写，它是由域名解析器和域名服务器组成的，域名服务器是指保存有该网络中所有主机的域名和对应IP地址，并具有将域名转换为IP地址功能的服务器。其中域名必须对应一个IP地址，而IP地址不一定有域名。域名系统采用类似目录树的等级结构，域名服务器为客户机/服务器模式中的服务器方，它主要有两种形式：主服务器和转发服务器，将域名映射为IP地址的过程就成为“域名解析”；

作用：

• 将域名解析为IP地址；
• 客户端向DNS服务器（DNS服务器有自己的IP地址）发送域名查询请求；
• DNS服务器告知客户机Web服务器的IP地址；
• 客户机与Web服务器通信。

16、TCP、UDP

TCP、UDP区别

• TCP是面向连接、面向字节流的；UDP是无连接的、面向数据报文的；
• TCP提供可靠的服务，通过TCP传送的数据，无差错，不丢失，不重复且按序到达；UDP尽最大努力交付，但不保证可靠交付；
• 每一条TCP连接只能是点对点，UDP支持一对一，一对多，多对多，多对一的交互通信；
• UDP具有较好的实时性，工作效率比TCP高，适用于对高速传输和实时性有较高的通信或广播通信；
• TCP对系统资源要求较多，UDP要求较少。

应用场景

TCP每个数据封包都需要确认，因此不适用高速数据传输场景，比如观看视频、网络游戏（TCP有延迟）等；但如果比如HTTP请求，要考虑请求/返回的可靠性，就用TCO比较合适；
但是像HTTP 3.0这类应用层协议，从功能性上思考，暂时没有找到太多的优化点，但是想要把网络优化到极致，就会用UDP作为底层技术，然后在UDP基础上解决可靠性。

TCP场景：

• 远程控制（SSH）；
• File Transfer Protocol（FTP）;
• 邮件（SMTP、IMAP）等；
• 点对点文件传出（微信等）；

UDP场景：

• 网络游戏；
• 音视频传输；
• DNS；
• Ping；
• 直播；

TCP、UDP都可以考虑：

• HTTP（目前以TCP为主）
• 文件传输

对应的协议

TCP、UDP的介绍及使用场景

17、数据库连接

• 内连接查询：显示A表和B表的共有信息，相当于取交集；
• 左连接查询：显示左表（A表）的全部信息，右表（B表）只显示符合条件的信息，没有显示null；
• 右连接查询：显示右表（B表）的全部信息，左表（A表）只显示符合条件的信息，没有显示null；
  
  MySQL七种常用查询连接详解

、碎碎碎~

1：完全二叉树设叶结点数为M，结点数为N，有M =（N+1）/2

2： 前-中-后缀表达式相互转换

3：

AVG()、SUM()：运算时忽略NULL值

COUNT()：

COUNT(*)或COUNT(1)：对表中的行数进行统计，不管某一行是否有NULL值

COUNT(字段名)：对特定列进行统计，会忽略NULL值进行统计 ```

4： 关于truncate和delete的区别

• ①truncate 删除表中的内容，不删除表结构，释放空间；
• ②delete 删除内容，不删除表结构，但不释放空间
• ③区别:
• 内存空间 truncate删除数据后重新写数据会从1开始，而delete删除数据后只会从删除前的最后一行续写；内存空间上，truncate省空间
• 处理速度 因为，truncate是直接从1开始，即全部清空开始，而delete需要先得到当前行数，从而进行续写；所以truncate删除速度比delete快；

5：瀑布模型（Waterfall Model）适应算法、平台、程序语言的变动，不适应用户需求的变动；
瀑布模型的四个阶段：分析、设计、编码、测试；
软件开发模型：瀑布、螺旋、迭代、增量、敏捷模型

增量模型：把待开发的软件系统模块化，将每个模块作为一个增量组件，从而分批次地分析、设计、编码和测试这些增量组件

6：linux中的root权限：root权限是超级管理员用户的最高管理权限；root权限可以超越任何用户和用户组对文件或目录进行读取修改或者删除；linux通过UID来区分用户权限级别，UID为0的用户则被系统认定为具有超级权限，也即root权限。
root的权限是最高的，也被称为超级权限的拥有者。普通用户无法执行的操作，root用户都能完成，所以也被称之为超级管理用户。

7：模式串的长度是m，主串的长度是n（m<n），使用KMP算法匹配的时间复杂度是O(m+n);
KMP为线性算法，处理主和匹配串的复杂度都为O(n)
KMP算法

8：用俩个栈模拟实现一个队列，如果栈的容量分别是O和P(O>P),那么模拟实现的队列最大容量是多少？
设stack1的容量是O，stack2的容量是P，（O>P），将stack1作为存储空间，stack2作为输出的缓冲空间。
1、将P个元素push到stack1中；
2、再将该P个元素pop到stack2中；（此时出栈的顺序就是队列前P个元素的出栈顺序）
3、将P+1个元素push到stack1中；
4、将P个元素pop到stack2中，先将stack1中剩余的元素pop，然后依次pop出stack2中的元素。
所以最终实现队列的最大容量是2P+1

9：ARP ：根据IP地址寻找物理地址（MAC）协议。（以用来发现本地设备的硬件地址）
RARP ：根据物理地址（MAC）寻找IP地址协议

10：SQL顺序
写法顺序：select–from–where–group by–having–order by
执行顺序：①from–where–group by–having–select–order by；
②from–join–on–where–group by–avg,sum…–having–select–distinct–order by

就是select要放后面，如果有order by，则order by放最后，因为order by 是对结果进行排序

11：接口和抽象类的区别

• 1.接口的方法默认为public abstract ,接口中的变量默认为public static final，在java8之前所有的方法不能有实现，抽象类中可以有非抽象方法
• 2.一个类可以实现多个接口，但只能继承一个抽象类
• 3.一个类实现接口，要实现该接口的所有抽象方法。
• 4.接口不能被实例化，但可以声明，但是必须引用一个实现该接口的对象。 抽象类可以有构造方法，但是不能被直接通过new进行实例化。但可以通过子类继承，实例化子类的时候抽象类也会被实例化。
  这其实用到了多态，向上转型。父类引用指向子类对象。
• 5.从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

12：

13：Linux_shell逻辑判断
-a 与
-o 或
！非

14：显式等待，隐式等待，线程休眠分别对应的关键词为WebDriverWait ，implicitly_wait， sleep

15：关于查找的说法

• 红黑树、B树、B+树均是自平衡树；
• 散列表的冲突通常可以用开放地址法和链地址法解决；
• 二分查找要求线性表存储的值是有序的。

16：当 Python 遇到一个变量的话会按照本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）的顺序进行搜索。

17：Java的设计模式共有23种。
常用设计模式

18：关于红黑树的说法

• 每个红色节点的两个子节点都一定是黑色；
• 根节点是黑色，每个节点是黑色或者红色；
• 每个叶子节点是黑色；
• 对于每个节点，从该节点到其后代叶节点的简单路径上，均包含相同数目的黑色节点。
• 红黑树的时间复杂度是O(lgn)

19：while 语句的循环体执行次数比循环条件的判断次数少 1，而 do-while语句的循环体执行次数等于循环条件的判断次数。

do{
循环体语句;
}while(判断条件语句);
do 会先执行循环体语句，再用while判断。所以 do 比 while 多执行一次循环体。while 本身循环体语句执行比条件语句执行少1.所以 最后一个是正确的。

20：在TCP/IP模型中，应用层包含了所有的高层协议

21：强调吞吐能力的系统是分道批处理系统；
22：线程阻塞方式：join、sleep、yield;
23：TCP的拥塞控制及方法：慢开始、拥塞避免、快重传、快恢复；
24：计算机中一个浮点数由 阶码和尾数 组成；
25：Mysql锁表原因：一个程序执行了对表的insert、update或者delete操作还未commite时，另一个程序也对同一个表进行相同的操作，则此时会发生资源正忙的异常，也就是缩锁表。
26：求最短路径FLOYD算法的时间复杂度为：O(N^3) ；
空间复杂度为O(N^2);
Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。
27：长度为n的字符串：有n(n+1)/2 +1个子串、非空子串：n（n+1）/2、非空真子串：n（n+1）/2– 1 。
28：操作系统提供给应用程序的接口是系统调用；
29：视图建立后，在数据字典中存放的是视图的定义；
30：操作系统是一种系统软件；
31：某进程中有3个并发进程，它们均需要某类资源，进程A需要2个，进程B需要3个，进程C需要4个，为确保该系统不会发生死锁所需的最少资源数：7个
解析：产生死锁的条件：互斥条件、请求和保持条件、不可抢占条件、循环等待条件；
根据题目给出的从资源供给上解决死锁的条件，所以每个进程均差一个资源的情况下形成僵持，即A（1个资源）、B（2两个资源）、C（3个资源）的情况下，只要再加1个资源即不会产生死锁，1+2+3+1=7
32：Mac地址通常存储在计算机的网卡上；
Mac地址用于在网络中唯一标示一个网卡，一台设备若有一个或多个网卡，则每个网卡都需要并会有一个唯一的MAC地址；
33：视图不占用物理空间；视图可以进行update操作；
视图没有实际的物理记录；视图的建立和删除不影响基本表；对视图内容的更新（添加、删除和修改）直接影响基本表；视图是由基本表（实表）产生的表（虚表）；
34：DHCP协议属于OSI网络模型中的应用层 ；
35：二叉树中度为2的节点与叶子节点（度为0）的节点个数关系：n(0) = n(2)+1;
36：同一个进程中的线程不能共享的部分是栈空间，而信号、堆、文件描述符可以共享；
37：在TCP/IP协议中，TCP协议工作在传输层，FTP协议工作在应用层；
38：关系数据库：mysql、sql server、oracle；
非关系型数据库：hbase；
39：算法的有穷性是指算法必须能在执行有限个步骤之后中止；
算法的时间复杂度是指算法执行过程中所需要的基本运算次数。
40：递归过程或函数调用时，处理参数及返回地址，要用一种称为栈的数据结构；
41：对线性表采用折半查找，该线性表必须元素按值有序排列，并且采用顺序存储结构；
42：无向图G中边数目的取值范围：0＜-e＜=n(n-1)/2。有n(n-1)/2条边的无向图称为完全图。
42：二叉树的旋转操作对中序遍历不会造成影响；
43：在最后一趟开始之前，所有元素都有可能不在其最终的位置上的是插入排序；
44：若用数组S[0…n-1]（n>3）作为两个栈S1和S2的共同存储结构，要求对任何一个栈，只有当S全满时才不能做入栈操作，则为这两个栈分配空间的最佳方案是S1的栈底位置为0，S2的栈底位置为n-1
45：快速排序在要排序的数据已基本有序的情况下最不利于发挥其长处；
46：无向图有n个顶点m条边，则建立该图的邻接表的时间复杂度是O(n+m)；
47：用二进制表示十进制数1到4，分别为1、10、11、100，这些二进制数所有位上1的个数共有5个。那么，用二进制表示的十进制数1到128，所有位上1的个数共有449个；
48：满二叉树高度为H（根节点为第一层），则节点总数为2^H -1
49：可串行化：多个事务的并发执行是正确的，当且仅当其结果与按某一次序串行的执行它们时的结果相同；
50：共享锁 ：又称读锁。允许一个事务去读一行，阻止其他事务获得相同数据集的排他锁。若事务T对数据对象A加上共享锁，则事务T可以读A但不能修改A，其他事务只能再对A加共享锁，而不能加写锁，直到T释放A上的共享锁。这保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。
51：排他锁 ：又称写锁。允许获取排他锁的事务更新数据，阻止其他事务取得相同的资源的共享读锁和排他锁。若事务T对数据对象A加上写锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的写锁。
52：CPI（Clock Cycles per instruction）：每条指令的平均时钟周期数，在相同时钟周期下，CPI越小程序速度越快；但一个程序在一台机器上CPI小也不一定对所有程序都在这台机器上运行的快，CPI的大小和程序本身有关，不同程序在不同机器上有不同的运行速度；
53：www浏览器的工作基础是解释执行用html语言书写的文件；
54：websocket是基于tcp的协议，websocket只需要服务端和客户端一次握手，就可以自由进行数据传送和接收，允许服务端主动发送数据，不需要使用轮询的方式；和HTTP协议不同、websocket客户端是基于事件的编程模型与node类似；
55：动态程序分析是对计算机软件的分析，该计算机软件是通过在真实或虚拟处理器上执行从该软件构造的程序来执行的；
动态分析：代码覆盖率、程序数据流分析；
56：数据库的完整性（Databases Integrity）是指数据库中数据在逻辑上的一致性、正确性、有效性和相容性；
57：MySQL数字函数

MySQL数字函数、日期函数
58：MySQL中触发器的每个表每次事件，都只允许一个触发器，因此，每个表最多只允许有6个触发器；如果一个表有两个事件,INSERT和DELETE,那么就要分别创建一个触发器。 只有表才支持触发器,视图和临时表不支持。
59：HTTP最基本的四种请求方式：get post put delete；
60：Linux使用top命令查看进程的CPU和内存的使用情况；
61：和while(true等价的for语句是for(; ; ) ;
62：程序的局部变量存在于栈（stack）中，全局变量存在于静态数据区中；动态申请数据存在于堆（heap）中；
63：Linux中修改为文件的权限设置：chmod；
64：Java程序经编译后会产生byte code(字节码)；
65：网络中实现远程登录的协议是TELNET，HTTP是超文本传输协议，FTP是文件传输协议；
66：如果用户程序使用UDP协议进行数据传输，则应用层协议必须承担可靠性方面的全部工作；
67：当一台主机从一个网络移到另一个网络时，必须改变它的ip地址，但不需改动MAC地址；
68：应用程序PING发出的是ICMP应答报文；
69：按照覆盖的地理范围，计算机网络可以分为局域网、城域网、广域网；
70：嵌入式系统是一种专用的计算机系统，用于控制、监视或者辅助操作机器和设备的装置；嵌入式是硬件和软件的综合体；
71：Internet采用的主要通信协议是TCP/IP协议；
72：音频和视频信息在计算机内的表现形式是数字信息；
73：python变量名必须以字母或者下划线开头、并且区分字母大小写；
74：判断一个链表是否有环：快慢指针 类似于数学中的追及问题，设置一个快指针，步长为2，设置一个慢指针，步长为1，如果不存在环，则快慢指针不会相遇。如果存在环，则会相遇。 时间复杂度为O(n)，空间复杂度为O(1)；

public boolean hasCycleForMethodThree(Node node){
		Node fast = node;
		Node slow = node;
		while(fast != null && fast.next != null){
			slow = slow.next;
			fast = fast.next.next;	

			if(slow == fast)  return true;
	}
	    return false;
}