最近面試題總結10.12

時間  2019-12-02
標籤 最近 面試 總結 10.12 欄目 快樂工作 简体版
原文   原文鏈接

1.java基本數據類型：
html

 

 

 

先說明兩個詞彙的基本概念：
bit （位）：位是計算機中存儲數據的最小單位，指二進制數中的一個位數，其值爲「0」或「1」。java

byte （字節）：字節是計算機存儲容量的基本單位，一個字節由8位二進制數組成。在計算機內部，一個字節能夠表示一個數據或者一個英文字母，可是一個漢字須要兩個字節表示。
1B＝8bit 
1Byte=8bit
1KB=1024Byte(字節)=8*1024bit
1MB=1024KB
1GB=1024MB
1TB=1024GBmysql

 

 

 

第二類、浮點數類型
float:單精度類型，32 位，後綴 F 或 f，1 位符號位，8 位指數，23 位有效尾數。算法

double：64 位，最經常使用，後綴 D 或 d，1 位符號位，11 位指數，52 位有效尾數。sql

java浮點型默認爲double型，因此要聲明一個變量爲float型時，須要在數字後面加F或者f：數據庫

例如：double d = 88888.8;      float f = 88888.8f;  //不加f的話會報錯
數組

 

第三類、字符類型安全

char:16位，java字符使用Unicode編碼，性能優化

第四類、布爾類型服務器

boolean：true 真  和 false 假

 

 

 簡單數據類型之間的轉換
   在Java中整型、實型、字符型被視爲簡單數據類型，這些類型由低級到高級分別爲

(byte，short，char)--int--long--float--double

更多可看：http://www.javashuo.com/article/p-rsvrhzgw-bc.html

 

 

2.工廠模式有什麼好處？

 工廠模式的做用，爲何要用工廠模式？

　　工廠模式是爲了解耦：把對象的建立和使用的過程分開。就是Class A 想調用Class B,那麼只是調用B的方法，而至於B的實例化，就交給工廠類。

　　工廠模式能夠下降代碼重複。若是建立B過程都很複雜，須要必定的代碼量，並且不少地方都要用到，那麼就會有不少的重複代碼。能夠把這些建立對象B的代碼放到工廠裏統一管理。既減小了重複代碼，也方便之後對B的維護。

工廠模式能夠減小錯誤，由於工廠管理了對象的建立邏輯，使用者不須要知道具體的建立過程，只管使用便可，減小了使用者由於建立邏輯致使的錯誤。

 

工廠模式的一些適用場景：

 　　對象的建立過程/實例化準備工做很複雜，須要不少初始化參數，查詢數據庫等

　　類自己有好多子類，這些類的建立過程在業務中容易發生改變，或者對類的調用容易發生改變

　　能夠參考，計算器例子。

 

3.二維數組的初始化

int [][] a=new int[][]{{1,2,3},{2,3}};

int [][] a=new int[4][4];

int [][]a=new int[3][];

 

4.一維數組初始化

 int[] arr = new int[3];

int[] arr = null; 

int[] arr = {1, 2, 3};

int[] arr = new int[]{1, 2, 3};

 

5.多態：

 多態是同一個行爲具備多個不一樣表現形式或形態的能力。

　　它包括兩種類型：
　　　　靜態多態性：包括變量的隱藏、方法的重載(指同一個類中，方法名相同[方便記憶]，可是方法的參數類型、個數、次序不一樣，本質上是多個不一樣的方法)；
　　　　動態多態性：是指子類在繼承父類(或實現接口)時重寫了父類(或接口)的方法，程序中用父類(或接口)引用去指向子類的具體實例，從代碼形式上看是父類(或接口)引用去調用父類(接口)的方法，可是在實際運行時，JVM可以根據父類(或接口)引用所指的具體子類，去調用對應子類的方法，從而表現爲不一樣子類對象有多種不一樣的形態。

 

多態的優勢

  • 1. 消除類型之間的耦合關係
  • 2. 可替換性
  • 3. 可擴充性
  • 4. 接口性
  • 5. 靈活性
  • 6. 簡化性

多態存在的三個必要條件

  • 繼承
  • 重寫
  • 父類引用指向子類對象

 

6.封裝：

　　封裝的好處：

  1. 封裝能夠隱藏實現的細節
  2. 讓使用者只能經過實現寫好的訪問方法來訪問這些字段，這樣一來咱們只須要在這些方法中增長邏輯控制，限制對數據的不合理訪問、
  3. 方便數據檢查，有利於於保護對象信息的完整性
  4. 便於修改，提升代碼的可維護性

 

