01面試題----英斯特

英斯特筆試：

1.進程和線程的區別

一個程序下至少有一個進程，一個進程下至少有一個線程，一個進程下也可以有多個線程來增加程序的執行速度。

 

2.線程的生命周期，多線程並發會有什么影響

當線程被創建並啟動以后，它既不是一啟動就進入了執行狀態，也不是一直處於執行狀態。 
在線程的生命周期中，它要經過新建(New)、就緒（Runnable）、運行（Running）、阻塞 (Blocked)和死亡(Dead)5種狀態。

多線程並發的影響：
多線程並發時會不安全，多線程同時操作對象的屬性或者狀態時，會因為線程之間的信息不同步，A線程讀取到的狀態已經過時，而A線程並不知道。

3.隊列和棧的特性。在什么實際案例中見過？

堆棧的特性：先進后出，后進先出
隊列的特性：先進先出，后進后出

　　

4.synchroized的作用，java中還有那些常用的鎖？

synchronized 它可以把任意一個非 NULL 的對象當作鎖。他屬於獨占式的悲觀鎖，同時屬於可重入鎖。
1. 作用於方法時，鎖住的是對象的實例(this)；
2. 當作用於靜態方法時，鎖住的是Class實例， 會鎖所有調用該方法的線程； 
3. synchronized 作用於一個對象實例時，鎖住的是所有以該對象為鎖的代碼塊。
Java中常見的鎖還有樂觀鎖、悲觀鎖、自旋鎖

5.synchronized 和 volatile 的區別是什么？

1.volatile本質是在告訴jvm當前變量在寄存器（工作內存）中的值是不確定的，需要從主存中讀取； synchronized則是鎖定當前變量，只有當前線程可以訪問該變量，其他線程被阻塞住。
2.volatile僅能使用在變量級別；synchronized則可以使用在變量、方法、和類級別的
3.volatile僅能實現變量的修改可見性，不能保證原子性；而synchronized則可以保證變量的修改可見性和原子性
4.volatile不會造成線程的阻塞；synchronized可能會造成線程的阻塞。
5.volatile標記的變量不會被編譯器優化；synchronized標記的變量可以被編譯器優化

6.spring的Bean的作用域和生命周期

Bean的作用域:單例(singleton)、原型（prototype）、請求（request）、會話（session）、全局會話（global session）	
Bean的生命周期流程：
1.首先容器啟動后，會對scope為singleton且非懶加載的bean進行實例化，
2.按照Bean定義信息配置信息，注入所有的屬性，
3.如果Bean實現了BeanNameAware接口，會回調該接口的setBeanName()方法，傳入該Bean的id，此時該Bean就獲得了自己在配置文件中的id，
4.如果Bean實現了BeanFactoryAware接口,會回調該接口的setBeanFactory()方法，傳入該Bean的BeanFactory，這樣該Bean就獲得了自己所在的BeanFactory，
5.如果Bean實現了ApplicationContextAware接口,會回調該接口的setApplicationContext()方法，傳入該Bean的ApplicationContext，這樣該Bean就獲得了自己所在的ApplicationContext，
6.如果有Bean實現了BeanPostProcessor接口，則會回調該接口的postProcessBeforeInitialzation()方法，
7.如果Bean實現了InitializingBean接口，則會回調該接口的afterPropertiesSet()方法，
8.如果Bean配置了init-method方法，則會執行init-method配置的方法，
9.如果有Bean實現了BeanPostProcessor接口，則會回調該接口的postProcessAfterInitialization()方法，
10.經過流程9之后，就可以正式使用該Bean了,對於scope為singleton的Bean,Spring的ioc容器中會緩存一份該bean的實例，而對於scope為prototype的Bean,
   每次被調用都會new一個新的對象，期生命周期就交給調用方管理了，不再是Spring容器進行管理了
11.容器關閉后，如果Bean實現了DisposableBean接口，則會回調該接口的destroy()方法，
12.如果Bean配置了destroy-method方法，則會執行destroy-method配置的方法，至此，整個Bean的生命周期結束。4

7.spring常用的六個注解以及作用

@Component(value)
配置類，當使用該注解時，SpringIOC會將這個類自動掃描成一個bean實例
不寫的時候，默認是類名，且首字母小寫
@Autowired
自動裝配，會根據類型尋找指定的Bean，required:表示假如說在bean目錄下找不到指定的注解還需不需要注入，默認是true 修改為false時，表示假如說沒有找到可以允許不注入。
@ImportResource({"classpath:xxx.xml"})
能夠讀取多個xml文件，這樣就可以引入多個xml定義的bean
@Service
標注於業務層組件上表示定義一個bean，自動根據所標注的組件名稱實例化一個首字母為小寫的bean。
@RequestBody
用來傳對象參數
@Resource
用來自動裝配Bean，激活一個命名資源的依賴注入。@Resource屬性name可以定義被自動裝配Bean的名稱

8.解釋什么是事務，多線程事務並發會產生哪些問題，簡述事務的四種隔離性

事務是應用程序中一系列嚴密的操作，所有操作必須成功完成，否則在每個操作中所作的所有更改都會被撤消。
也就是事務具有原子性，一個事務中的一系列的操作要么全部成功，要么一個都不做。 
事務的結束有兩種，當事務中的所以步驟全部成功執行時，事務提交。如果其中一個步驟失敗，將發生回滾操作，撤消撤消之前到事務開始時的所以操作。 

並發問題可歸納為以下幾類: 
A.丟失更新
B.臟讀
C.不可重復讀
D. 覆蓋更新
E.虛讀（幻讀）

