吃不完的土豆番茄

吃不完的土豆番茄 查看完整档案

其它编辑  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 该用户太懒什么也没留下

个人动态

吃不完的土豆番茄 发布了文章 · 8月23日

【字节面前准备】20200823面试前

1.TCP,UDP介绍差别

https://www.bilibili.com/video/BV1rf4y1R7n3?from=search&seid=14420998634794827825
TCP固定长度为20个字节,UDP固定长度为8个字节。
UDP是一种不可靠的通信协议,他不需要建立连接,不需要确认ack。数据是否出现乱序丢失他都不管,因此UDP适合实时视频通话、语音聊天等.
TCP是面向连接的可靠的数据传输服务,TCP需要经过三次握手和对方确认连接后才可以进行信息传输。除此之外,TCP还有超时重传机制、滑动窗口、流量控制。保证数据在传输过程中不会出现丢失、乱序等情况,保证可靠性传输。因此TC适合数据完整性通信质量要求高的场景,比较适合文件下载、浏览网页等等。
TCP是面向字节流的,这就意味着数据是以字节流的形式传递给接受者的,没有边界的概念。每个TCP会有一个发送缓冲区,如果字节流太长,TCP会将其拆分,然后再发送;如果字节流太短,TCP会等待缓冲区中字节流到合适的时机再发送出去。因此接收方读到的数据可能是好几个TCP的数据包,也可能是一个或者半个。
UDP是面向报文的,UDP传输报文的方式是由应用程序控制的,应用层交给UDP多长的报文,UDP照样发送,既不拆封也不合并,保留这些报文的边界。

2.红黑树,AVL对比,引申B,B+树

https://www.cnblogs.com/chengdabelief/p/7384691.html
https://www.cnblogs.com/lca1826/p/6484469.html
https://blog.csdn.net/liang3720/article/details/81700748

3.网卡收到一条数据到进程处理数据,这之间经历了什么(中断的上半部下半部,网络层协议拆包)

https://blog.csdn.net/drdairen/article/details/83818154

4.大数据量(内存够用)下,快排与堆排序的对比(考察缓存命中率的对比)

5.缓存相关内容,LRU算法思想,手撕LRU的实现

6.实习项目介绍,问的很深 引申到一致性hash

7.缓存失效,替换原理

8.32位系统运行大于4G的程序,如何寻址(考察虚拟内存,虚拟地址空间)

9.手撕完全二叉树寻找最后一行的最后一个节点(没做过,当时想到的是利用特性算出最后节点的层序序号,然后除二看奇偶,找出起点到最后节点的路径)

10.手撕层序遍历二叉树

11.手撕给二叉树先序,中序序列,求后序序列

12.http https

13.http各种状态码

14.一次http流程

15.SSL加密

16.session cookie

17.数据库索引 innodb

18.b树 b+树

19.聚簇非聚簇

20.写sql语句 课程A分数大于平均分的总人数

21.代码:二维数组找单词

22.http和https有什么区别?

https是ssl(安全套接层+http,加密版本)

23.数字证书有哪些?

讲了一下公钥体系。

24.http有哪些版本,区别?

0.9/1.0/1.1/2.0,我说成1.2而且只知道持久连接。

0.9是原始版本,只有get操作。

1.0新增了post,head操作,增加了状态码等。一般是一个请求一个连接。有keepalive。

1.1增加了持久连接,全二进制,管道,put,delete,options等请求方式。

2.0增加了双工,数据流等。

25.TCP和IP属于什么层?TCP挥手握手?

26.TCP可靠传输的机制?窗口的含义是什么?

回答窗口协议,可重传,连接建立。

27.介绍一下linux内存模型

好像分为内核虚拟储存器,用户栈,文件映射区,运行时堆,读写段,只读段,保留区

28.介绍一下页表

29.单cpu单核处理器,多线程需要加锁吗?

30.一些数据在磁盘上,要发送到网络上,要经过哪些过程?

NIO零拷贝

31.介绍一下BIO, NIO, AIO

阻塞, 阻塞同步, 非阻塞同步, 异步

32.中间件那些有了解吗?

33.sql数据库引擎有了解吗?

34.数据库锁有了解吗?

35.字节对齐如何实现有什么作用,举个例子。

36.介绍一下泛型擦除

37.map原理,1.8以后呢?

38.介绍一下可重入锁原理

39.讲一下虚拟机如何加载. class文件,双亲委派

40.红黑树规定,插入删除如何操作?

41.广度优先搜索用到什么数据结构?

42.深度优先遍历,思路比较容易想到,关键要熟练

43.UDP保证可靠性

https://blog.csdn.net/u011001084/article/details/78977548
RUDP 的重传是发送端通过接收端 ACK 的丢包信息反馈来进行数据重传,发送端会根据场景来设计自己的重传方式,重传方式分为三类:定时重传、请求重传和 FEC 选择重传。

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 8月16日

【实习答辩准备】

1.aixos背景