實現封裝的方式:使用訪問控制符

　　java提供了三種訪問權限，準確的說還有一種是默認的訪問權限，加上它一共四種。

  • private 　　在當前類中可訪問
  • default        在當前包內和訪問
  • protected    在當前類和它派生的類中可訪問
  • public          公衆的訪問權限，誰都能訪問

 

7.把一個整數反轉過來，這道你查一下，要注意正負數的狀況

public class demo_exp_2 {

    public int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int pop = x % 10;
            x /= 10;
            if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
            if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
            rev = rev * 10 + pop;
        }
        return rev;
    }
    public static void main(String[] args){

        demo_exp_2 a = new demo_exp_2();
        System.out.println(a.reverse(-13232));
    }

}
View Code

 

簡單代碼以下：

public class Solution {  
    public int reverse(int x) {  
        int result = 0;  
        while (x != 0) {  
            result = result * 10 + x % 10; // 每一次都在原來結果的基礎上變大10倍，再加上餘數  
            x = x / 10; // 對x不停除10  
        }  
        return result;  
    }
View Code

 

8.一球從100米高度自由落下，每次落地後反跳回原高度的一半；再落下，求它在 第10次落地時，共通過多少米？第10次反彈多高？

public static void main(String[] args) {
        int total = 0;
        int height = 100;
        for (int i = 0; i < 10; i++) {
            System.out.print("第" + (i + 1) + "次落下時候高度:" + height + " ");
            total = total + height;
            height = height / 2;
            System.out.println("第" + (i + 1) + "次落下通過距離:" + total);
        }
    }
View Code

 

8.Mysql的數據類型

　主要包括如下五大類：

　　整數類型：BIT、BOOL、TINY INT、SMALL INT、MEDIUM INT、 INT、 BIG INT

　　浮點數類型：FLOAT、DOUBLE、DECIMAL

　　字符串類型：CHAR、VARCHAR、TINY TEXT、TEXT、MEDIUM TEXT、LONGTEXT、TINY BLOB、BLOB、MEDIUM BLOB、LONG BLOB

　　日期類型：Date、DateTime、TimeStamp、Time、Year

　　其餘數據類型：BINARY、VARBINARY、ENUM、SET、Geometry、Point、MultiPoint、LineString、MultiLineString、Polygon、GeometryCollection等

 

 

9.Mysql索引

　　MySQL目前主要有如下幾種索引類型：
　　1.普通索引：是最基本的索引，它沒有任何限制。
　　2.惟一索引：與前面的普通索引相似，不一樣的就是：索引列的值必須惟一，但容許有空值。若是是組合索引，則列值的組合必須惟一。
　　3.主鍵索引：是一種特殊的惟一索引，一個表只能有一個主鍵，不容許有空值。通常是在建表的時候同時建立主鍵索引
　　4.組合索引：指多個字段上建立的索引，只有在查詢條件中使用了建立索引時的第一個字段，索引纔會被使用。使用組合索引時遵循最左前綴集合
　　5.全文索引：主要用來查找文本中的關鍵字，而不是直接與索引中的值相比較。fulltext索引跟其它索引大不相同，它更像是一個搜索引擎，而不是簡單的where語句的參數匹配。
　　6.覆蓋索引
 
 
 
 
 
數據庫有哪些索引？
B tree、B+tree、哈希、全文、R-tree
 
 

爲何不實用二叉查找樹或者紅黑樹做爲數據庫索引。

二叉樹在處理海量數據時，樹的高度過高，雖然索引效率很高，達到logN，但會進行大量磁盤io，得不償失。並且刪除或者插入數據可能致使數據結構改變變成鏈表，須要增進平衡算法。而紅黑樹，插入刪除元素的時候會進行頻繁的變色和旋轉（左旋，右旋），很浪費時間。可是當數據量很小的時候，徹底能夠放入紅黑樹中，此時紅黑樹的時間複雜性比b樹低。所以，綜上考慮，數據庫最後選擇了b樹做爲索引。

B tree和B+ tree應用場景：

1.B樹經常使用於文件系統，和少部分數據庫索引，好比mongoDB。

2.B+樹主要用於mysql數據庫索引。

 

B+ tree對比B tree的優勢

B樹的每一個節點除了存儲指向 子節點的索引外，還要存儲data域，所以單一節點指向子節點的索引並非不少，樹的高度較高，磁盤io次數較多。B+樹的高度更低，且全部data都存儲在葉子節點，葉子節點都處於同一層，所以查詢性能穩定，便於範圍查找。

 
 
10.聯合索引的最左匹配原則
 
11.錶鏈接
 
錶鏈接有幾種?
sql錶鏈接分紅 外鏈接、 內鏈接和 交叉鏈接。
 
外鏈接：
　　外鏈接包括三種,分別是左外鏈接、右外鏈接、全外鏈接。
　　對應的sql關鍵字:LEFT/RIGHT/FULL OUTER JOIN,一般咱們都省略OUTER關鍵字,寫成LEFT/RIGHT/FULL JOIN。
　　在左、右外鏈接中都會以一種表爲基表，基表的全部行、列都會顯示，外表若是和條件不匹配則全部的外表列值都爲NULL。
　　全外鏈接則全部表的行、列都會顯示，條件不匹配的值皆爲NULL。
 
內鏈接：內鏈接是用比較運算符比較要鏈接的列的值的鏈接，不匹配的行不會被顯示。sql關鍵字JOIN 或者INNER JOIN，一般咱們寫成JOIN
 
交叉鏈接：:沒有where條件的交叉鏈接將產生鏈接表所涉及的笛卡爾積。即TableA的行數*TableB的行數的結果集。（TableA 3行*TableB 3行=9行）

 

12.關係型數據庫三大範式

　　要想知足第二範式必須先知足第一範式，想知足第三範式必須先知足第二範式。

第一範式：是指數據庫表的每一列都是不可分割的基本數據項，同一列中不能有多個值，即實體中的某個屬性不能有多個值或者不能有重複的屬性。（列數據的不可分割）

第二範式：要求數據庫表中的每一個行必須能夠被惟一地區分，爲實現區別一般須要爲表加上一個列，以存儲各個實例的惟一標識（主鍵）

第三範式：須要確保數據表中的每一列數據都和主鍵直接相關，而不能間接相關。

 

簡單總結就是：第一範式的關鍵詞是列的原子性

　　　　　　　第二範式的關鍵詞是不能包含部分依賴

　　　　　　　第三範式的關鍵詞是不能包含傳遞依賴

更多：http://www.javashuo.com/article/p-dngvthpy-em.html

 

13.list<T>、 list<?>、list<Object>的區別？

　　List<T>、List<?>、List<Object>這三者均可以容納全部的對象，

　　但使用的順序應該是首選List<T>，次之List<?>，最後選擇List<Object>

緣由以下：

(1) List<T>是肯定的某一個類型
　　List<T>表示的是List集合中的元素都爲T類型，具體類型在運行期決定；List<?>表示任意類型，與List<T>相似，而List<Object>則表示List集合中的全部元素爲Object類型，由於Object是全部類的父類，因此List<Object>也能夠容納全部的類類型，從這一字面意義上分析，List<T>更符合習慣：編碼者知道它是某一個類型，只是在運行期才肯定而已。

(2) List<T>能夠進行讀寫操做
　　List<T>能夠進行諸如add、remove等操做，由於它的類型是固定的T類型，在編碼期 不須要進行任何的轉型操做。
　　List<?>是隻讀類型的，不能進行增長、修改操做，由於編譯器不知道List中容納的是 什麼類型的元素，也就無畢校驗類型是否安全了，並且List<?>讀取出的元素都是Object類 型的，須要主動轉型，因此它常常用於泛型方法的返回值。注意，List<?>雖然沒法增長、修 改元素，可是卻能夠刪除元素，好比執行remove、clear等方法，那是由於它的刪除動做與泛型類型無關。
　　List<Object>也能夠讀寫操做，可是它執行寫入操做時須要向上轉型（Upcast),在讀 取數據後須要向下轉型（Downcast),而此時已經失去了泛型存在的意義了。

 