事務的四種隔離性：
A.Serializable（串行化）：一個事務在執行過程中完全看不到其他事務對數據庫所做的更新
（事務執行的時候不允許別的事務並發執行。事務串行化執行，事務只能一個接着一個地執行，而不能並發執行。）。
B.Repeatable Read（可重復讀）：一個事務在執行過程中可以看到其他事務已經提交的新插入的記錄，但是不能看到其他其他事務對已有記錄的更新。
C.Read Commited（讀已提交數據）：一個事務在執行過程中可以看到其他事務已經提交的新插入的記錄，而且能看到其他事務已經提交的對已有記錄的更新。
D.Read Uncommitted（讀未提交數據）：一個事務在執行過程中可以看到其他事務沒有提交的新插入的記錄，而且能看到其他事務沒有提交的對已有記錄的更新。

9.什么是aop，spring的幾種通知方式

aop是面向切面編程，在整個系統中，動態橫向添加新的功能還不改變原來的業務流程的編程

spring的幾種通知方式：
1.前置通知（方法調用前通知）
2.后置通知（方法調用后正常返回的時候通知，可以獲取返回值，發生異常的時候不會執行）
3.最終通知（無論程序是否發生異常都會執行的）
4.異常通知（發生異常的執行）
5.環繞通知（方法執行的時候執行）

10.畫出jvm的內存運行圖並解釋其作用

首先Java源代碼文件(.java后綴)會被Java編譯器編譯為字節碼文件(.class后綴)，
然后由JVM中的類加載器加載各個類的字節碼文件，加載完畢之后，交由JVM執行引擎執行。
在整個程序執行過程中，JVM會用一段空間來存儲程序執行期間需要用到的數據和相關信息，
這段空間一般被稱作為Runtime Data Area（運行時數據區），也就是我們常說的JVM內存。
因此，在Java中我們常常說到的內存管理就是針對這段空間進行管理

　　

 

11.手寫快速排序算法

StreamApi
第一種排序:sorted()，自然排序
 @Test
    public void test8() {
        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
    }

第二種排序:sorted(Comparator com)-定制排序
public void test8() {
        List<String> list = Arrays.asList("qqq","aaa","bbb","ccc","ddd");
        list.stream().sorted().forEach(System.out::println);
       	deptList.stream().sorted((x,y) -> {
           if(x.getDeptno().equals(y.getDeptno())) {
               return x.getDname().compareTo(y.getDname());
           }else {
               return x.getLoc().compareTo(y.getLoc());
           }
        });
    }
// 第三種按Map排序

//創建一個Map，並填入數據

Map<String, Integer> codes = new HashMap<>();
codes.put("United States", 1);
codes.put("Germany", 49);
codes.put("France", 33);
codes.put("China", 86);
codes.put("Pakistan", 92);

// 按照Map的鍵進行排序
Map<String, Integer> sortedMap = codes.entrySet().stream() 
　　　　　　　　.sorted(Map.Entry.comparingByKey())
　　　　　　　　.collect(
　　　　　　　　Collectors.toMap(
　　　　　　　　Map.Entry::getKey, 
　　　　　　　　Map.Entry::getValue,
　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　LinkedHashMap::new
　　　　　　　　)
　　　　　　　　);

// 將排序后的Map打印
sortedMap.entrySet().forEach(System.out::println);
//按照value排序
　　Map<String, Integer> sortedMap2 = codes.entrySet().stream()
　　　　　　　　　　　　.sorted(Map.Entry.comparingByValue())
　　　　　　　　　　　　.collect(Collectors.toMap(
　　　　　　　　　　　　Map.Entry::getKey,
　　　　　　　　　　　　Map.Entry::getValue,
　　　　　　　　　　　　(oldVal, newVal) -> oldVal,
　　　　　　　　　　　　LinkedHashMap::new));

//排序以后打印

sortedMap2.entrySet().forEach(System.out::println);

　　

　　

12.手寫線程安全的單例模式

　　

https://www.runoob.com/design-pattern/singleton-pattern.html

//懶漢式，線程安全
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    　　if (instance == null) {  
       　　instance = new Singleton();  
    　　}  
    return instance;  
    }  
}

//餓漢式
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    　　return instance;  
    }  
} 

//雙檢鎖/雙重校驗鎖（DCL，即double-checked locking），JDK1.5起
public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        　　if (singleton == null) {  
           　　singleton = new Singleton();  
        　　}  
        }  
    }  
    return singleton;  
    }  
}

//登記式/靜態內部類
public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    　　return SingletonHolder.INSTANCE;  
    }  
}

//枚舉，JDK1.5起
public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
} 

經驗之談：一般情況下，不建議使用懶漢方式，建議使用餓漢方式。只有在要明確實現lazy loading 效果時，才會
使用登記方式。如果涉及到反序列化創建對象時，可以嘗試使用枚舉方式。如果有其他特殊的需求，可以考慮使用雙檢
鎖方式。

13.設計一個秒殺的結構圖

 

 

 