2.promise

3.跨域问题深入

4.CRSF/XRSF

5.箭头函数

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 8月16日

【初面复盘】2020/8/15后端

先说一句:面试官上来强调自己不是学java的,主要探讨为主,可是我发现面试官问的问题一点都不像没学过java~
共面了1小时40分钟

1.java垃圾回收机制
新生代/老年代 其它垃圾回收机制
2.java面向对象特性
继承
封装
多态
3.设计模式

4.单例模式

5.map的底层实现

6.hash函数如何实现

7.哈希冲突的解决方法
再哈希
建立公共缓冲区

8.hashmap查询复杂度/降低复杂度方法

9.hashmap线程不安全

10.juc中的concurrentHashmap如何保证线程安全

11.常用的集合类型
arraylist
linkedlist
12.arrayList和linkedList区别

13.链表中如何使查询速度更快
建索引?
14.知道哪些本地缓存?redis?lru?

15.计算机网络七层模型

16.浏览器每一个标签页都是一次tcp连接吗

17.http和https的比较

18.https加密算法是对称的还是非对称的?

19.TCP三次握手四次挥手

20.伪造第三次握手,如何保证?

21.syn攻击?还是什么攻击?

22.TIME_WAIT作用

23.多路复用、epoll方法的优点 存储连接的是链表吗
select poll epoll
24.进程和线程

25.线程间通信

26.进程间通信

27.共享内存是在A进程中还是B进程?
应该都不是
28.线程间同步

29.sychronized和RetrantLock异同点

30.乐观锁和悲观锁,他们的效率

31.每次请求都是对锁的一个修改,两种策略效率如何

32.排序算法及各自的最好最坏复杂度及稳定性

33.归并排序和快速排序的算法思想
分治
34.快速排序的最坏情况,如何改变

35.相同的子问题可以用分治法,那不同的子问题?

36.最后一题算法题
牛客网本题讨论链接
小Q在进行一场竞技游戏,这场游戏的胜负关键就在于能否争夺一条长度为L的河道,即可以看做是[0,L]的一条数轴。
这款竞技游戏当中有n个可以提供视野的道具--真视守卫,第i个真视守卫能够覆盖[xi,yi]。现在小Q想知道至少用几个真视守卫就可以覆盖整段河道。

输入描述:
输入包括n+1行
第一行包括两个正整数n和L(1<=n<=10^5,1<=L<=10^9)
接下来的n行,每行两个正整数xi,yi(0<=xi<=yi<=10^9),表示第i个真视守卫覆盖的区间
输出描述,一个表示最少需要的真视守卫数量,如果无解,输出-1。

样例:
输入:
4 6
3 6
2 4
0 2
4 7
输出
3

import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int L = input.nextInt();
        int[][] nums = new int[n][2];
        int ce = 0;
        while (ce < n) {
            nums[ce][0] = input.nextInt();
            nums[ce][1] = input.nextInt();
            ce++;
        }
        System.out.println(guidenum(nums, L));

    }

    public static int guidenum(int[][] nums, int L) {
        int count = 0;
        Arrays.sort(nums, (a, b) -> a[0] - b[0]);
        int start = 0, end = 0;
        for (int i = 0; start < L; ) {
            for (; i < nums.length && nums[i][0] <= start; i++)
                end = Math.max(end, nums[i][1]);
            if (start == end) {
                return -1;
            }
            start = end;
            count++;
        }
        return count;
    }
}
查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 8月11日

【腾讯面经总结】20200815面试前

简历项目相关;
1.spring security
2.json web token
3.mybatis
4.aop代理,动态代理,静态代理
5.redis


1.索引,什么是B+树
2.索引太多有什么问题,三个方面各三点
3.redis有什么数据结构
4.https是什么,工作原理
5.响应状态码
6.tcp三次握手、四次挥手
7.tcp流量控制
8.讲一下hashmap
9.hash算法
10.如果有个很大的10g文件,里面都是数字,你的内存只有2g,你怎么样读进来然后排序,最好详细到源码


1.java多线程和高并发
2.线程池参数以及几个线程池的细分
3.java提供了几个类加载器?分别是?怎么对类进行加载?
4.hashCode的作用,重写需要注意什么
https://www.cnblogs.com/honoka/p/4827721.html
5.classnotfoundexception 知道吗?遇到场景是什么?怎么解决的?
6.NoSuchMethodException遇到过吗


1.TCP/IP有几层?那些?传输层有哪些协议?http是基于什么协议的?
2.cookies和session的区别?
3.session是怎么做区分的?
4.cookie是怎么传到前端的?
服务器在响应头里面设置Set-Cookie字段
5.物理层我们常用的协议有哪些?
6.项目里有个数据安全的,aes和md5的区别?详细点
aes是流密码体系,主要是做传输时的加密。
md5主要是签名的时候用的,通过hash做的
7.单点登录怎么实现的?
8.https怎么实现的?SSL和TLS的区别?
9.上海和深圳两个集群,他们https加密的公共密钥怎么同步?
10.页面报错了,你怎么排查?