14.數據庫優化

一、選取最適用的字段屬性

二、使用鏈接（JOIN）來代替子查詢(Sub-Queries)

三、使用聯合(UNION)來代替手動建立的臨時表

四、事務

五、鎖定表

六、使用外鍵

七、使用索引

八、優化的查詢語句

 

MySQL性能優化的一些經驗
	a.爲查詢優化你的查詢
	b.學會使用EXPLAIN
	c.當只要一行數據時使用LIMIT 1
		當你查詢表的有些時候只須要一條數據，請使用 limit 1。
	d.正確的使用索引
		索引並不必定就是給主鍵或是惟一的字段。若是在你的表中，有某個字段你總要會常常用來作搜索、拍下、條件，那麼，請爲其創建索引吧。
	e.不要ORDER BY RAND()
		效率很低的一種隨機查詢。
	f.避免SELECT *
		從數據庫裏讀出越多的數據，那麼查詢就會變得越慢。而且，若是你的數據庫服務器和WEB服務器是兩臺獨立的服務器的話，這還會增長網絡傳輸的負載。必須應該養成一個須要什麼就取什麼的好的習慣。
	g.使用 ENUM 而不是 VARCHAR
		ENUM 類型是很是快和緊湊的。在實際上，其保存的是 TINYINT，但其外表上顯示爲字符串。這樣一來，用這個字段來作一些選項列表變得至關的完美。
		若是你有一個字段，好比「性別」，「國家」，「民族」，「狀態」或「部門」，你知道這些字段的取值是有限並且固定的，那麼，你應該使用 ENUM 而不是 VARCHAR。
	h.使用 NOT NULL
	k.垂直分割
		「垂直分割」是一種把數據庫中的表按列變成幾張表的方法，這樣能夠下降表的複雜度和字段的數目，從而達到優化的目的。須要注意的是，這些被分出去的字段所造成的表，你不會常常性地去Join他們，否則的話，這樣的性能會比不分割時還要差，並且，會是極數級的降低。
	l.拆分大的 DELETE 或 INSERT 語句
	
	m.越小的列會越快
		對於大多數的數據庫引擎來講，硬盤操做多是最重大的瓶頸。因此，把你的數據變得緊湊會對這種狀況很是有幫助，由於這減小了對硬盤的訪問。
	n.選擇正確的存儲引擎
		在 MySQL 中有兩個存儲引擎 MyISAM 和 InnoDB，每一個引擎都有利有弊。
		MyISAM 適合於一些須要大量查詢的應用，但其對於有大量寫操做並非很好。甚至你只是須要update一個字段，整個表都會被鎖起來，而別的進程，就算是讀進程都沒法操做直到讀操做完成。另外，MyISAM 對於 SELECT COUNT(*) 這類的計算是超快無比的。
		InnoDB 的趨勢會是一個很是複雜的存儲引擎，對於一些小的應用，它會比 MyISAM 還慢。他是它支持「行鎖」 ，因而在寫操做比較多的時候，會更優秀。而且，他還支持更多的高級應用，好比：事務。

 9.兩個list查找相同元素！除了遍歷外你還想到什麼方法？