華為總部面試：
主要都是一些底層的東西，今天兩個華為項目組，大概的題目是。
①基本數據類型和他們包裝類之間（主要是有基本數據類型，為什么還要有包裝類，基本數據類型和包裝類在作為形參的時候有什么區別）
②jvm的內存模型【線程私有的線程共有的分別有哪些，分別存放什么，java8方法區改成了什么（改成了元數據區，又問他們有什么區別），什么又叫Java內存泄漏（怎么避免內存泄漏--主要是對象的引用類型）】，垃圾回收機制（新生代老年代的划分，他們分別用什么回收算法，常見的垃圾回收器，他們有什么特點，client和server模式下運行時他們的垃圾回收器是否相同（扯出來什么叫client，server模式，什么叫jit））。第二條很重要，兩個項目組都問了
③hashmap 在1.7和1.8的底層實現有什么區別，這些改進有什么優點（以及引申出的桶排序（最快的排序，犧牲內存，保證性能），紅黑樹他的整體結構，四個規則）兩個項目組都問了，第二個問的更深。
④spring通過bean創建對象時，怎么確保他的線程安全的
⑤由於我項目上寫了websocket，http和https的區別（主要就是后者的加密，他的加密是基於什么的），當兩個人之間通訊時，如何確保信息不會被偽造，篡改，截獲（主要可逆加密中的對稱加密和非對稱加密，以及他們之間的配合使用），還有就是信任鏈當中的證書問題。
⑥抽象類和接口的區別
⑦你使用過哪些線程安全的類，為什么他們是線程安全的，如果給你一個線程不安全的類，你怎么將他改成線程安全的。
⑧構建一個大致的vue
⑨執行一個jar中的某個方法怎么執行。(主要是有一個MANIFEST.MF文件，在這里面配置main class.然后通過java -jar abc.jar)
⑩一台服務器近期cpu和內存突然使用率變高，怎么排查。
①說一下單點登錄的具體實現
②我說我大學學過c和java，他問我java8有一個新特性叫lambda，他和c語言中的什么相似。

綠和：
1.幾年工作經驗？

2年

 

2.用的什么框架？

spring boot微服架構

 

3.是不是前后端分離

是前后端分離

 

4.用不用vue？用的話常用的指令有哪些？

用vue

v-if指令:是條件渲染指令，它根據表達式的真假來刪除和插入元素
語法：v-if="expression"

v-show指令：顯示內容 （同angular中的ng-show）

v-else指令：必須和v-if連用  不能單獨使用  否則報錯   模板編譯錯誤

v-for指令：v-for指令基於一個數組渲染一個列表，它和JavaScript的遍歷語法相似
語法：v-for="item in items"

v-bind指令： v-bind 指令可以在其名稱后面帶一個參數，中間放一個冒號隔開，這個參數通常是HTML元素的特性（attribute）
語法：v-bind:argument="expression"

v-model：v-model（表單元素設置了之后會忽略掉value，checked，selected），常用在表單 <input> 及 <textarea>，讓表單元素和數據實現雙向綁定（映射關系）

v-on指令：v-on 指令用於給監聽DOM事件，它的用語法和v-bind是類似的，例如監聽<a>元素的點擊事件：<a v-on:click="doSomething">

v-text指令： v-text指令主要是防止頁面首次加載時 {{}} 出現在頁面上。將對象中數據變量值顯示在綁定的標簽內容上。
語法：v-text="expresstion"

 

5.js和jq熟悉嗎

熟悉，兩者區別如下
1、本質上的區別
jQuery是一個JavaScript函數庫。jQuery就是基於JavaScript語言寫出來的一個框架,實質上還是JavaScript而已。

2、代碼書寫的不同
jQuery 極大地簡化了 JavaScript 編程，jQuery代碼比沉重的JavaScript輕靈多了，jquery設計的初衷就是要用更少的代碼，漂亮的完成更多的功能。

3、在使用方法上的不同
（1）使用JavaScript和jQuery分別加載DOM：
JavaScript只會執行一次，而jQuery會執行多次。
（2）使用JavaScript和jQuery獲取class方法：
JavaScript沒有默認的獲取class的方法 ，而JQuery， 可以通過$('.className') 調用class的方法。

 

6.springmvc工作流程

工作原理：
1、  用戶發送請求至前端控制器DispatcherServlet。

2、  DispatcherServlet收到請求調用HandlerMapping映射器。

3、  映射器找到具體的處理器(可以根據xml配置、注解進行查找)，生成對象及攔截器一並返回給DispatcherServlet。

4、  DispatcherServlet調用HandlerAdapter適配器。

5、  HandlerAdapter經過適配調用具體的處理器Controller（后端控制器)。

6、  Controller執行完成返回ModelAndView。

7、  HandlerAdapter將controller執行結果ModelAndView返回給DispatcherServlet。

8、  DispatcherServlet將ModelAndView傳給ViewReslover視圖解析器。

9、  ViewReslover解析后返回具體View。

10、DispatcherServlet根據View進行渲染視圖（即將模型數據填充至視圖中）。

11、 DispatcherServlet響應用戶。

 

7.ArrayList和LinkedList的區別

共性：ArrayList與LinkedList都是List接口的實現類，因此都實現了List的所有未實現的方法，只是實現的方式有所不同。

區別：List接口的實現方式不同

ArrayList實現了List接口，以數組的方式來實現的，因此對於快速的隨機取得對象的需求，使用ArrayList實現執行效率上會比較好。

LinkedList是采用鏈表的方式來實現List接口的，因此在進行insert和remove動作時效率要比ArrayList高。適合用來實現Stack(堆棧)與Queue(隊列)。

 

8.redis支持的數據類型

Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

 

9.線程問題

概念：一個程序可以有多條執行線索同時執行，一個線程就是程序中的一條執行線索，
         獨立運行的基本單位。

狀態：
新建狀態：執行new()方法
就緒狀態：執行start()方法
運行狀態：執行run()方法，獲取CPU資源
阻塞狀態：執行sleep()，讓出CPU資源
死亡狀態：可用stop()和destroy()強制終止

實現線程方式：繼承Thread類，實現Runnable接口 ，實現Callable接口
  join()：線程插隊 