1.jvm结构分区以及调优
(栈、堆、方法区、程序计数器,简单的-ea -Xmx2g -Xms2g -XX:MaxPermSize=1024m)
2.线程池的各个参数以及值,用了什么队列,拒绝策略
(核心线程数 50,最大 100,ArrayBlockingQueue 默认丢弃)
3.项目中有没用到微服务

4.mybatis和hibernate相比
(轻量级,不需要反向生成,动态sql直接在接口上写注解sql语句,方便)
5.为什么选ssm框架
(主流,方便易用)


1.垃圾回收器CMS与G1
2.垃圾回收算法
3.堆外内存、IO与NIO
4.HTTP与HTTPs
5.对称加密算法与非对称加密算法
6.hashmap、hashtable、7.concurrentHashMap
8.线程安全、synchronized、volatile
9.快速排序、时间复杂度
10.sort内部实现
11.自旋锁
12.linux命令、内核态


1.Spring DI 是什么?如何实现?
2.Spring AOP 是什么?实现原理?
3.HashMap 底层实现?支持并发的 HashMap 有哪些?
4.JVM 内存布局?
5.synchronized 的底层实现?
6.线程的创建方式?线程池的关键参数?
7。介绍TCP的三次握手四次挥手?
8.为什么会有TIME_WAIT和CLOSE_WAIT?
9.介绍一下拥塞控制?
10.进程和线程的区别?
11.了解mysql的索引嘛?聚簇索引和非聚簇索引的区别?
12.索引的结构?
13.查询很慢,如何优化?


1.出现OOM,如何分析和解决?
2.Web端实现实时通信的方法有哪些?
3.Web端登陆的安全性如何实现?
4.Linux中,如何查询系统负载情况?CPU利用率如何计算?
5.【编程】151. 翻转字符串里的单词 - 力扣(LeetCode)


1.操作系统 内存部分(虚拟地址怎么找到物理地址)
2.swap分区
3.为什么用虚拟地址
4.linux怎么查看内存情况
5.进程的堆栈里面放的什么
6.快排  归并排序
7.口述算法 最长回文子串
8.三次握手
9.syn攻击
10.多态
11.hashmap  hashtable
12.线程状态(blocked   waiting  timed_waiting)
13.jvm内存分配
14.==  equals  hashcode
15.数据库隔离级别
16.脏读  幻读


1.对并发的理解
2.synchronized 和  lock
3.juc你认识的工具类
4.爬楼梯问题
5.mysql连接对象问题
6.长事务
7.mvcc


1.说对spring mvc 和spring cloud的理解
2.说一下tcp 和 udp
3.tcp的time wait 和 close wait
4.说一下拥塞控制
5.怎么控制滑动窗口的大小
6.如果服务器端已进入close状态,客户端还处于time wait 状态,占用着端口,怎么解决
7.查看tcp连接数的命令
8.linux你知道哪些命令
9.linux 中 ‘|’的作用是什么?
10.当前系统的性能遇到了瓶颈,如何去定位问题
11.内存泄露怎么定位
12.说说你调优jvm的方向
13.说说jvm gc的特点,你的理解

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

后端面试知识点记录

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

【项目相关】汇总

1.Redis分布式锁存在的问题,如何优化

2.spring security

3.json web token

4.mybatis

5.aop两种代理

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

【mysql数据库】汇总

1.数据库在查询的时候,数据类型会出现隐式转化(如varchar不加单引号的话可能会自动转换为int型,索引会失效),怎么避免隐式转换

Mysql的隐式转换示例讲解
Mysql隐式转换的问题
MySQL隐式转换解决方案
mysql 隐式转换问题(案例一)
谈谈MySQL隐式类型转换
MySQL隐式转化整理
如下表:
1.PNG

#sname为varchar类型,用值类型搜索
explain select sno
from s
where sname=123;
#sname为varchar类型,用字符串类型搜索
explain select sno
from s
where sname='123';

上述查询上面不会走索引,下面会走索引。
2.PNG

3.PNG

因为等号两侧类型不一致,因此会发生隐式转换,cast(index_filed as signed),然后和123进行比较。因为'123','123abc'都会转化成123,故MySQL无法使用索引只能进行全表扫描,造成了慢查询的产生。

解决方案:
1.in中全使用字符串类型
2.cast
附:explain字段详解

2.最左匹配原则

Mysql最左匹配原则语句详解
Mysql最左匹配原则通过示例详解(这个很清楚)
为什么使用联合索引
示例详解:

#建立名为test_user的表
CREATE TABLE `test_user` (
                             `name`     varchar(20) DEFAULT NULL,
                             `province` int(11)     DEFAULT NULL,
                             `sex`      varchar(20) DEFAULT NULL,
                             `birthday` int(11)     DEFAULT NULL,
                             `phone`    double      DEFAULT NULL
)
    ENGINE = InnoDB
    DEFAULT CHARSET = utf8;