　　從兩個list中找到重複元素，很容易就想到兩個for循環嵌套來實現，可是若是兩個list都很是大的話，時間複雜度將很是大。因此這裏介紹一種以空間換時間的方法。
1.由於list中是能夠存在相同元素的，可是想以2來獲得重複的元素，因此須要進行去重
2.將list中的元素放入map中，並對元素個數進行一個統計
3.將hashmap中value爲2的key存入list

代碼以下：

public class TestList {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();

        list1.add("a");
        list1.add("b");
        list1.add("b");
        list1.add("c");

        list2.add("b");
        list2.add("c");
        list2.add("d");

        String duplicate = findDuplicate(list1, list2);
        System.out.println("duplicate element: " + duplicate);
    }

    private static String findDuplicate(List<String> list1, List<String> list2) {
        List<String> duplicate = new ArrayList<String>();
        Map<String, Integer> map = new HashMap<String, Integer>();
        //1.去重
        List<String> list3 = new ArrayList<String>(new HashSet<String>(list1));
        List<String> list4 = new ArrayList<String>(new HashSet<String>(list2));
        //2.將list中的元素加入map中並進行統計
        for (String s1 : list3) {
            map.put(s1, 1);
        }
        //3.將list中的元素加入map中並進行統計
        for (String s2 : list4) {
            map.put(s2, (map.get(s2) == null ? 1 : 2));
        }
        //4.將重複的元素放入list中
        for (Map.Entry<String, Integer> m : map.entrySet()) {
            if (m.getValue() == 2) {
                duplicate.add(m.getKey());
            }
        }
        return duplicate.toString();
    }
}
View Code

 

 

15.複習一下mybatis

 

 

16.數據庫若是有某個字段突然增大到幾萬的長度怎麼辦

　　能夠另外建一個表來存儲這段數據，再有就是把字段切割成幾段，原先的表裏存對應的id ，避免原先的表數據量過大

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程