sleep()和wait()區別：
sleep()是Thread類的方法，讓出cpu,cpu去執行其他線程，會自動恢復。
wait()是Object類的方法，讓出同步鎖給等待此鎖的線程，不會自動恢復。

run()和start()區別：
run()是讓該線程所關聯的執行代碼（一個線程必須管理具體的執行代碼）。
start()是啟動一個線程，使線程就緒狀態。

最佳線程數目=（（線程等待時間+線程CPU時間）/線程CPU時間）*CPU數目
（線程等待時間占比越高，需要越多線程，CPU時間占比越高，需要越少線程）

 

10.vue的路由

前端路由和后端路由：

后端路由：對於普通的網站，所有的超鏈接都是url地址，所有url都對應服務器上對應的資源
前端路由：對於單頁面應用程序來說，主要通過url的hash（#）來實現不同頁面的切換，同時hash還有一個特點HTTP請求中不會包含hash相關的內容，所以單頁面程序中的頁面跳轉主要用hash實現
在單頁面應用程序中這種通過hash來改變頁面的方式稱作前端路由區別於后端路由

 

11.為什么用elk+kafka

因為單純的使用elk 日志收集，進行io讀取，容易數據丟失，logstash太多了，擴展不好。非實時性。

 

12.mycat分了哪些表

1. 分庫表
表示表的數據存放在多個實際的數據庫中，按照一定的規則決定將某條數據存放在某一個數據庫的表中；
添加數據時，根據分庫規則決定添加到哪個實際數據庫表中；
更新和刪除數據時，首先定位到數據在哪個實際的數據庫表中，然后再進行修改；
查詢數據時，從映射的每個數據庫中查詢符合條件的記錄，然后聚合以后返回結果；
存在分庫規則，比如rule="auto-sharding-long"

2. 全局表
在每個數據庫中都存放了該表的一個副本；
在添加和修改、刪除數據時，在每個實際數據庫表中都進行添加，操作完成后，每個數據庫表的內容仍然相同；
在查詢數據庫表時，隨機選擇一個實際數據庫表中的數據來返回；
用type="global"來標識。

3. 一對一映射表
一個mycat中的邏輯表映射到一個實際的數據庫表，邏輯表與物理表之間是1對1映射的；

 

13.Rabbitmq怎么實現的

RabbitMQ使用以及原理解析

RabbitMQ是一個實現了AMQP（Advanced Message Queuing Protocol）高級消息隊列協議的消息隊列服務，用的是Erlang語言。
幾個概念說明:
Broker:它提供一種傳輸服務,它的角色就是維護一條從生產者到消費者的路線，保證數據能按照指定的方式進行傳輸,
Exchange：消息交換機,它指定消息按什么規則,路由到哪個隊列。
Queue:消息的載體,每個消息都會被投到一個或多個隊列。
Binding:綁定，它的作用就是把exchange和queue按照路由規則綁定起來.
Routing Key:路由關鍵字,exchange根據這個關鍵字進行消息投遞。
vhost:虛擬主機,一個broker里可以有多個vhost，用作不同用戶的權限分離。
Producer:消息生產者,就是投遞消息的程序.
Consumer:消息消費者,就是接受消息的程序.
Channel:消息通道,在客戶端的每個連接里,可建立多個channel.

 

易九：
介紹項目
找一個模塊的業務邏輯講一下
介紹一下中台架構
Es是什么

拜客科技：
Final

修飾類，類不能被繼承

修飾變量，變量變成常量，只能被賦值一次，一般會與public static共用

修飾方法，方法不能被重寫

Final修飾對象，該對象不能再指向其他引用，換句話，該對象不能再接受new對象的賦值情況

　　

1.接口和抽象

(1)接口的特點：

 接口的關鍵字：interface

a.所有的方法都是用public abstract 修飾的。(不寫也默認有)

b.接口不能實例化

c.實現類必須實現接口的所有方法

d.實現類可以實現多個接口（java中的"多繼承"的關系）

e.所有的變量都是使用public static final 修飾的(靜態常量)。

 

 (2)接口用的是什么協議

a.HTTP  超文本傳輸協議

b.HTTPS  安全超文本傳輸協議

c.FTP  文件傳輸協議( Xshell的文件拖拽)

d.TCP 網絡控制協議

e.IP  互聯網協議

f.UDP  用戶數據協議

 

(3) java中抽象類的特點：

a.抽象類可以定義構造函數

b.抽象類可以聲明和使用字段

c.如果一個類中有抽象方法，那么這個類一定是抽象類

d.抽象類中可以存在普通屬性、方法、靜態屬性和靜態方法

e.抽象類中不一定有抽象方法

f.抽象類中的抽象方法需要有子類實現，如果子類不實現，則子類也需要定義為抽象的

 

(4) 區別:

a.抽象類可以聲明和使用字段；接口則不能，但是可以創建靜態的final常量

b.抽象類可以定義構造函數，接口不能

c.抽象類中的方法可以是public、protected、private或者默認的package；接口的方法都是public（不管是否聲明，接口都是公開的）

d.java接口中聲明的變量默認都是final的，抽象類可以包含非final變量

e.抽象類可以在不提供接口方法實現的情況下實現接口

f.接口是絕對抽象的，不可以被實例化。抽象類也不可以被實例化，但是如果它包含main方法的話是可以被調用的

 

2.String能被繼承嗎，為什么

不能被繼承，因為String類有final修飾符，而final修飾的類是不能被繼承的。

3.流

