Java 基础几个为什么？

1.如何用鼠标双击就可以运行的JAR文件？
MF文件是一个清单文件。里面记录的是版本信息，和主入口类信息等。
2.x+=y 和 x=x+y?

int a = 10;
a+=1;
与a = a+1;这里没什么区别。

但是
shot a = 10;
a+=1;
和a=a+1；这就有问题了     a+=这种方式 不但实现了功能，而且还进行一次数据类型的强制转换。

3.在实现x递增加1的时候，X++ 与++X有什么区别?

 int i = 10;
 // i++;
  ++i;
  System.out.println("i\t"+i);
  
 
 // 上述代码中i++ 与++i是作为单独语句进行执行的,所以等价。

 // 如若i++  与 ++i作为程序的某一部分是使用 就会存在差异
  
  
  int a = 10;
  int b = 10;
  int j = 10+(a++);//a 变量值先参与表达式运算,然后在加1运算  所以a=10不变
  int z = 10+(++b);//a 变量值先运算自加1  所以b=11  在参与表达式运算
  
  System.out.println("j\t"+j);
  System.out.println("z\t"+z);

4."+"操作符号在Java内部是如何实现字符串连接的。
                String a = "a";
  String b = "b";
  
    //两个String类型和一个数值类型连接
  String c = a + b;
  //一个String类型和一个数值类型进行连接
  String d = c + 1;
  
  System.out.println("c\t"+c);
  System.out.println("d\t"+d);
  //上述代码进行编译之后 我们可以看到.
  
  
  
 /* public static void main(String args[])
  {
   String a = "a";
   String b = "b";
   String c = (new StringBuilder(String.valueOf(a))).append(b).toString();
   String d = (new StringBuilder(String.valueOf(c))).append(1).toString();
   System.out.println((new StringBuilder("c\t")).append(c).toString());
   System.out.println((new StringBuilder("d\t")).append(d).toString());
  }*/
  
  //由编译结果可以看出,"+"在实际字符串连接过程中,实际上借助了StringBuilder类以及append方法
  //String 类代表大小已经固定的字符串 一旦被声明之后，内容和大小都没法改变，
  //String类中提供的所有字符串操作方法，所返回的结果都是创建了一个新的String对象并返回。
  //为了考虑效率问题 在底层Java采用了StringBuilder类,利用他的insert() append();在原字符基础上修改。

5.== 和 equals比较相等的区别?
         int a = 10;
  int b = 10;
  String c = new String("tom");
  String d = new String("tom");
  
  
 //==用于判断两个简单变量的值是否相等。  或者两个引用变量的引用地址是否相等.
 //equals用于判断两个引用地址指向的存储内容是否相等。
  
  System.out.println(a==b);
  System.out.println(c==d);
  System.out.println(c.equals(d));

6.String s  ="abc"与String s = new String("abc"); 有什么区别?
  String a ="tom";
  String b = "tom";
  
  
  //字符串是程序中使用频率比较高的一种数据类型，
  //Java为了加强程序的运行速度,因此在设计上使用了两种
  //不同的方法来生成字符窜对象。
  //一种是调用String类的构造方法
  //另一种是使用双引号"";
  //这两种方法生成的字符串对象，在内存中存取机制是不同的
     //Java为String类型提供了缓冲池机制,当使用双引号定义对象时,
  //Java环境首先去字符串缓冲池中寻找相同内容的字符串,如果存在
  //则直接拿出来应用,如果不存在则创建一个新的字符串放在缓冲池中.
  
  //所以上述String a，String b;使用的是缓冲区中同一个存储对象.
  String c = new String("tom");
  String d = new String("tom");
  //而String c,String d，则在对内存中开辟了两块内存空间，
  //两个不同的引用只是内容相同而已.

7.break 与 continue

   for(int i = 1;i<=10;i++)
            {
                  if(i == 7){
                  break;
                  } 
                  System.out.println("i \t"+i);
            }
            System.out.println("i = 7; break ;Game Over");
           
           
            for(int j = 1;j<=10;j++)
            {
                  if(j == 7){
                  continue;
                  } 
                  System.out.println("j \t"+j);
            }
            System.out.println("j = 7; continue ;Game Over");
           
           
          /*运行结果
           *i  1
            i  2
            i  3
            i  4
            i  5
            i  6
            i = 7; break ;Game Over
            j  1
            j  2
            j  3
            j  4
            j  5
            j  6
            j  8
            j  9
            j  10
            j = 7; continue ;Game Over
*/

           
              //continue 跳出本次循环 继续下一次循环 所以j=7后跳出 ,执行下面的j=8 j =9 j=10
              //break 跳出本次循环 不在进行下次循环  意思就是i = 7 后面的就不执行了。

