記錄平時開發的一些問題

從學校出來快兩個月了，在這家公司從實習到轉正也工做半年了，也體會了連續半個月的加班到一兩點甚至通宵，趁着這幾天事情少，總結一下這段時間遇到的一些問題，問題都比較老，由於技術棧比較老，可是對我這個初出茅廬的仍是有一些借鑑意義的。

1.exists關鍵字select from emp where exists（select max（sal） from emp）這句話的意思是隻要（select max（sal） from emp）有結果則執行select from emp，不然不執行

2.在Windows下的路徑分隔符和Linux下的路徑分隔符是不同的，當直接使用絕對路徑時，跨平臺會暴出「No such file or diretory」的異常。
好比說要在temp目錄下創建一個test.txt文件，在Windows下應該這麼寫：File file1 = new File ("C:tmptest.txt");
在Linux下則是這樣的：File file2 = new File ("/tmp/test.txt");
若是要考慮跨平臺，則最好是這麼寫： File myFile = new File("C:" + File.separator + "tmp" + File.separator, "test.txt");
File類有幾個相似separator的靜態字段，都是與系統相關的，在編程時應儘可能使用。

3.n = n&(n-1); 重複操做，有多少個1，這個操做就能夠執行多少次。用來求輸入是一個無符號整數，返回其二進制表達式中數字位數爲 ‘1’ 的個數(漢明重量)

4.^(異或運算)：參加運算的兩個對象，若是兩個相應位爲「異」（值不一樣），則該位結果爲1，不然爲0。
&(與運算)：兩位同時爲「1」，結果才爲「1」，不然爲0
|(或運算)：參加運算的兩個對象只要有一個爲1，其值爲1。
~（取反運算符）：參加運算的一個數據，按二進制位進行「取反」運算。運算規則：~1=0； ~0=1；

5 mkdirs()能夠創建多級文件夾， mkdir()只會創建一級的文件夾， 以下：
new File("/tmp/one/two/three").mkdirs();執行後， 會創建tmp/one/two/three四級目錄
new File("/tmp/one/two/three").mkdir();則不會創建任何目錄， 由於找不到/tmp/one/two目錄， 結果返回false

6.視圖的做用：

1. 視圖可以簡化用戶的操做。
2. 視圖使用戶能以多種角度看待同一數據。
3. 視圖對重構數據庫提供了必定程度的邏輯獨立性。
4. 視圖可以對機密數據提供安全保護。
5. 適當利用視圖能夠更清晰的表達查詢。

7.java List去重方式及效率對比：

方式一，利用HashSet不能添加劇複數據的特性 因爲HashSet不能保證添加順序，因此只能做爲判斷條件：

private static void removeDuplicate(List<String> list) {

HashSet<String> set = new HashSet<String>(list.size());
   List<String> result = new ArrayList<String>(list.size());
   for (String str : list) {
       if (set.add(str)) {
           result.add(str);
       }
   }
   list.clear();
   list.addAll(result);

}
方式二，利用LinkedHashSet不能添加劇複數據並能保證添加順序的特性 ：

private static void removeDuplicate(List<String> list) {

LinkedHashSet<String> set = new LinkedHashSet<String>(list.size());
   set.addAll(list);
   list.clear();
   list.addAll(set);

}
方式三，利用List的contains方法循環遍歷：

private static void removeDuplicate(List<String> list) {

List<String> result = new ArrayList<String>(list.size());
   for (String str : list) {
       if (!result.contains(str)) {
           result.add(str);
       }
   }
   list.clear();
   list.addAll(result);

}

準備測試程序：

private static void main(String[] args) {

final List<String> list = new ArrayList<String>();
   for (int i = 0; i < 1000; i++) {
       list.add("haha-" + i);
   }

   long time = System.currentTimeMillis();
   for (int i = 0; i < 10000; i++) {
       removeDuplicate(list);
   }
   long time1 = System.currentTimeMillis();
   System.out.println("time1:"+(time1-time));
   
   for (int i = 0; i < 10000; i++) {
       removeDuplicate2(list);
   }
   long time2 = System.currentTimeMillis();
   System.out.println("time2:"+(time2-time1));
   
   for (int i = 0; i < 10000; i++) {
       removeDuplicate3(list);
   }
   long time3 = System.currentTimeMillis();
   System.out.println("time3:"+(time3-time2));

}
結果爲：

time1:329
time2:292
time3:17315
總結：從便捷以及效率上，方式二是最佳選擇，具體緣由能夠參考HashMap的存儲方式

8.put與putIfAbsent區別:

put在放入數據時，若是放入數據的key已經存在與Map中，最後放入的數據會覆蓋以前存在的數據，

而putIfAbsent在放入數據時，若是存在重複的key，那麼putIfAbsent不會放入值。

putIfAbsent若是傳入key對應的value已經存在，就返回存在的value，不進行替換。若是不存在，就添加key和value，返回null

9.JAVA實現數據等分，一個List分紅多個List

/**
 * 將一組數據平均分紅n組
 *
 * @param source 要分組的數據源
 * @param n      平均分紅n組
 * @param <T>
 * @return
 */
public static <T> List<List<T>> averageAssign(List<T> source, int n) {
    List<List<T>> result = new ArrayList<List<T>>();
    int remainder = source.size() % n;  //(先計算出餘數)
    int number = source.size() / n;  //而後是商
    int offset = 0;//偏移量
    for (int i = 0; i < n; i++) {
        List<T> value = null;
        if (remainder > 0) {
            value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
            remainder--;
            offset++;
        } else {
            value = source.subList(i * number + offset, (i + 1) * number + offset);
        }
        result.add(value);
    }
    return result;
}

/**
 * 將一組數據固定分組，每組n個元素
 * @param source 要分組的數據源
 * @param n      每組n個元素
 * @param <T>
 * @return
 */
public static <T> List<List<T>> fixedGrouping(List<T> source, int n) {

    if (null == source || source.size() == 0 || n <= 0)
        return null;
    List<List<T>> result = new ArrayList<List<T>>();

    int sourceSize = source.size();
    int size = (source.size() / n) + 1;
    for (int i = 0; i < size; i++) {
        List<T> subset = new ArrayList<T>();
        for (int j = i * n; j < (i + 1) * n; j++) {
            if (j < sourceSize) {
                subset.add(source.get(j));
            }
        }
        result.add(subset);
    }
    return result;
}

/**
 * 將一組數據固定分組，每組n個元素
 *
 * @param source 要分組的數據源
 * @param n      每組n個元素
 * @param <T>
 * @return
 */
public static <T> List<List<T>> fixedGrouping2(List<T> source, int n) {

    if (null == source || source.size() == 0 || n <= 0)
        return null;
    List<List<T>> result = new ArrayList<List<T>>();
    int remainder = source.size() % n;
    int size = (source.size() / n);
    for (int i = 0; i < size; i++) {
        List<T> subset = null;
        subset = source.subList(i * n, (i + 1) * n);
        result.add(subset);
    }
    if (remainder > 0) {
        List<T> subset = null;
        subset = source.subList(size * n, size * n + remainder);
        result.add(subset);
    }
    return result;
}