#建立(name,phone,province)联合索引
CREATE INDEX test_user_name_phone_province_index
    ON test_user (name, phone, province);

以下查询走索引结果如下图:

explain select name
        from test_user
        where name='张三';

explain select name
        from test_user
        where name='张三' and phone=32432;

explain select name
        from test_user
        where name='张三' and phone=32432 and province=2;

explain select name
        from test_user
        where phone=32432;

explain select name
        from test_user
        where

1.PNG

2.PNG

3.PNG

4.PNG

5.PNG

3.b+树和b树、红黑树、二叉树的区别

数据结构之树--二叉树/B树/B+树/红黑树及相关算法
浅谈AVL树,红黑树,B树,B+树原理及应用
趣解各种树(很详细)
MYSQL-索引结构介绍、为什么选择B+树而不是B树
深入理解数据库索引采用B树和B+树的原因
B树B-树和B+树的总结
AVL是比红黑树更严格的二叉平衡树,缺点是在极端情况下,会退化成链表;
红黑树有自己的一套规则,根节点必为黑色。
B树是多叉树,高度降低,节点上有待搜索数据。
B+树在B树基础上,非叶子节点并不存储真实数据,只是索引,只有叶子节点存储真实数据,并且叶子节点间也形成链表。

4.覆盖索引

覆盖索引解释(很详细)
覆盖索引总结
首先要知道什么是聚集索引和二级索引。
索引是高效找到行的一个方法,当能通过检索索引就可以读取想要的数据,那就不需要再到数据表中读取行了。如果一个索引包含了(或覆盖了)满足查询语句中字段与条件的数据就叫 做覆盖索引。
聚集索引(主键索引):
聚集索引就是按照每张表的主键构造一颗B+树,同时叶子节点中存放的即为整张表的记录数据。
聚集索引的叶子节点称为数据页,聚集索引的这个特性决定了索引组辅助索引(二级索引):
非主键索引,叶子节点=键值+书签。Innodb存储引擎的书签就是相应行数据的主键索引值。

5.drop、truncate、 delete区别,哪个最快,为什么

drop,delete与truncate的区别(删除表的方式,哪个快)
drop、truncate和delete的区别
drop直接删掉表 truncate删除表中数据,再插入时自增长id又从1开始 delete删除表中数据,可以加where字句。
用TRUNCATE替代DELETE
TRUNCATE不记录日志,DELETE记录日志,所以TRUNCATE要快于DELETE。
但是一旦用TRUNCATE进行删除就不能进行恢复, TRUNCATE是删除整张表的数据。不能加where条件。

6.MySQL索引类型

mysql索引类型详解
mysql索引总结
mysql索引简洁口诀
mysql索引精选
从数据结构角度
1、B+树索引(O(log(n))):关于B+树索引,可以参考 MySQL索引背后的数据结构及算法原理
2、hash索引:
a 仅仅能满足"=","IN"和"<=>"查询,不能使用范围查询
b 其检索效率非常高,索引的检索可以一次定位,不像B-Tree 索引需要从根节点到枝节点,最后才能访问到页节点这样多次的IO访问,所以 Hash 索引的查询效率要远高于 B-Tree 索引
c 只有Memory存储引擎显示支持hash索引
3、FULLTEXT索引(现在MyISAM和InnoDB引擎都支持了)
4、R-Tree索引(用于对GIS数据类型创建SPATIAL索引)

从物理存储角度
1、聚集索引(clustered index)
2、非聚集索引(non-clustered index)

从逻辑角度
1、主键索引:主键索引是一种特殊的唯一索引,不允许有空值
2、普通索引或者单列索引
3、多列索引(复合索引):复合索引指多个字段上创建的索引,只有在查询条件中使用了创建索引时的第一个字段,索引才会被使用。使用复合索引时遵循最左前缀集合
4、唯一索引或者非唯一索引
5、空间索引:空间索引是对空间数据类型的字段建立的索引,MYSQL中的空间数据类型有4种,分别是GEOMETRY、POINT、LINESTRING、POLYGON。
MYSQL使用SPATIAL关键字进行扩展,使得能够用于创建正规索引类型的语法创建空间索引。创建空间索引的列,必须将其声明为NOT NULL,空间索引只能在存储引擎为MYISAM的表中创建

CREATE TABLE table_name[col_name data type]
[unique|fulltext|spatial][index|key][index_name](col_name[length])[asc|desc]

1、unique|fulltext|spatial为可选参数,分别表示唯一索引、全文索引和空间索引;
2、index和key为同义词,两者作用相同,用来指定创建索引
3、col_name为需要创建索引的字段列,该列必须从数据表中该定义的多个列中选择;
4、index_name指定索引的名称,为可选参数,如果不指定,MYSQL默认col_name为索引值;
5、length为可选参数,表示索引的长度,只有字符串类型的字段才能指定索引长度;
6、asc或desc指定升序或降序的索引值存储