8.如何实现数组的copy

//static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length){};
    //src       源数组
    //srcPos    源数组中的起始位置
    //dest      目标数组
    //destPos   目标数据中的起始位置
    //length    要复制元素的数量
 
  int[] a = {10,20,30,40,50};
  int[] b = {1,2,3,4,5,6,7,8,9};
  
  System.arraycopy(a, 0, b, 2, 5);
  
  for(int element : b){
   System.out.println("element in b\t"+element);
  }
  
  //运行结果
  /*element in b 1
  element in b 2
  element in b 10
  element in b 20
  element in b 30
  element in b 40
  element in b 50
  element in b 8
  element in b 9*/

9.几种排序方式
package com.dk.q08;

public class q08 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  int[] testArray = {110,10,220,2,1,4,500,6,41,21,4};
  //数组排序算法
  //System.out.println("1.选择排序\n");
  //q08.xuanze(testArray);
  //System.out.println("2.冒泡排序\n");
  //q08.maopao(testArray);
  //System.out.println("3.插入排序\n");
  //q08.charu(testArray);
  System.out.println("4.快速排序\n");
  q08.kuaisu(testArray);
 }
 
 
 //1.选择排序法
 /*思路清理:
  *
  * 将要排序的数组分成两部分，
  * 一部分是从小到达已经排好序的，一部分是无序的。
  * 从无序的部分取出最小值放到已经排好的部分的最后。
  */
 public static int[] xuanze(int[] testArray){
  int t;
  for(int i = 0 ; i < testArray.length ; i ++)
  {
   int m = i;
   for(int j = i+1;j< testArray.length ; j ++)
   {
    //如果j元素比m元素小,将j赋值给m
    if( testArray[j] <  testArray[m] )
    {
     m = j;
    }
   }
   
   //交换m和i两元素的位置
   if(i != m)
   {
    t = testArray[i];
    testArray[i] = testArray[m];
    testArray[m] = t;
   }
  }
  printlnArray(testArray);
  return testArray;
 }

 //2.冒泡排序法
 /*思路清理:
  *
  * 从数组开始扫描待排序的元素,在扫描的过程中依次对相邻元素进行比较，
  * 将数值较大的元素往后移，每经过一次一趟排序之后，数值最大的元素
  * 将移到末尾，此时记下该元素的位置，下一趟排序只需要比较到此位置
  * 为止，直到所有元素都已有序排列.
  *
  */
 public static int[] maopao(int[] testArray){
  int t;
  for(int i = 0 ; i < testArray.length ; i ++)
  {
     //循环比较相邻两个元素大小
   for(int j = 0 ; j < testArray.length-1 ; j ++)
   {
    //比较相邻元素大小，小的前移，大的后移。
    if(testArray[j] > testArray[j+1])
    {
     t = testArray[j];
     testArray[j] = testArray[j+1];
     testArray[j+1]=t;
    }
   }
  }
  printlnArray(testArray);
  return testArray;
 }
 
 //3.插入排序法
 /*思路清理:
  *
  * 要将排序的数组分为两部分,每次从后面的数组部分中取出索引
  * 最小的数组元素，插入到前面数组部分的适当位置中。通常在开始排序
  * 时，将数组的第一个元素作为一组,后面的元素被当初另外一组.
  *
  */
 public static int[] charu(int[] testArray){
  //把第一个元素看作一部分,第二个元素看作另一部分
  //从第二部分中依次取元素插入到第一部分中。
  for(int i = 1 ; i < testArray.length ; i ++)
  {
   int temp = testArray[i];
   int j = i - 1;
      //依次和i前面元素比较,寻找合适插入位置
   while(temp < testArray[j]){
    testArray[j+1] = testArray[j];
    j--;
    if(j == -1){
     break;
    }
   }
   //将插入元素插入到合适位置
   testArray[j+1] = temp;
  }
  printlnArray(testArray);
  return testArray;
 }
 
 //4.快速排序法
 /*思路清理:
  *
  * 快速排序被认为最好的排序算法之一,他主要是将一个大的数组排序问题,
  * 分解成2个小的数组的排序，而每个小的数组的排序又可以继续分解成更小的2个数组
  * 在这样一直递归分解下去，直到数组的最小最后为2.
  *
  *
  */
 public static int[] kuaisu(int[] testArray){
 
  return quicksort(testArray,0,testArray.length-1);
 }
 
 
   public static int[] quicksort(int[] testArray,int left,int right){
  //递归分组排序
  int t ;
  if( left < right )
  {
     int s = testArray[left];
     int i = left;
     int j = right+1;
     while(true)
     {
     //向右找大于s的数的索引
      while( i+1<testArray.length && testArray[++i]<s );
   
       //向左找小于s的数的索引
       while(j-1 >-1 && testArray[--j]>s);
     
        //如果i>=j ,退出循环
        if(i >= j)
        {
         break;
        }
        else
        {
         //交换i和j的位置的元素
         t = testArray[i];
         testArray[i]=testArray[j];
         testArray[j]=t;
        }
     }
    
     testArray[left] = testArray[j];
     testArray[j]=s;
     //对左边进行递归
     quicksort(testArray,left,j-1);
     //对右边进行递归
     quicksort(testArray,j+1,right);
  }
  printlnArray(testArray);
  return testArray;
   }
 
 public static void printlnArray(int[] testArray){
  
  for(int element : testArray)
  {
   System.out.println("element in testArray \t"+element);
  }
 }
}

