面试笔试不懂的东西（更新第一次）

最新推荐文章于 2023-07-06 14:24:47 发布

kelsey1234

最新推荐文章于 2023-07-06 14:24:47 发布

阅读量527

点赞数

分类专栏：笔试面试总结文章标签： Review更新第一次

本文链接：https://blog.csdn.net/kelsey1234/article/details/99627847

版权

笔试面试总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Review

笔试题不懂的东西：

在这里插入图片描述

~:按位取反 eg:~101010 == 010101

&:有0则0，全1才1

|：有1则1，全0才0

(因为&|比&&||多出位运算，比如0x31&0x0f = 0x01，所以优先级高于&&||)

11111111&

00000001=

00000001

&&:一假即假

||：一真即真

<<:乘以2的n次方 >>:除以2的n次方顾明思议，移位运算要是整型数据类型

^按位异或

split("\\d"):转义字符\ 加上\d匹配0-9,按照0-9中任意数字进行拆分

super表示调用父类构造器

构造方法：

1、构造方法方法名必须和类名相同

2、构造方法没有返回类型，也不能定义void（方法名前不声明方法类型）

3、构造方法用来给对象初始化赋值

4、一个类中可以有多个构造方法（重载），若没有定义构造方法，系统会自动插入无参构造器

String regex = “\.\s*“是指匹配”.(任意空格)”

构造器参数与成员变量相同时必须用this区别，不然该构造器视为无用（eg：name=name）

子类重写父类方法权限问题：

子类不能缩小父类方法的访问权限（你继承了就够了，不要变本加厉想要占为己有）

java中数据的运算：

如果进行运算的是两个变量：会先进行类型的提升，然后在进行运算赋值（byte short char）

其中+=这种运算符在赋值运算时会自动转换

如果进行运算的是两个常量：会先进行类型运算，然后判断是否满足类型范围，满足之后在进行赋值。

String 定长字符串及地址问题：

public static void main (String [] args) {

String foo = “blue”;		

String bar = foo;

foo = “green”;

System.out.println(bar);

}

String s1 = "a";
String s2 = "b"+s1;
System.out.println(s2 == "ba");//false

分析：

1、foo指向的地址值是“blue"

2、bar的地址值和foo的地址值相同

3、foo的地址值指向新的地址值green了，但是这跟bar地址值又有什么关系呢

注：String类是定长字符串，调用一个字符串的方法以后也会形成一个新的字符串。不再是以前的字符串了。

三目运算符结果问题：

三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果

由容量高的决定。eg:int x = 1;(x>4) ? 99.9 :9 99.9是double类型而9是int类型，double容量高输出为9.0。

构造方法：类中可以有与类名相同的方法。

一道很容易出错的题：

Set s=new HashSet();

for(Short i=0;i<100;i++)

{

s.add(i);

s.remove(i-1);

}

i是Short类型，i-1是int类型，自动装箱成Integer类型。所以remove方法失效，不能对集合进行操作，所以只有add方法

**栈：**栈是先进后出线性表

子父类重写的问题：

子类中有和父类方法名相同参数列表不同，可以。可以认为是新定义的方法;

但是如果方法名相同，参数列表相同，访问权限，异常都相同，只有返回类型不同，编译则不答应。

面试不懂的东西：

多线程的好处：

1、cpu资源利用率更高：

cpu在等待磁盘读取文件，或者网络io等可以去做一些其他的事。比如处理文件。所以cpu利用率会变高

2、防止阻塞：多线程防止即使一条数据代码在读取文件的时候阻塞，不会影响其他任务的执行。比如聊天室项目中的读取数据：为了不让程序阻塞在读写代码前，也就是即使没有读取到任何内容也能让其他客户端连接到。我就把读写方法放到线程中。

3、程序响应更快；比如你点开一个耗时的任务，此时程序既要更新窗口又要执行任务。此时将任务交给工作者线程，工作者线程在执行任务的时候，窗口线程响应其他用户的请求。对于用户来说，这种工作者线程响应速度更快。

线程安全是什么意思？

当多个线程去访问同一个对象时，主程序中不做任何同步，不管怎么调用这些对象或者说线程如何交替执行，执行结果都是我们想要的正确结果，那这个线程就是安全的。（一般都是局部变量和全局变量引起的）