7.一个Mysql操作很慢,怎样排查原因

反应慢排查示例
mysql数据库慢排查及解决
1.top查看cpu占用
2.查看锁状态
3.查看线程状态processlist

8.悲观锁,乐观锁

悲观锁、乐观锁简要解释
趣解数据库中的悲观锁、乐观锁
数据库中的乐观锁与悲观锁
数据库中的悲观锁和乐观锁的总结

悲观锁

总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronizedReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
两种锁的使用场景:从上面对两种锁的介绍,我们知道两种锁各有优缺点,不可认为一种好于另一种,像乐观锁适用于写比较少的情况下(多读场景),即冲突真的很少发生的时候,这样可以省去了锁的开销,加大了系统的整个吞吐量。但如果是多写的情况,一般会经常产生冲突,这就会导致上层应用会不断的进行retry,这样反倒是降低了性能,所以一般多写的场景下用悲观锁就比较合适。

9.索引的优点与缺点,底层怎么实现的?

优缺点总结

索引的优点:
1.创建唯一性索引,保证数据库表中每一行数据的唯一性。
2.大大加快数据的检索速度(最主要的原因)。
3.加速表和表之间的连接,特别是在实现数据的参考完整性方面特别有意义。
4.在使用分组和排序子句进行数据检索时,同样可以显著减少查询中分组和排序的时间。
5.通过使用索引,可以在查询的过程中使用优化隐藏器,提高系统的性能。
索引的缺点:
 1.创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。

  2.索引需要占物理空间,除了数据表占数据空间之外,每一个索引还要占一定的物理空间,如果要建立聚簇索引,那么需要的空间就会更大。
  3.当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,降低了数据的维护速度。

10.mysql引擎有哪些,有啥区别

mysql五种引擎详解
InnoDB Myisam Memory
InnoDB跟Myisam的默认索引是B+tree,Memory的默认索引是hash
区别:
1.InnoDB支持事务,支持外键,支持行锁,写入数据时操作快,MySQL5.6版本以上才支持全文索引。
2.Myisam不支持事务。不支持外键,支持表锁,支持全文索引,读取数据快。
3.Memory所有的数据都保留在内存中,不需要进行磁盘的IO所以读取的速度很快,但是一旦关机的话表的结构会保留但是数据就会丢失,表支持Hash索引,因此查找速度很快。

11.事务的特性

事务及其特性和隔离级别详解
原子性(Atomicity):操作这些指令时,要么全部执行成功,要么全部不执行。只要其中一个指令执行失败,所有的指令都执行失败,数据进行回滚,回到执行指令前的数据状态。
一致性(Consistency):事务的执行使数据从一个状态转换为另一个状态,但是对于整个数据的完整性保持稳定。
隔离性(Isolation):隔离性是当多个用户并发访问数据库时,比如操作同一张表时,数据库为每一个用户开启的事务,不能被其他事务的操作所干扰,多个并发事务之间要相互隔离。
即要达到这么一种效果:对于任意两个并发的事务T1和T2,在事务T1看来,T2要么在T1开始之前就已经结束,要么在T1结束之后才开始,这样每个事务都感觉不到有其他事务在并发地执行。
持久性(Durability):当事务正确完成后,它对于数据的改变是永久性的。

12.主键跟索引的区别

主键与聚集索引的区别
主键(PRIMARY KEY)
表通常具有包含唯一标示表中每一行的值的一列或者一组列。这样的一列或者多列称为表的主键(PK),用于强制表的尸体完整性。在创建或者修改表时,您可以通过定义PK约束来创建主键。
一个表只能有一个PK约束,并且PK约束中的列不能接受空值。由于PK约束可以保证数据的唯一性,因此经常对标识列定义这种约束。
如果为表指定了PK约束,数据库引擎将通过为主键列创建唯一索引来强制数据的唯一性。当在查询中使用主键时,此索引还可以用来对数据进行快速访问。因此,所选的主键必须遵守创建唯一索引的规则。
创建主键时,数据库引擎会自动创建唯一的索引来强制实施PK约束的唯一性要求。如果表中不存在狙击索引或未显示指定非聚集索引,则将创建唯一的聚集索引以强制实施PK约束。
聚集索引
聚集索引给予数据行的兼职在表内排序和存储这些数据行。每个表只能有一个聚集索引,因为数据行本身只能按一个顺序存储。
每个表几乎都对列定义聚集索引来实现下列功能:
可用于经常使用的查询。
提供高度唯一性。

13.InnoDB引擎主键为什么设成自增?

MySQL的InnoDB存储引擎为什么要用自增的主键?
为什么推荐InnoDB引擎使用自增主键?
在InnoDB中,表数据文件本身就是按B+Tree组织的一个索引结构,这棵树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键,因此InnoDB表数据文件本身就是主索引。