1.按流向區分：輸出流： OutputStream,Writer 基類
           輸入流： InputSteam,Reader   基類
2.數據單元分：字節流： 字節輸入流InputStream，字節輸出流OutputStream
           字符流： 字符輸入流Reader，字符輸出流Writer

 

4.throws和throw的區別

throws：用來聲明一個方法可能產生的所有異常，不做任何處理而是將異常往上傳，誰調用我我就拋給誰。
  用在方法聲明后面，跟的是異常類名
  可以跟多個異常類名，用逗號隔開
  表示拋出異常，由該方法的調用者來處理
  throws表示出現異常的一種可能性，並不一定會發生這些異常
throw：則是用來拋出一個具體的異常類型。
  用在方法體內，跟的是異常對象名
  只能拋出一個異常對象名
  表示拋出異常，由方法體內的語句處理
  throw則是拋出了異常，執行throw則一定拋出了某種異常  

5.事務的實現

（1）編程式事務管理對基於 POJO 的應用來說是唯一選擇。我們需要在代碼中調用beginTransaction()、commit()、rollback()等事務管理相關的方法，這就是編程式事務管理。
（2）基於 TransactionProxyFactoryBean的聲明式事務管理
（3）基於 @Transactional 的聲明式事務管理
（4）基於Aspectj AOP配置事務

 

6.Mybatis延時原理

使用CGLIB創建目標對象的代理對象，當調用目標方法時，進入攔截器方法，
比如調用a.getB().getName()，攔截器invoke()方法發現a.getB()是null值，
那么就會單獨發送事先保存好的查詢關聯B對象的sql，把B查詢上來，然后調用a.setB(b)，
於是a的對象b屬性就有值了，接着完成a.getB().getName()方法的調用。這就是延遲加載的基本原理。

 

7.數據庫優化，回答了之后，他會問他就要在where中對字段進行null判斷怎么解決

數據庫優化：

1、在表中建立索引，優先考慮where、group by使用到的字段。

2、盡量避免使用select *，返回無用的字段會降低查詢效率。如下：

SELECT * FROM t 

優化方式：使用具體的字段代替*，只返回使用到的字段。
 

3、盡量避免使用in 和not in，會導致數據庫引擎放棄索引進行全表掃描。如下：

SELECT * FROM t WHERE id IN (2,3)

SELECT * FROM t1 WHERE username IN (SELECT username FROM t2)

優化方式：如果是連續數值，可以用between代替。如下：

SELECT * FROM t WHERE id BETWEEN 2 AND 3

如果是子查詢，可以用exists代替。如下：

SELECT * FROM t1 WHERE EXISTS (SELECT * FROM t2 WHERE t1.username = t2.username)
 

4、盡量避免使用or，會導致數據庫引擎放棄索引進行全表掃描。如下：

SELECT * FROM t WHERE id = 1 OR id = 3

優化方式：可以用union代替or。如下：

SELECT * FROM t WHERE id = 1
UNION
SELECT * FROM t WHERE id = 3

（PS：如果or兩邊的字段是同一個，如例子中這樣。貌似兩種方式效率差不多，即使union掃描的是索引，or掃描的是全表）

 

5、盡量避免在字段開頭模糊查詢，會導致數據庫引擎放棄索引進行全表掃描。如下：

SELECT * FROM t WHERE username LIKE '%li%'

優化方式：盡量在字段后面使用模糊查詢。如下：

SELECT * FROM t WHERE username LIKE 'li%'


6、盡量避免進行null值的判斷，會導致數據庫引擎放棄索引進行全表掃描。如下：------------------where中對字段進行null判斷怎么解決？

SELECT * FROM t WHERE score IS NULL

優化方式：可以給字段添加默認值0，對0值進行判斷。如下：

SELECT * FROM t WHERE score = 0

 

7、盡量避免在where條件中等號的左側進行表達式、函數操作，會導致數據庫引擎放棄索引進行全表掃描。如下：

SELECT * FROM t2 WHERE score/10 = 9

SELECT * FROM t2 WHERE SUBSTR(username,1,2) = 'li'

優化方式：可以將表達式、函數操作移動到等號右側。如下：

SELECT * FROM t2 WHERE score = 10*9

SELECT * FROM t2 WHERE username LIKE 'li%'


8、當數據量大時，避免使用where 1=1的條件。通常為了方便拼裝查詢條件，我們會默認使用該條件，數據庫引擎會放棄索引進行全表掃描。如下：

SELECT * FROM t WHERE 1=1

優化方式：用代碼拼裝sql時進行判斷，沒where加where，有where加and。

8.Dubbo功能

9.Dubbo怎么部署，幾種方式

 

方式：
1、 使用web容器（Tomcat、Jetty等）啟動dubbo服務 ：
增加端口管理復雜性， tomcat/jetty等都需要占用端口，dubbo服務也需要端口；浪費資源（內存），單獨啟動 tomcat，jetty占用內存大
運用：需要提供web服務的模塊，一般dubbo client可以使用這種方式部署

2、使用自建Main方法類運行spring容器啟動dubbo服務：Dobbo提供的優雅停機高級特性沒用上，並且自已編寫啟動類可能會有缺陷
運用：在開發階段測試dubbo server可以使用這種方式

3、使用Dubbo框架提供的Main方法類運行Spring容器啟動服務：官方建議使用，dubbo框架本身提供啟動類（com.alibaba.dubbo.container.Main），可實現優雅關機，打包的時候使用maven打成普通的jar包就可以了。
運用：生產上dubbo server可以用這種方式部署。
————————————————
版權聲明：本文為CSDN博主「HsiunKao」的原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/growdane/article/details/84639182

 