多线程情况便要考虑线程同步，否则会影响线程安全。比如售票程序，多个售票机去售卖100张票，就会出现两个售票机售卖同一张票号的情况，此时就是线程非安全的，我们可以通过对售卖的对象加锁，当拿到这个票号的售票机进行售卖时。其他售票机就不会抢占了售卖了。

js中循环遍历：

<script>
        var myArr = [1,2,34,4,45,23];
        function first() {

            for (var index = 0;index <myArr.length;index++){
                console.log(index);
            }
            console.log("第一种循环遍历方式");
        }
        function second() {
            for (var index in myArr){
                console.log(myArr[index]);
            }
            console.log("第二种循环遍历方式");
        }
        function third() {
            myArr.forEach(function (value, index) {
                console.log(index+":"+value);
            });
            console.log("第三种循环遍历方式");
        }
    </script>
    <style>
        label{
            display: inline-block;
        }
    </style>
</head>
<body>
<a><button onclick="first()">第一种循环遍历</button></a>
<label onclick="third()">第三种遍历方式</label>
<p><button onclick="second()">第二种循环遍历方式</button></p>

什么情况下使用JavaBean?

1、JavaBean 是一种规范的标准Java对象：其中必须包括私有成员变量和getter setter方法，公共的构造器，无参构造器，实现序列化接口。

2、它是一种编程思想。实现了数据的封装，我们使用数据的时候只要调用该对象即可。

3、同时访问数据库是可以作为接收类型存储数据库取出的数据，也可以作为传入对象将javabean类型的对象往数据库里放。

讲讲你对java反射机制的了解：

反射就是对于任意一个类我们都能获取其属性和方法；对于任意一个对象，我们都能调用其属性和方法；动态地获取属性及调用方法就是Java反射

加载类：Class myClass = Class.forName(“包名.类名”);

======================================================

获取私有成员变量：Field f = myClass.getDeclareField(“name”);

调用成员变量：Object obj1 = myClass.getConstructor().newInstance();

f.setAccessible(true);

f.set(obj,“打不死的小强哈哈哈哈”);

==========================================================

获取公共的构造器:Contructor c = myClass.getConstructor();//传参就是有参构造器，传null就是无参构造器；

私有的构造器:myClass.getDeclareConstructor(String name);

调用公共构造器：Object obj2 = myClass.getContructor(char.class);

c.newInstance(“男”)；//获取传入一个参数的构造器

===========================================================

获取方法:Methd m = myClass.getMethod(“show1”,String .class);//获取方法名是show1,传入的参数是String类型的方法

调用方法:Object obj = myClass.getConstructor().newInstance();

m.invoke(obj,“打不死的小强”);

包装类和基本数据类型用“==”比较:

Integer a =100;//或者是1000

int b= 100;//或者是1000

sout(a == b);//都为true

Linux基本操作符：

pwd:查看当前目录完整路径

ls:查看目录

cd:切换当前路径位置

ctrl+insert:复制

shift+insert:粘贴

mkdir:创建目录

find + ‘文件名/目录名’:查找文件或目录

grep:查找文件内容

json dto vo是什么？

vo是View Object视图对象

dto:Data Transfer Object 是数据传输对象

json是轻量级的简洁的文本形式存储和表示数据的数据交换格式

什么时候用多线程？

程序包含复杂的计算任务时；处理速度较慢的外围设备时，用独立的线程处理任务，让程序不需要专门等待结果而耗费时间。

一般servelet框架本身是有多线程的，只是是由webserver帮我们启动了，不需要我们自己去启动；

一般处理网络通信问题，都是需要自己做多线程处理的；

多线程主要作用就是两个：

1.不阻塞主线程任务

2.并发，提高吞吐量

多线程的意义：提高任务执行效率

多线程要考虑数据安全。不能同时处理同个数据的时候就要考虑到锁机制

sql注入：

欺骗服务器执行恶意的sql命令，欺骗服务器授予其权限。比如在登录时用户名和密码输入一些关于永远成立的语句‘1‘ =’1‘这样的语句。web提交表单给服务器，服务器进行后台操作时sql语句会被修改。