这种索引叫做聚集索引。因为InnoDB的数据文件本身要按主键聚集,所以InnoDB要求表必须有主键(MyISAM可以没有),如果没有显式指定,则MySQL系统会自动选择一个可以唯一标识数据记录的列作为主键,如果不存在这种列,则MySQL自动为InnoDB表生成一个隐含字段作为主键,这个字段长度为6个字节,类型为长整形。

InnoDB的辅助索引data域存储相应记录主键的值而不是地址。所以不建议使用过长的字段作为主键,因为所有辅助索引都引用主索引,过长的主索引会令辅助索引变得过大。

InnoDB数据文件本身是一颗B+Tree,非单调的主键会造成在插入新记录时数据文件为了维持B+Tree的特性而频繁的分裂调整,十分低效。

14.默认的隔离级别

mysql的默认隔离级别
主流数据库的默认隔离级别

15.隔离性分几个级别?每个级别的意思?

5分钟带你读懂事务隔离性与隔离级别
4种事务的隔离级别

事务的隔离级别分为:

  • Read uncommitted(读未提交)
  • Read Committed(读已提交)
  • Repeatable Reads(可重复读)
  • Serializable(串行化)

Read uncommitted

读未提交:隔离级别最低的一种事务级别。在这种隔离级别下,会引发脏读、不可重复读和幻读。

Read Committed

读已提交读到的都是别人提交后的值。这种隔离级别下,会引发不可重复读和幻读,但避免了脏读。

Repeatable Reads

可重复读这种隔离级别下,会引发幻读,但避免了脏读、不可重复读。

Serializable

串行化是最严格的隔离级别。在Serializable隔离级别下,所有事务按照次序依次执行。脏读、不可重复读、幻读都不会出现。

16.关于mysql处理百万级以上的数据时如何提高其查询速度的方法

关于mysql处理百万级以上的数据时如何提高其查询速度的方法

17.SQL join操作

SQL的各种连接Join详解
Mysql数据库演示内连接、左连接、右连接

18.数据库的三范式是什么?

数据库三范式
数据库三大范式详解(通俗易懂)

19.数据库MVCC

数据库MVCC 隔离级别

20.数据库类型(关系型数据库/非关系型数据库)

数据库的简介与类型

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

【java基础】汇总

1. Hash Map的底层实现
2. Java中查询元素,和添加元素的整个逻辑过程是如何实现的
3. JavaHashMap底层中,哈希表对应位置上的链表过长,底层如何解决的。当底层红黑树层数过深是,底层又是如何平衡的
4. Java中HashMap底层扩容是如何实现的
5. Java锁有哪些,具体的原理是什么,之间有什么区别
6. HashMap在多线程操作时候,如何保证线程的安全性
7. Collecions类对于线程安全是如何实现的
8. jvm中类加载是如何实现的
9. Java中Class类是什么作用
10. 反射是如何实现的,有什么作用
11. java是解释型语言还是编译型语言?为什么
12. Java在多线程操作中,分组上锁(可能说的是分离锁)是如何实现的?
13. ArrayList 和 LinkedList的区别 / Java底层LinkedList是单链表还是双链表
14. 双亲委派机制
查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

【数据结构与算法】汇总

所有类型面试题集合

1. 冒泡排序实现及复杂度

算法思想:每次比较相邻的两个元素,一直到数组末尾,这样一组操作每次会确定最大位置的元素;重复操作每次将剩下元素中较大的元素交换到数组后面,直到所有元素都确定好位置。
复杂度分析:平均O(n^n),最好O(n),最坏O(n^2)。
稳定性:稳定。
代码模板:

class Solution {
    public void bubbleSort(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums, j, j + 1);
                }
            }
        }
    }

    private void swap(int[] nums, int p, int q) {
        int tmp = nums[p];
        nums[p] = nums[q];
        nums[q] = tmp;
    }
}

2. 归并排序实现及复杂度

归并排序的思想详解
自己之前总结的各种排序
算法思想: 先拆分再合并。
复杂度分析:平均O(nlogn),最好O(nlogn),最坏O(nlogn)。
稳定性:稳定。
代码模板:

class Solution {
    public void mergeSort(int[] nums, int start, int end) {
        if(start<end){
            int mid = (start + end) / 2;
            mergeSort(nums, start, mid);
            mergeSort(nums, mid + 1, end);
            merge(nums, start, mid, end);
        }
    }

    private void merge(int[] nums, int start, int mid, int end) {
        int p1 = start;
        int p2 = mid + 1;
        int index = start;
        int[] tmp = new int[nums.length];
        while (p1 <= mid && p2 <= end) {
            if (nums[p1] < nums[p2]) {
                tmp[index++] = nums[p1++];
            } else {
                tmp[index++] = nums[p2++];
            }
        }
        while (p1 <= mid) {
            tmp[index++] = nums[p1];
        }
        while (p2 <= end) {
            tmp[index++] = nums[p2++];
        }
        for (int i = start; i <= end; i++) {
            nums[i] = tmp[i];
        }
    }
}