10.Redis支持的數據類型，在什么情況下用
11.Reids的持久化，怎么實現
12.並行與並發的區別
13.什么是死鎖
14.怎么防止死鎖
15.同步關鍵字的實現原理
16.Springboot的注解，和里面包含的注解以及作用
17.Sleep和wait的區別
18.#{}和${}區別
19.Struts
20.自己設計一個shiro流程

一些筆試題：
1.有n個整數，使其前面各數順序向后移m個位置，最后m個數變成最前面的m個數

 

import java.util.Scanner;
public class lianxi36 {
public static void main(String[] args) {
   int N =10;
   int[] a = new int[N];
   Scanner s = new Scanner(System.in);
   System.out.println("請輸入10個整數：");
   for(int i=0; i<N; i++) {
    a[i] = s.nextInt();
   }
   System.out.print("你輸入的數組為：");
   for(int i=0; i<N; i++) {
     System.out.print(a[i] + " ");
   }
   System.out.print("\n請輸入向后移動的位數：");
   int m = s.nextInt();
   int[] b = new int[m];
   for(int i=0; i<m; i++) {
    b[i] = a[N-m+i];
   }
   for(int i=N-1; i>=m; i--) {
   a[i] = a[i-m];
   }
   for(int i=0; i<m; i++) {
    a[i] = b[i];
   }
System.out.print("位移后的數組是：");
   for(int i=0; i<N; i++) {
    System.out.print(a[i] + " ");
   }
}
}

 

 

 

2.給定一個整數N，按以下模式打印2*N行。如果N=4則
1
2*3
4*5*6
7*8*9*10
7*8*9*10
4*5*6
2*3
1
輸入：n—>表示行數的整數
輸出：按指定行數打印出該模式

public class printmatrix {

    public static int helper[] = new int[100];

    public static void calc(int n){
        if(n==1){
            helper[n]=1;
            return;
        }
        if(helper[n-1]==0)
            calc(n-1);
        helper[n] = helper[n-1]+n;
    }