basic:

变量命名规则：

1、字母、数字、$、_组成；

2、不能以数字开头；

3、不能有java中保留字：if、for等；

4、大小写敏感；

5、中文最好不要用。

8中基本数据类型：可以进行转换（隐式和显式）

byte(1)–short(2)–int(4)–long(8)–float(4)–double(8)

boolean(1) char(2)(0~65535)—

其中char支持：

char a = ‘A’ ; char b= 32 ; char c = ‘\u0041’

分支结构：

if-else ; switch-case(优势：可以用break跳出分支结构；很明显结构很清晰；因此执行效率高。)1.7之后接受switch中可以使用字符串表达式。本来只能接受整型直接量。

循环结构：

两要素：循环条件boolean表达式；循环体

while;doWhile;for;

break:只能使用在switch和循环结构中；break表示终止循环执行循环后面的语句。

continue：只能使用在循环语句中；continue表示跳过当前循环体中剩余语句而去执行下一次循环。

程序：算法+数据结构

数组：

1、最基本的数据结构
2、同种数据类型元素的集合

3、线性顺序排列，一个接一个

4、有索引下表

三种数组初始化方式：

简单的：int[] arr1 = {1,2,3,4,4};//只能声明时进行初始化

静态的：int[] arr2 = new int[] {2,54,57,6};

//或者：

int[] arr2 ;

arr2 = new int[]{2,54,57,6};

动态的：int[] arr3 = new int[5];

其中都使用8种基本数据类型的默认值：

long int byte short 都是0 char类型是空字符串；double float是0.0

数组复制问题：

Arrays.copyOf(srcName,int length)//可以实现数组的扩容，只要src.length+1;进行截取只要小于src.length

System.arrayCopy(src,int index,dest,int index,int length)

流程：先将目标数组写好，然后将原数组复制到目标数组的dest位置上，复制的元素是src数组 index位置长度为length的元素们

数组排序：

