记录平时开发的一些问题

从学校出来快两个月了，在这家公司从实习到转正也工作半年了，也体会了连续半个月的加班到一两点甚至通宵，趁着这几天事情少，总结一下这段时间遇到的一些问题，问题都比较老，因为技术栈比较老，但是对我这个初出茅庐的还是有一些借鉴意义的。

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;
}