    public static void printNum(int n){
        if(helper[n]==0){
            calc(n);
        }
        String[] strs = new String[n+1];
        int row = 1;
        for(;row<=n;row++){
            String str = new String();
            for(int i=helper[row-1]+1;i<=helper[row];i++){
                if(!str.equals(""))str+='*';
                str += i;
            }
            strs[row] = str;
        }
        for(String str : strs){
            if(str==null)continue;
            System.out.println(str);
        }
        for(int i=n;i>0;i--){
            System.out.println(strs[i]);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        printmatrix.printNum(4);
    }
}

3.談談你對webService的看法

WebService，顧名思義就是基於Web的服務。它使用Web(HTTP)方式，接收和響應外部系統的某種請求。從而實現遠程調用

 

4.談談你對存儲過程的看法

我理解的存儲過程就是預先定義好的SQL語句，然后存儲起來，等你用的時候再把自己所需要的匹配的SQL語句用Execute(即exec)調用就行！

5.已知表（Sales）

 

1>寫出求每個Company的Amout的合計在10000以上的數據的SQL語句。
2>過濾掉Company、Amout重復的數據。只保留一條。以上述數據為例。執行結果應該為：

6.如下代碼有錯么？錯在哪里？請說明情況。
List list=null；
System.out.println(list.length);

null沒有 .size()
你可以 List<object> aa= new List<object>(); (C#語言，java類似）
就是意思是new一個list對象 這樣.size()就可以用了

7.談談你對java集合類的看法。List，Set，Map是否繼承自Collection接口？

Collection是最基本的集合接口，聲明了適用於JAVA集合（只包括Set和List）的通用方法。 
Set 和List 都繼承了Conllection；Set具有與Collection完全一樣的接口，因此沒有任何額外的功能，不像前面有兩個不同的List。
實際上Set就是Collection,只 是行為不同。(這是繼承與多態思想的典型應用：表現不同的行為。)Set不保存重復的元素(至於如何判斷元素相同則較為負責) 
Map沒有繼承於Collection接口 從Map集合中檢索元素時，只要給出鍵對象，就會返回對應的值對象。 

 

8.abstract class 和 interface有什么區別？

1. 抽象類可以有構造方法，接口不能有構造方法 
2. 抽象類中可以有普通成員變量，接口中沒有普通成員變量 
3. 抽象類中可以包含非抽象的普通方法，接口中的所有方法必須是抽象的，不能有非抽象的普通方法 
4. 抽象類中抽象方法的訪問類型可以是public，protected和默認類型雖然（eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public類型，並且默認即為public abstract類型 
5. 抽象類中可以包含靜態方法，接口中不能包含靜態方法 
6. 抽象類和接口中都可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型可以任意，但接口中定義的變量只能是public static final類型，並且默認即為public static final類型 
7. 一個類可以實現多個接口，但只能繼承一個抽象類

9.啟動一個線程使用run()還是start()？

啟動線程肯定要用start()方法。當用start()開始一個線程后，線程就進入就緒狀態，使線程所代表的虛擬處理機處於可運行狀態，
這意味着它可以由JVM調度並執行。這並不意味着線程就會立即運行。當cpu分配給它時間時，才開始執行run()方法(如果有的話)。
start()是方法,它調用run()方法.而run()方法是你必須重寫的. run()方法中包含的是線程的主體。 

10.應用服務器有哪些？

根據確定文檔內容的時間，所有文檔可以划分為靜態Web文檔、動態web文檔和活動文檔。常用的Web應用服務器有：nginx、Apache、Tomcat、WebLogic、Resin、Glassfish、JBoss、WebSphere等等。

11.如何理解transaction事務的概念？

事務（transaction）的概念與特性
    事務是一系列操作，這些操作組成了一個邏輯工作單元。這個邏輯工作
    單元中的操作作為一個整體，要么全部成功，要么全部失敗。
    事務的特性（ACID）：
    1.原子性（Atomicity）：
      事務中的一系列操作作為一個原子性的邏輯工作單元，這個邏輯工作
      單元中的操作要么全部成功，要么全部失敗。
    2.一致性（Consistency）：
      事務操作之前與操作之后數據庫系統的數據狀態是從一種一致性狀態
      轉換到另一種一致性狀態。
    3.隔離性(Isolation)
      多個事務並發執行時，互相不能看到對方的操作過程。
    4.持久性（Durability）
      一旦事務執行成功，對數據庫系統的影響是持久性的。

12.String時最基本的數據類型嗎？String和StringBuffer的區別？

String不是基本的數據類型
（1）String:是對象不是原始類型.為不可變對象,一旦被創建,就不能修改它的值.對於已經存在的String對象的修改都是重新創建一個新的對象,然后把新的值保存進去.String 是final類,即不能被繼承
（2）StringBuffer:是一個可變對象,當對他進行修改的時候不會像String那樣重新建立對象。它只能通過構造函數來建立對象被建立以后,在內存中就會分配內存空間,並初始保存一個null.
　　 向StringBuffer中付值的時候可以通過它的append方法.

13.int 和 Integer有什么區別？

1、Integer是int的包裝類，int則是java的一種基本數據類型 
2、Integer變量必須實例化后才能使用，而int變量不需要 
3、Integer實際是對象的引用，當new一個Integer時，實際上是生成一個指針指向此對象；而int則是直接存儲數據值 
4、Integer的默認值是null，int的默認值是0

14.運行時異常與一般異常有何異同？

異常表示程序運行過程中可能出現的非正常狀態，

運行時異常：表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，
但是並不要求必須聲明拋出未被捕獲的運行時異常。

一般異常：java編譯器強制要求我們必需對出現的異常進行try…catch…處理的否則程序不能通過編譯

15.說出Servlet的生命周期，並說出Servlet和CGI的區別？

Servlet的生命周期分為5個階段:
實例化：Servlet容器創建Servlet類的實例。
初始化：該容器調用init()方法，通常會申請資源。
服務：由容器調用service()方法，（也就是doGet()和doPost()）。
破壞：在釋放Servlet實例之前調用destroy()方法，通常會釋放資源。
不可用：釋放內存的實例。
CGI（Common Gateway Interface通用網關接口）程序來實現數據在Web上的傳輸，使用的是如Perl這樣的語言編寫的，它對於客戶端作出的每個請求，
必須創建CGI程序的一個新實例，這樣占用大量的內存資源。由此才引入了Servlet技術。
Servlet是一個用java編寫的應用程序，在服務器上運行，處理請求信息並將其發送到客戶端。對於客戶端的請求，只需要創建Servlet的實例一次，因此節省了大量的內存資源。
Servlet在初始化后就保留在內存中，因此每次作出請求時無需加載。

16.說出ArrayList，Vector，LinkedList的存儲性能和特性

ArrayList和Vector都是使用數組方式存儲數據，此 數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，
但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據 慢，Vector由於使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，
按序號索引數據需要進行前向或后向遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入速度較快。
一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的
二.數據增長:當需要增長時,Vector 默認增長為原來一培，而ArrayList卻是原來的一半

17.條件：
學生表student：學號sno，姓名name
課程成績表student_score：學號sno，學科stype，分數score
(1)查詢所有同學的學生編號，學生姓名，選課總數，所有課程的總成績
(2)檢索“01”課程分數小於60，按分數降序排列的學生信息
(3)查詢至少有一門課與學號為"01"的同學所學相同的同學的信息
編寫新增學生信息的rest接口，包括用到的注解
(1).controller
(2).service
(3).dao
(4).xml,sql層

------------恢復內容結束------------

英斯特筆試：
1.進程和線程的區別

進程:是系統進行分配和管理資源的基本單位

線程:進程的一個執行單元, 是進程內調度的實體、是CPU調度和分派的基本單位, 是比進程更小的獨立運行的基本單位。線程也被稱為輕量級進程, 線程是程序執行的最小單位。

 一個程序至少一個進程, 一個進程至少一個線程。

 進程有自己的獨立地址空間, 每啟動一個進程, 系統就會為它分配地址空間, 建立數據表來維護代碼段、堆棧段和數據段， 這種操作非常昂貴。

而線程是共享進程中的數據的, 使用相同的地址空間, 因此CPU切換一個線程的花費遠比進程要小很多, 同時創建一個線程的開銷啊也比進程要小很多。

 線程之間的通信更方便, 同一進程下的線程共享全局變量、靜態變量等數據, 而進程之間的通信需要以通信的方式進行。

 如何處理好同步與互斥是編寫多線程程序的難點。

 多進程程序更健壯, 進程有獨立的地址空間, 一個進程崩潰后, 在保護模式下不會對其它進程產生影響,

而線程只是一個進程中的不同執行路徑。線程有自己的堆棧和局部變量, 但線程之間沒有獨立的空間, 所以可能一個線程出現問題, 進而導致整個程序出現問題

 

2.線程的生命周期，多線程並發會有什么影響
3.隊列和棧的特性。在什么實際案例中見過？
4.synchroized的作用，java中還有那些常用的鎖？
5.synchronized 和 volatile 的區別是什么？
6.spring的Bean的作用域和生命周期
7.spring常用的六個注解以及作用
8.解釋什么是事務，多線程事務並發會產生哪些問題，簡述事務的四種隔離性
9.什么是aop，spring的幾種通知方式
10.畫出jvm的內存運行圖並解釋其作用
11.手寫快速排序算法
12.手寫線程安全的單例模式
13.設計一個秒殺的結構圖

 

 

 

華為總部面試：
主要都是一些底層的東西，今天兩個華為項目組，大概的題目是。
①基本數據類型和他們包裝類之間（主要是有基本數據類型，為什么還要有包裝類，基本數據類型和包裝類在作為形參的時候有什么區別）
②jvm的內存模型【線程私有的線程共有的分別有哪些，分別存放什么，java8方法區改成了什么（改成了元數據區，又問他們有什么區別），什么又叫Java內存泄漏（怎么避免內存泄漏--主要是對象的引用類型）】，垃圾回收機制（新生代老年代的划分，他們分別用什么回收算法，常見的垃圾回收器，他們有什么特點，client和server模式下運行時他們的垃圾回收器是否相同（扯出來什么叫client，server模式，什么叫jit））。第二條很重要，兩個項目組都問了
③hashmap 在1.7和1.8的底層實現有什么區別，這些改進有什么優點（以及引申出的桶排序（最快的排序，犧牲內存，保證性能），紅黑樹他的整體結構，四個規則）兩個項目組都問了，第二個問的更深。
④spring通過bean創建對象時，怎么確保他的線程安全的
⑤由於我項目上寫了websocket，http和https的區別（主要就是后者的加密，他的加密是基於什么的），當兩個人之間通訊時，如何確保信息不會被偽造，篡改，截獲（主要可逆加密中的對稱加密和非對稱加密，以及他們之間的配合使用），還有就是信任鏈當中的證書問題。
⑥抽象類和接口的區別
⑦你使用過哪些線程安全的類，為什么他們是線程安全的，如果給你一個線程不安全的類，你怎么將他改成線程安全的。
⑧構建一個大致的vue
⑨執行一個jar中的某個方法怎么執行。(主要是有一個MANIFEST.MF文件，在這里面配置main class.然后通過java -jar abc.jar)
⑩一台服務器近期cpu和內存突然使用率變高，怎么排查。
①說一下單點登錄的具體實現
②我說我大學學過c和java，他問我java8有一個新特性叫lambda，他和c語言中的什么相似。

綠和：
1.幾年工作經驗？
2.用的什么框架？
3.是不是前后端分離
4.用不用vue？用的話常用的指令有哪些？
5.js和jq熟悉嗎
6.springmvc工作流程
7.ArrayList和LinkedList的區別
8.redis支持的數據類型
9.線程問題
10.介紹一下項目
11.vue的路由
12.為什么用elk+kafka
13.mycat分了哪些表
14.Rabbitmq怎么實現的

易九：
介紹項目
找一個模塊的業務邏輯講一下
介紹一下中台架構
Es是什么

拜客科技：
Final
1.接口和抽象
2.String能被繼承嗎，為什么
3.流
4.異常和throw的區別
5.事務的實現
6.Mybatis延時原理
7.數據庫優化，回答了之后，他會問他就要在where中對字段進行null判斷怎么解決
8.Dubbo功能
9.Dubbo怎么部署，幾種方式
10.Redis支持的數據類型，在什么情況下用
11.Reids的持久化，怎么實現
12.並行與並發的區別
13.什么是死鎖
14.怎么防止死鎖
15.同步關鍵字的實現原理
16.Springboot的注解，和里面包含的注解以及作用
17.Sleep和wait的區別
18.#{}和${}區別
19.Struts
20.自己設計一個shiro流程

一些筆試題：
1.有n個整數，使其前面各數順序向后移m個位置，最后m個數變成最前面的m個數
2.給定一個整數N，按以下模式打印2*N行。如果N=4則
1
2*3
4*5*6
7*8*9*10
7*8*9*10
4*5*6
2*3
1
輸入：n—>表示行數的整數
輸出：按指定行數打印出該模式
3.談談你對webService的看法
4.談談你對存儲過程的看法
5.已知表（Sales）

 

1>寫出求每個Company的Amout的合計在10000以上的數據的SQL語句。
2>過濾掉Company、Amout重復的數據。只保留一條。以上述數據為例。執行結果應該為：

6.如下代碼有錯么？錯在哪里？請說明情況。
List list=null；
System.out.println(list.length);
7.談談你對java集合類的看法。List，Set，Map是否繼承自Collection接口？
8.abstract class 和 interface有什么區別？
9.啟動一個線程使用run()還是start()？
10.應用服務器有哪些？
11.如何理解transaction事務的概念？
12.String時最基本的數據類型嗎？String和StringBuffer的區別？
13.int 和 Integer有什么區別？
14.運行時異常與一般異常有何異同？
15.說出Servlet的生命周期，並說出Servlet和CGI的區別？
16.說出ArrayList，Vector，LinkedList的存儲性能和特性
17.條件：
學生表student：學號sno，姓名name
課程成績表student_score：學號sno，學科stype，分數score
(1)查詢所有同學的學生編號，學生姓名，選課總數，所有課程的總成績
(2)檢索“01”課程分數小於60，按分數降序排列的學生信息
(3)查詢至少有一門課與學號為"01"的同學所學相同的同學的信息
編寫新增學生信息的rest接口，包括用到的注解
(1).controller
(2).service
(3).dao
(4).xml,sql層