public class BubbleSort{

public static void main(String[] args){
//随机产生11个元素

int[] arr = new int[11];

for (int i = 0 ; i < arr.length ; i ++){

Random r= new Random();

int elem = r.nextInt(100);

arr[i] = elem ;

}

//进行冒泡排序 : 11个元素排序10次
for(int j = 10 ； j > 0 ; j --){

for(int i = 1 ; i <= j ; i++){
if(arr[i-1] > arr[i]){
int temp = arr[i-1];

arr[i - 1] = arr[i];

arr[i] = temp;

}

//增强for循环遍历出数组内容

}

return作用：

将值返回给调用方

结束当前方法

oop

什么是类？

类是抽象数据类型：不仅定义了抽象数据类型组合（成员变量），还定义了针对抽象数据类型的操作（方法），说到底类时对象的概括，对象是类的具体实现。======类时对象的模子；是具有相属性和方法的对象的集合

方法签名：

1、方法名

2、参数列表（类型和数量）

对象内存管理：

对象存储在堆中，没有任何引用指向的对象被视为被废弃的对象,Java中gc（Garbage Collection)垃圾回收机制针对没有任何引用指向的对象会进行回收。这是Java自带的自动运行这的线程。如果没有被即使回收，会因为内存占用过多而导致内存泄漏

局部变量和成员变量的区别：

1、局部变量存储在方法中，成员变量存储在方法外；

2、局部变量声明时必须设定初始值，成员变量可以不设置初始值；

3、局部变量在方法被加载时创建，存储在栈中，方法调用结束，被清除；成员变量在被实例化后存储在堆中，对象被回收，成员变量失效。

实例变量：是类的成员变量；类变量或静态成员变量必须用static修饰；

静态变量：是所有对象所共享的，所以上述代码中的几个对象操作是同一静态变量x，静态变量可以通过类名调用。

重写和重载的区别：

重写：

子类重写父类，方法名相同参数列表也相同，只是方法的实现不同。子类重写父类方法后，无论是子类调用还是父类调用，执行的都是重写后的版本。

重写遵循编译器绑定，程序根据调用该方法的引用指向的对象绑定哪个方法

子类方法的返回值必须和父类保持一致，子类方法的访问修饰符不能严于父类，子类的异常不能比父类大。

重载：

方法名相同参数列表不同；常见的有构造器的重载。程序在运行时根据参数个数或参数类型决定调用哪个方法。

重载遵循运行期绑定，程序根据参数个数和参数类型的不同决定绑定哪个方法

抽象类和接口的区别：

1、抽象类和接口都不能直接实例化。如果要实例化，该抽象变量必须指向实现该抽象类的抽象实现类。接口变量必须指向实现该接口的接口实现类。

2、接口可以做方法的申明，不能做方法的实现。而抽象类既可以做方法的申明又可以做方法的实现，且在方法的申明的时候不能做方法的实现。

3、接口中只有抽象方法，而抽象类中即可以有抽象方法也可以有普通方法，抽象类中也可以一个抽象方法也没有，这个不会有语法错误。但是毫无意义，说到方法：抽象类中的抽象方法不能是静态的私有的。因为这些方法要被子类实现。抽象类中可以有静态方法，但静态和抽象不能共存在同一个方法上（解释：申明static说明可以直接用类名调用该方法，声明abstract说明需要子类重写该方法，如果同时声明static和abstract，用类名调用一个抽象方法肯定不行）。

4、接口中的变量只能是公共的静态的常量，而抽象类中的变量是普通成员变量（也就是说可以有private修饰的成员变量）

5、接口可以继承接口并且可以多继承，抽象类只能单继承

访问控制修饰符访问权限：

从打到小依次是：public protected,默认，private
最大能访问的：其他包中的类，子类，同一个包中的类，本类。

static:

static是属于类的，static修饰的成员变量和方法都存放在方法区，static方法中不能调用非static方法，必须new 出该非static类，然后用该类去调用

非static的内部类不可以使用static成员；只有在顶层类中或者static修饰的内部类中可以使用static，当内部类用static修饰了，就不能调用外部类的非static成员

final：

修饰局部变量是常量

修饰成员变量是地址值不可以被改变：final规定了一旦你指向一个对象了就不要乱指了；当然你阻挡不了你对象发生改变，那他随意。

final Person per = new Person(); //定义了一个Person类的对象引用per，并指向了new的对象

per = new Person(); //重新创建一个Person类对象，并让per指向它，会出现与上面一样的错误，即final修饰的引用类型变量不能重新赋值

per.name = "me"; //per指向的对象本身的内容可以更改

修饰方法是不可以被重写

修饰类不可以被继承

final初始化：构造器中进行初始化；声明同时进行初始化：

封装：

口语表达：简单来说就是功能都给你实现好了，你不用了解他是怎么实现的只要直接去用就可以了，但这是对于使用者来说，对于开发者，封装就得我们自己干。那怎么实现封装呢？这个问题我们应该反过来问使用者，对于使用者自然希望越简单越好，所以我们开发者要将复杂的代码封死不让啊使用者接触。为什么不让使用者去接触呢？因为大多数使用者都是不大专业的，如果暴露了太多的接口给他们，就会出现一些稀奇古怪的问题，就好比让啊一个不会做酸菜鱼的人去做酸菜鱼，肯定是不会做的，但是如果我们给它一条鱼和调料，让她直接放进锅里就会简单很多，所以，我们将复杂代码封装起来，就会避免一些不必要的麻烦。

继承：

继承的作用简单来说就是实现代码的重用；子类继承父类后可以使用父类的方法，还可以在原有的基础上进行功能的补充；比如说学生一定是人，但是比人有更多的属性和方法，所以继承在一定程度上消除了机构上的重复；Java中只能实现单继承，不能多继承。

多态：

多态靠的是父类接口中的引用变量指向具体实现类的实例对象。而程序调用的是引用变量指向的具体实现类的方法而不是引用变量的类型中定义的方法。

j2se:

String 是什么？常用api?

String是静态字符串常量。一旦创建不可以被改变；创建在常量池中；是用final修饰的，不可以被继承。

对于重复出现的字符串，jvm会首先在常量池中查找，找到后直接返回这一个对象，不会创建新对象。

api:substring(),indexOf();lastIndexOf();charAt();split();startsWith();endsWith();toUpperCase();toLowerCase();replace();replaceAll();int indexOf(String s , int index):返回指定字符串s在字符串中从index开始第一出现的索引

==:

对于基本数据类型：比较的是值得大小

对于引用类型：比较的是引用的地址值

equals:

默认情况下；不进行重写比较的是地址值（Object）

重写后（String， Date， Integer)比较的是值内容

StringBuilder和StringBuffer区别:

他们都是可变字符串

StringBuilder是非线程安全的，StringBuffer是线程安全的，他们几乎无差别，差别就在于StringBuffer里的大部分方法都是synchronize修饰的,他们拥有的方法：charAt();delete(int i1,int i2);indexOf(String s);

append();reverse();replace()

执行效率：StringBuider>String BUffer>String

String和StringBuilder区别：

[外链图片转存失败(img-tGb7i9Lt-1565840987937)(C:\Users\Administrator\Desktop\14ce36d3d539b60078c4295def50352ac75cb7d5.jpg)]

1、String是不可变字符串，其内容不可变，引用变量名字可变；StringBuilder是可变字符串

String a = "wo";
String b = "wo";
System.out.println(b);

2、StringApi中没有reverse方法，delete(int index)，insert( int index)因为一旦创建就不可以改变；；StringBuilder中没有replaceAll方法：类似于StringBuilder和StringBuffer都可以append那都是无止尽的，谈何replaceAll()呢？
3、String中重写了equals()方法，StringBuilder没有重写，比较的还是地址值

Date:

Date()中的方法：setTime();getTime()getTime()返回类型是Date类型

SimpleDateFormat:格式化:new SimpleDateFormat(“yyyy-MMM-dd HH:mm:ss”).format(Date date)

解析：new SimpleDateFormat(“yyyy-MM-dd”).parse(String date)

Canlendar();静态工厂方法：getInstance();

Collection:

List:Map下的接口

List是有序的（存储顺序和取出顺序一致）；

List存储的元素可以重复；

List接口常用子类有：

ArrayLiist LinkedList vector

List中常用方法：

add(E elem);add(int Index,Object o)//可以插入一个新的集合 ;remove(int index);remove(E elme);set(Int index,E elem);get(int Index);

List中的遍历可以用迭代器：

Iterator it = list.Iterator();

while(it.hasNext){

sout(it.next)

}

这其中不能对list进行增删改的操作，会产生ConcurrentModificationException异常，产生数据的不确定性，解决方法：可以使用ListIterator代替

List存储数据结构有哪些？

堆栈、队列、数组、链表

堆栈：先进后出队列：先进先出

数组：增删慢，查询快。

增的话必须先创建一个新的数组将新插入的元素放到指定位置，旧数组的元素按照索引一一对应到新数组上

而对于链表：增删就比较块，查询速度慢：要进行遍历，时间复杂度是o(n)

链表的增：加入现在有两个元素，每个元素都有两个引用，第一个引用指向前一个元素，第二个引用指向后一个元素，将新插入的元素的后一个引用的地址值该为第二个引用的地址，即让其指向第二个元素；让啊第一个元素的后一个引用地址值改为插入的元素的前驱索引值，即让其指向新插入的元素；

所以只要改变地址值即可实现插入和删除

ArrayList和LinkedList的区别就在于数组和链表的区别

而他们都是非线程安全的，都是非同步的

而Vector是同步的线程安全的

Vector是早期的迭代器，底层是数组结构，有独特的枚举取出元素方式。

集合转数组：list.toArray()

数组转集合：Arrays.asList();

Set:Collection接口下的子接口

set是存储既可以有序又可以无序，但是不能重复的集合。存储有序的set集合有LinkedHashSet:底层是哈希表和链表的结构，所以他可以保证元素的不重复且有序；存储无序的set集合有HashSet:

set中保证数据不重复的规则是：先判断新增的元素的hashcode值是否和集合中的元素的hashCode值相等？如果不相等，不是同一个元素，直接添加进set结合中；如果相等，再对equals()方法进行判断，如果返回truz则是相同元素，不可以添加进集合中，如果返回false则是不同元素，可以添加集合;因此。想要使得set集合实现存储不重复元素，必须让自定义类实现equals和hashCode方法，否则比较的只是地址值，不是元素内容。

至于它的方法大致和List相同，实际操作中可以用.获取到，但是不一样的是他没有get方法，因为他是无序的存储进的元素没有索引值。

锁机制包括哪两个部分？

锁的对象

锁的代码块

锁的对象可以包括哪三种？

锁对象、锁普通方法、锁静态方法（相当于锁类对象）

线程安全的API:

Map中：HashTableConcurrentHashTable;

List中：Vector

io中：StringBuffer

让线程停止执行的方法：

sleep() ; wait() ; notify() ; stop() ; synchronized() ; yield() ;

线程生命周期：

在这里插入图片描述

Jdbc访问数据库基本操作：

加载驱动Class.forName----创建连接-----创建preparestatement–定义sql语句 ----数据库操作 ---- 返回结果集并进行操作 ---- 关闭连接（关闭顺序：从里到外一层一层关闭·

PrepareStatement和statement的区别：

preparestatement是预编译，支持批处理，效率高，安全性高，但是其开销比sattement大。

jdbc访问数据库具体实现代码：

jdbc:oracle:thin:@localhost:1521:XE

public static void main(String[] args) {
    //加载驱动
    Class.forName("oracle.jdbc.driver");
    //创建连接
    Connection conn  = DriverManager.getConnection("XXXXXXXXXXX",
                            "java12",
                            "itek");
    //创建ststament
    Statement state = conn.createStatement
    //创建sql语句
    String sql = "select id ,name from emp where id = 1;
    //执行sql语句
    ResultSet rs = state.executeQuery(sql);
    //读取语句
   while(rs.next){
       rs.getString("name")+":"+rs.getInt("id");
   }
    //关闭资源
    conn.close();
}

public static void main(String[] args) {
 	Class.forName("com.mysql.jdbc.driver");
    Connection conn = DriverManeger.getConnection("jdbc:MySql://localhost:3306/wpzhang"
                               	"root",
                                "ITEK");
    PrepareStatement ps = conn.prepareStatement("select id , name from emp_wpzhang");
    ResultSet rs = ps.executeQuery();
    while(rrs.next()){
        rs.getString("name")+":"+rs.getInt("id");
    }
    conn.close();
}

jdbc脏读：

jdbc幻读：

数据库

数据库中模糊查询所需通配符：

_匹配单个字符

%匹配0-多个字符

查询语句的执行顺序：from–where–group by-- having-- order by-- select

排序关键字：ASC DESC

查询条件中的where中可用关键字8:

±&/ and/or in/not in is null/is not null between…and… like…_/%… distinct去重 all/any

聚合函数(只能在select中使用)min max avg sum nvl(comm,0)配合sum avg使用 count

子查询可以在哪几个语句中？

select from where having

子查询返回结果可以分为哪三种？

单行单列：一个数据

多行单列：集合

多行多列：表

分页查询：起始值start= (pageNo - 1)*pageSize

终点值end = pageSize*pageNo

数据库事务控制：ACID

A：Atomicity原子性。事务的各项操作都是要么全部成功，要么全部失败。江湖义气一点说：就是同生共死

C：Consistence:一致性。事务的执行结果应该从一个一致性状态到另一个一致性状态。例如存钱和取钱后金额总数保持不变。

I：Isolation：隔离性。并发执行的事务之间不会相互影响。比如多个用户同时向一个账户转钱，最后的结果应该和他们按先后顺序转钱的结果一样。

D：Duration：持久性。事务一旦提交，其对数据库的更新就是永久性的。

视图：

CREATE VIEW v_emp_11 AS
(SELECT empno,ename FROM emp_wpzhang WHERE deptno = 10);

1、什么是视图？

视图本质上就是一条select语句，可以像操作表一样操作视图；

基于单表建立的视图：简单视图和复杂视图。简单视图：是语句中不包含任何函数，表达式或group by ，order by等，复杂视图则可以包含这些。

基于多个表建立的视图：连接视图。

2、视图的作用？

可以简化复杂查询，基于复杂查询建立视图，查询视图即可

可以限制数据访问，视图本质是一条select语句，我们访问只能访问select涉及的列，对其他列具有保密的作用。

索引:

CREATE INDEX idx_emp_job_sal on emp_wpzhang(job,sal);
SELECT empno , job , sal FROM emp_wpzhang ORDER BY job,sal;

1、什么是索引？

索引是可以直接访问表中某一数据行的树形结构

2、索引的作用？

提高查询效率

3、“三要三不要”

要：
在where条件语句中创建索引；

在作为连接条件的列上创建索引；

在group by order by后面的字段创建索引；

不要：
不要在小表上创建索引；

不要在经常DML的字段上创建索引；

删除不必要的索引；

主键：

非空且唯一

外键：

用于保证两个表之间的关系

sql语句优化：

1、考虑到索引：应该尽量避免查询时引擎放弃索引进行全表扫描的状况

①尽量在order by ,group by ,where 子句上建立索引。

②尽量避免在where子句中使用!= , <>符号

③尽量减少用or连接条件：比如select id from emp where age = 18 or age = 19;应该改为：select id from emp where age = 18 union all select id from emp where age = 19;

④索引并不是越多越好，合理创建索引

⑤减少频繁地创建表删除表

2、分库分表：

垂直分库：

将数据根据业务耦合度，将关联度低的不同表存储到不同数据库。与“微服务治理类似”，每个微服务使用单独的数据库。（减少业务层面的耦合，业务清晰）

垂直分表：

垂直分表是根据数据库的列进行的。将表中字段过多或者字段过长进行垂直分表，通过大表拆小表更便于开发和维护，也能避免跨页问题。

但是任然存在数据量大的问题，此时就要考虑水平切分：

水平切分：

根据数值范围：时间区间来切分（缺点：数据热点成为性能瓶颈，旱的旱死，涝的涝死，有些近期存储的数据会被频繁的操作，而那些历史数据又会很少被访问。优点：扩容就扩容自己的表就好了不需要管其他的，定位也很好定位，找自己就行了）；根据数值取模；

3、数据库查询：

列转行：

info

year	month	account
1991	1	1.1
1991	2	2.1
1991	3	3.1
1991	4	4.1
1992	1	1.2
1992	2	2.2
1992	3	3.2
1992	4	4.2

year	m1	m2	m3	m4
1991	1.1	2.1	3.1	4.1
1992	1.2	2.2	3.2	4.2

查询语句：

SELECT info.account ,

(SELECT t.account FROM info WHERE t.month = 1 AND t.year = info.year )m1,//先看表，1.1要出现在那个位置，必须满足两个条件，第一：年份,第二：月份

(SELECT t.account FROM info WHEREt.month = 2 AND t.year = info.year)m2,

(SELECT t.account FROM info WHERE t.month = 3 AND t.year = info.year)m3,

(SELECT t.account FROM info WHERE t.month = 4 AND t.year = info.year)m4

FROM info

GROUP BY info.year;

web前端

bootstrap:

可以不用写css,js代码就可以有较漂亮的交互页面

简单说一下css元素分类：

块级元素，行内元素

js中选择器：

类选择器，元素选择器，id选择器，后代选择器（p strong{color:red;}）,子选择器（p>strong{font-size:30px;}）

jq中选择器：

类选择器，元素选择器，id选择器，表单选择器（：text 匹配文本框），过滤选择器（tr.children(“td:eq(0)”)）

什么是Ajax？

就是局部更新，不刷新整个页面。

使用场景？

比如登录失败不跳转页面，注册时提示用户名是否存在，修改表格中某个状态而不是修改整个表。

当页面加载完毕后执行里面的函数？

$(function(){

});

EL表达式：

作用：访问bean属性：${对象名.属性名}

eg：${user.age}

执行过程：容器会依次从pageContext,session,request,application中找到user的对象，找到后调用getAge()方法，然后输出：（属性名不能写错，否则会报错，对象名写错或者属性不存在都会出现空白页面，不会报错。）

JSTL:

核心标签：

<c:if test = ""//boolean表达式 var = ""//指定绑定名称 scope = ""//指定范围 ></c:if> 
<c:choose>
    <c:when test = " "></c:when>
    <c:otherwise test = " "></c:otherwise>
</c:choose>

//遍历集合和数组
<c:forEach var="accounts"//临时取的名字 items = "${account}"//遍历的集合或数组>
</c:forEach>