3,快速排序实现及复杂度

快速排序的思想
快速排序会问到的问题
自己之前总结的各种排序
算法思想:采用了分治法和递归思想。首先找一个元素作为哨兵,再将大于它和小于它的分别放在右边和左边,这就确定了哨兵的位置。再依次排哨兵左边和右边的数组。
复杂度分析:平均O(nlogn),最好O(nlogn),最坏O(n^2)。
稳定性:不稳定。
代码模板:

class Solution {
    public void quickSort(int[] nums, int low, int high) {
        int p1 = low;
        int p2 = high;
        if (low < high) {
            int tmp = nums[low];
            while (p1 < p2) {
                while (p1 < p2 && nums[p2] > tmp) {
                    p2--;
                }
                if (p1 < p2) {
                    nums[p1] = nums[p2];
                    p1++;
                }
                while (p1 < p2 && nums[p1] < tmp) {
                    p1++;
                }
                if (p1 < p2) {
                    nums[p2] = nums[p1];
                    p2--;
                }
            }
            nums[p1] = tmp;
            quickSort(nums, low, p1 - 1);
            quickSort(nums, p1 + 1, high);
        } else {
            return;
        }
    }
}

TopK
这题直接应用快速排序模板先排序,再去前k个值。
但是力扣上有在快速排序上效率更高的思想,只排到前k个就行了,不用排之后的。

import java.util.Arrays;

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        quickSort(arr,0,arr.length-1);
        return Arrays.copyOf(arr,k);
    }
    private void quickSort(int[] nums, int low, int high) {
        int p1 = low;
        int p2 = high;
        if (low < high) {
            int tmp = nums[low];
            while (p1 < p2) {
                while (p1 < p2 && nums[p2] > tmp) {
                    p2--;
                }
                if (p1 < p2) {
                    nums[p1] = nums[p2];
                    p1++;
                }
                while (p1 < p2 && nums[p1] < tmp) {
                    p1++;
                }
                if (p1 < p2) {
                    nums[p2] = nums[p1];
                    p2--;
                }
            }
            nums[p1] = tmp;
            quickSort(nums, low, p1 - 1);
            quickSort(nums, p1 + 1, high);
        } else {
            return;
        }
    }
}

4.动态规划

【背包思想可解的Leetcode题】
目标和

分割等和子集

零钱兑换

零钱兑换II

组合总和

5.回溯法

全排列

import java.util.*;

class Solution {
    /**
     * 全排列
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<Integer> path = new LinkedList<>();
        boolean[] used = new boolean[nums.length];
        backtrack(nums, ans, 0, path, used);
        return ans;
    }

    /**
     * 回溯法
     *
     * @param nums
     * @param ans
     * @param i
     * @param path
     * @param used
     * @return
     */
    private void backtrack(int[] nums, List<List<Integer>> ans, int depth, LinkedList<Integer> path, boolean[] used) {
        if (depth == nums.length) {
            ans.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            path.addLast(nums[i]);
            used[i] = true;
            backtrack(nums, ans, depth + 1, path, used);
            path.removeLast();
            used[i] = false;
        }
    }
}

目标和

class Solution {
    private int count = 0;

    public int findTargetSumWays(int[] nums, int S) {
        backtrack(nums, S, 0);
        return count;
    }

    /**
     * 回溯法
     * @param nums
     * @param rest
     * @param i
     */
    private void backtrack(int[] nums, int rest, int i) {
        if (i == nums.length) {
            if (rest == 0) {
                count++;
            }
            return;
        }
        rest -= nums[i];
        backtrack(nums, rest, i + 1);
        rest += nums[i];

        rest += nums[i];
        backtrack(nums, rest, i + 1);
        rest -= nums[i];
    }
}

组合总和

import java.util.*;

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<Integer> sub = new LinkedList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, 0, ans, sub);
        return ans;
    }

    /**
     * 回溯法&剪枝
     * @param candidates
     * @param rest
     * @param i
     * @param ans
     * @param sub
     */
    private void backtrack(int[] candidates, int rest, int i, List<List<Integer>> ans, LinkedList<Integer> sub) {
        if (rest == 0) {
            ans.add(new LinkedList<>(sub));
            return;
        }

        for (int k = i; k < candidates.length; k++) {
            if (rest - candidates[k] < 0) {
                break;
            }
            sub.add(candidates[k]);
            backtrack(candidates, rest - candidates[k], k, ans, sub);
            sub.removeLast();
        }
    }
}

组合总和 II(允许不同级不允许同级那里没看太懂)

