面试主要知识点：
tcp拥塞控制，qq是用过tcp还是udp。
mysql中 delete和truncate的区别与对比
答：
(1)应用范围：delete:视图和表 truncate：表
（2）表和索引所占空间。
当表被TRUNCATE 后，这个表和索引所占用的空间会恢复到初始大小，
DELETE操作不会减少表或索引所占用的空间。
drop语句将表所占用的空间全释放掉。
(3)
TRUNCATE TABLE 则一次性地从表中删除所有的数据并不把单独的删除操作记录记入日志保存，删除行是不能恢复的。并且在删除的过程中不会激活与表有关的删除触发器。执行速度快。所以在没有备份的前提下谨慎使用
（4） Truncate table 表名 速度快,而且效率高,因为:
truncate table 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。
（5） TRUNCATE TABLE 删除表中的所有行，但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。如果想保留标识计数值，请改用 DELETE。如果要删除表定义及其数据，请使用 DROP TABLE 语句。
（6） 对于由 FOREIGN KEY 约束引用的表，不能使用 TRUNCATE TABLE，而应使用不带 WHERE 子句的 DELETE 语句。由于 TRUNCATE TABLE 不记录在日志中，所以它不能激活触发器
一、delete
1、delete是DML，执行delete操作时，每次从表中删除一行，并且同时将该行的的删除操作记录在redo和undo表空间中以便进行回滚（rollback）和重做操作，但要注意表空间要足够大，需要手动提交（commit）操作才能生效，可以通过rollback撤消操作。
2、delete可根据条件删除表中满足条件的数据，如果不指定where子句，那么删除表中所有记录。
3、delete语句不影响表所占用的extent，高水线(high watermark)保持原位置不变。
二、truncate
1、truncate是DDL，会隐式提交，所以，不能回滚，不会触发触发器。
2、truncate会删除表中所有记录，并且将重新设置高水线和所有的索引，缺省情况下将空间释放到minextents个extent，除非使用reuse storage，。不会记录日志，所以执行速度很快，但不能通过rollback撤消操作（如果一不小心把一个表truncate掉，也是可以恢复的，只是不能通过rollback来恢复）。
3、对于外键（foreignkey ）约束引用的表，不能使用 truncate table，而应使用不带 where 子句的 delete 语句。
4、truncatetable不能用于参与了索引视图的表。
三、drop
1、drop是DDL，会隐式提交，所以，不能回滚，不会触发触发器。
2、drop语句删除表结构及所有数据，并将表所占用的空间全部释放。
3、drop语句将删除表的结构所依赖的约束，触发器，索引，依赖于该表的存储过程/函数将保留,但是变为invalid状态抖音登陆测试思路
抖音下划测试思路
mysql的自联结，左外连接
操作系统的进程状态，进程与线程不同，进程死锁的原因，死锁检测，死锁避免，死锁预防等等，进程之间的通信。
jvm虚拟机
线程锁
算法题：
1.
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
nums = [-1, 0, 1, 2, -1, -4,4,5]
注意：答案中不可以包含重复的三元组。
思路：先求一个和数组，然后通过hashmap判断是否有和的负值存在
import java.util.Scanner;
import java.util.*;
public class Main {
public static void main(String[] args) {
int nums[]=new int[]{-1,0,1,2,-1,4,5};
int len=nums.length;
ArrayList<num> arraylist=new ArrayList<>();
HashMap<Integer,Integer> hashmap=new HashMap<>();//存储数组
ArrayList<Integer>[] arraylists=new ArrayList[len];//存储结果
int flag1=0;//标注有多少个解
for(int i=0;i<len;i++){
for(int j=i;j<len;j++){
if(j==i)continue;
else arraylist.add(new num(nums[i],nums[j],nums[i]+nums[j]));
}
}
for(int i=0;i<len;i++){
hashmap.put(nums[i],i);
}
for(num a:arraylist){
if(hashmap.containsKey(-a.k)){
if(-a.k!=a.i&&-a.k!=a.j){
arraylists[flag1]=new ArrayList<Integer>();
arraylists[flag1].add(a.i);
arraylists[flag1].add(a.j);
arraylists[flag1].add(-a.k);
flag1++;
}
}else{
continue;
}
}
for(ArrayList arr:arraylists){
if(arr==null){
continue;
}else{
System.out.println(arr.get(0)+","+arr.get(1)+","+arr.get(2));
}
}
}
static class num{//标记数字
int i;
int j;
int k;//累加结果
public num(int i,int j,int k){
this.i=i;
this.j=j;
this.k=k;
}
}
}2.
判断一个字符串是否符合ipv4地址，返回true或者false
比如输入“127.0.0.1”，返回true
输入"256.1.2.3"，返回false
思路：比较简单，分四个部分判断就行，可以注意一下优化，能提前判断错误就直接返回不要进行太多的步骤。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
String str="127.000.0.0";
System.out.println(istrue(str));
}
public static boolean istrue(String str){
boolean flag=true;//标记是否合法
String str1[]=str.split("\\.");//存储每一个部分
// String string[]=str.split('.);
int len =str1.length;
if(len!=4)return false;
for(int j=0;j<str.length();j++){
if((((str.charAt(j)-'0')>9)||((str.charAt(j)-'0')<0))&&str.charAt(j)!='.')
return false;
}
int num[]=new int[len];
for(int i=0;i<len;i++){
if(str1[i].length()>3)return false;
else {
if(str1[i].charAt(0)=='0')return false;
num[i]=Integer.valueOf(str1[i]);//将每一部分转换为数字
if(num[i]>255||num[i]<0){
return false;
}
if(i==0&&num[i]==0){
return false;
}
}
}
return true;
}
}3.将中文亿级数字转换为int，值范围[0, 10^9]
一千零二十四 => int
Cases
一千零二十四
一亿零九万三千八百
零
思路：我是根据字符串的‘万’和‘亿’字符的位置进行分割，将字符串分割成三个部分，然后依次判断，最后累加起来就行。
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static HashMap<Character,Integer> hashmap;
public static void main(String[] args) {
//Scanner in = new Scanner(System.in);
//int a = in.nextInt();
//System.out.println(a);
hashmap=new HashMap<>();
hashmap.put('一',1);
hashmap.put('二',2);
hashmap.put('三',3);
hashmap.put('四',4);
hashmap.put('五',5);
hashmap.put('六',6);
hashmap.put('七',7);
hashmap.put('八',8);
hashmap.put('九',9);
String str="零";
int a=str.indexOf("万");//找出节点
int b=str.indexOf("亿");
String str1[]=new String[3];//分别表示个，万，亿
if(a!=-1&&b!=-1){
str1[2]=str.substring(0,b);
str1[1]=str.substring(b+1,a);
str1[0]=str.substring(a+1,str.length());
}
else if(a!=-1&&b==-1){
str1[1]=str.substring(0,a);
str1[0]=str.substring(a+1,str.length());
}else if(a==-1&&b==-1){
str1[0]=str;
}
int sum=0;
for(int i=0;i<3;i++){
if(str1[i]!=null){
//进行判断
if(i==0)
sum+=cat(str1[i])*1;
else if(i==1)
sum+=cat(str1[i])*10000;
else sum+=cat(str1[i])*100000000;
}
}
System.out.println(sum);
}
public static Integer cat(String string){
//进行每一部分的变换
char[] a=string.toCharArray();
int len=a.length;
int flag2=1;//标记当前扫描的位数
int sum=0;
for(int i=len-1;i>=0;i--){
if(i==len-1){
if(a[i]=='十'){
flag2=100;
continue;
}
else flag2=1;
}
else{
if(a[i]=='十'||a[i]=='零')
{
flag2=10*flag2;
continue;
}
}
if(a[i]=='千'){
flag2=1000;
continue;
}
if(a[i]!='千'&&a[i]!='百'&&a[i]!='十'&&a[i]!='零'){
sum+=hashmap.get(a[i])*flag2;
}
}
return sum;
}
/*
1000 //一千
0001//一
1001//一千零一 //不适合的
1100//一千一百
0011//一十一
1010//一千零一十
0110//一百一十
0101//一百零一
1110//一千一百一十
1101//一千一百零一
1011//一千零一十一
0111//一百一十一*/
}