10.JDBC-API

DriverMnageer：管理一组JDBC驱动程序的基本服务
Connection：Java程序与特定数据库的连接
Statement:   用于执行静态SQL语句并返回它所生成的结果对象。
PreparedStatement:表示预编译SQL语句对象
CallableSatement:用于执行SQL存储过程的接口
ResultSet:表示数据库查询的结果集.

11. Statement 和 PrepareStetment
Statement 用于执行静态SQL语句并返回它所结果对象。Statement在执行sql之前必须指定一个事先准备好的sql语句。
而使用PrepareStetment对象执行SQL命令时，SQL命令被数据库进行解释并编译，然后被放到命令缓冲区。然后当执行同一个PrepareStetment对象的时候，他就会被在解析一次，但不会
被再次编译。在缓冲区中可以发现预编译命令，并且可以重新使用。PrepareStetment对象带来的编译次数的减少能提高数据库的总体性能。

12调用存储过程。
CallableStatement  cs = conn.prepareCall("{call MyProcedure1()}"); 调用无参存储过程。
CallableStatement  cs = conn.prepareCall("{call MyProcedure1(?,?)}"); 调用有参存储过程。

13 oracle 连接数据库 thin 和oci 方式有什么不一样么？
jdbc:oracle:thin@127.0.0.1:1521:test

jdbc:oracle:oci@test  @<本地服务>

thin 属于 Direct-to-Datebase Pure Java Driver 类型   只要有数据库驱动jar包就可以直接通过网络端口访问数据库
oci  属于 Native-API partly-java driver类型   需要在客户端安装oracle的客户端安装软件.并注册本地服务名.理论上oci的性能要好于thin

14JDBC中的批处理
 Statement 和 PrepareStetment都支持批处理功能，可以使用addBacth()方法追加sql操作语句  使用executeBatch();

Statement st = conn.createStatement();
st.addBacth("select * from a");
st.addBacth("update a  set name='aa' where id=1");
st.addBacth("delete from a where id = 2");
st.executeBatch();

15提升sql语句的性能查询性能。

1.数据库设计与规划
   1.1pramary key 字段长度尽量小，能用small integer就不要使用integer
   1.2字符长度如果固定 请不要用varchar或nvarchar 比如电话号码，身份证号码
   1.3如果长度不固定应该是用varchar 或nvarchar 除了可以节省存储空间外，存储硬盘时，也会较有效率。
   1.4设计字段时，如果其值可有可无最好给一个默认值，并设置成不允许null，因为有些数据库在存放和查询有null的数据表时，会花费额外的运算动作。

2.适当的创建索引
  2.1 primary key 字段可以自动创建索引

3.使用索引功能

4.避免在where子句中对字段使用函数.

5.and 与 or的使用
 在and运算中，只要有一个条件使用到索引，即可大幅度提升查询速度,但在or运算中则要所有的条件都有索引才能提升查询效率。
6.Join与子查询
  多数情况下join比子查询的效率要高，join语法也更容易理解。

7.其他查询技巧
比如order by ，distint 等会让数据库做额外的计算.如果没有要过滤重复数据的需要使用unionall union 因为后者加入了distinct算法。

8.尽可能的使用存储过程
存储过程是实现编译好，性能较好，也可减少sql语句在网络中的传递。方便商业逻辑的重复使用。

9.尽可能在数据源过滤数据