import java.util.*;

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<Integer> sub = new LinkedList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, 0, ans, sub);
        return ans;
    }

    /**
     * 回溯法&剪枝
     *
     * @param candidates
     * @param rest
     * @param i
     * @param ans
     * @param sub
     */
    private void backtrack(int[] candidates, int rest, int i, List<List<Integer>> ans, LinkedList<Integer> sub) {
        if (rest == 0) {
            ans.add(new LinkedList<>(sub));
            return;
        }
        for (int k = i; k < candidates.length; k++) {
            if (rest - candidates[k] < 0) {
                break;
            }
            //允许不同级但不允许同级
            if (k > i && candidates[k] == candidates[k - 1]) {
                continue;
            }
            //加上当前的数
            sub.add(candidates[k]);
            backtrack(candidates, rest - candidates[k], k + 1, ans, sub);
            sub.removeLast();
        }
    }
}

全排列 II(同样是同级不同级那里)

import java.util.*;

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<Integer> sub = new LinkedList<>();
        boolean[] used=new boolean[nums.length];
        Arrays.sort(nums);
        backtrack(nums, used,0, ans, sub);
        return ans;
    }

    /**
     * 回溯法&剪枝
     *  @param nums
     * @param used
     * @param i
     * @param ans
     * @param sub
     */
    private void backtrack(int[] nums, boolean[] used, int i, List<List<Integer>> ans, LinkedList<Integer> sub) {
        if (sub.size() == nums.length) {
            ans.add(new LinkedList<>(sub));
            return;
        }
        for (int k = 0; k < nums.length; k++) {
            if(used[k]){
                continue;
            }
            //允许不同级但不允许同级
            if (k > 0 && nums[k] == nums[k - 1]&&used[k-1]) {
                continue;
            }
            //加上当前的数
            sub.add(nums[k]);
            used[k]=true;
            backtrack(nums, used, k + 1, ans, sub);
            used[k]=false;
            sub.removeLast();
        }
    }
}

子集

import java.util.*;

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ans=new ArrayList<>();
        LinkedList<Integer> sub=new LinkedList<>();
        backtrack(nums,ans,sub,0);
        return ans;
    }

    private void backtrack(int[] nums, List<List<Integer>> ans, LinkedList<Integer> sub, int i) {
        if(i==nums.length){
            ans.add(new LinkedList<>(sub));
            return;
        }
        sub.addLast(nums[i]);
        backtrack(nums,ans,sub,i+1);
        sub.removeLast();
        
        backtrack(nums,ans,sub,i+1);
    }
}

子集 II

import java.util.*;

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<Integer> sub = new LinkedList<>();
        Arrays.sort(nums);
        backtrack(nums, ans, sub, 0);
        return ans;
    }

    private void backtrack(int[] nums, List<List<Integer>> ans, LinkedList<Integer> sub, int i) {
            ans.add(new LinkedList<>(sub));
        for (int k = i; k < nums.length; k++) {
            if (k > i && nums[k] == nums[k - 1]) {
                continue;
            }
            sub.addLast(nums[k]);
            backtrack(nums, ans, sub, k + 1);
            sub.removeLast();
        }
    }
}

6.如何用链表实现栈

查看原文

赞 0 收藏 0 评论 0

吃不完的土豆番茄 发布了文章 · 7月31日

【操作系统】汇总

整理好的一些操作系统面试题

1.进程和线程的区别

2.进程之间是如何切换的

3.什么是操作系统

4.进程的三种基本状态

5.进程状态间的切换

6.线程的几种状态

7.什么是线程?什么是进程?

8.一个进程里包含什么?

9.linux进程有5种状态

10.进程和线程的关系?

11.多进程和多线程之间的区别

12.什么时候适合用多线程什么时候适合用多进程?

13.作业、管程各自定义

14.什么是进程间通信?通信的目的?

15.进程间通信方式-IPC?哪种方式效率最高?

16.X64和X86的区别

17.死锁的产生和解除

18.避免死锁的算法

19.互斥体和临界区的区别

20.Windows链接器加载动态库(DLL)的搜索路径顺序

21.什么是内存抖动

22.多线程、多进程在实际服务器中的应用

23.线程(进程)同步的方式有哪些?

24.什么是缓冲区溢出?有什么危害?其原因是什么?

25.说一说进程同步有哪几种机制。

26.操作系统中进程调度策略有哪几种?

27.分页和分段有什么区别?

28.用户态和内核态的区别

29.用户态进入内核态的方式,如何进入内核态

30.什么叫僵尸进程?怎么处理僵尸进程?

31.ps -aux什么意思

32.虚拟内存

33.缺页中断

34.lru实现

35.系统是怎么调度线程的?

36.hash冲突的解决办法

37.什么是协程

38.socket的读写操作

39.什么是中断

40.线程间通信(?)

41.页面置换算法LRU/LFU

42.cpu内存

43.cpu缓存

44.进程和线程和协程的区别

45.进程调度算法

46.内存置换算法有什么

47.什么是时钟置换算法

48.线程高速缓存

49.内存分配高低地址

50.动态库加载机制

51.什么是银行家算法

查看原文

赞 0 收藏 0 评论 0

认证与成就

  • 获得 16 次点赞
  • 获得 1 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 1 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 3月11日
个人主页被 461 人浏览