黑马程序员—java语法基础

                                             -------android培训、java培训、期待与您交流！ ----------

1.数值型：

整型：byte、short、int、long

区别：byte：由1个8位来表示，即由8位二进制来表示。   short：由2个8位来表示，即由16位二进制来表示。

          int：由4个8为来表示，即由32为二进制来表示。    long：由8个8位来表示。

浮点型：float、double

区别：float：由4个8位来表示       double：由8个8位来表示

2."%"取模运算：

（1）2 % 5 == 2； 即当左边的操作数小于右边时，值就为左边的值；

（2）2 % -5 == 2； -2 % 5 == -2； 即当左边的操作数为负数时，值就为相应值的负数；与右边操作数是不是负数无关；

3. 字符串数据和任何数据使用+都是相连接，最终都会变成字符串；

4.运算符：

^异或：两边结果相同为false，两边不同为true； 注：一个数异或同一个数两次，结果还是之前那个数。

&和&&的区别：&无论左边是否为真，右边都要运算；&&如果左边为假，则右边就不去运行；

5.位运算符：

<<左移、>>右移：

3<<2(3向左移2位)：用二进制来表示3.然后对二进制左移两位，后面缺少两位用0补上；

a>>2(a向右移2为)：表示对32位二进制右移两位，前面缺少两位用0或1补上(如果最高位是1即这个数是负数，就用1补)；

>>>无符号右移：即不管是正数还是负数，都用0去补；

结论：<<其实就是乘以2的移动的位数次幂； >>就是除以2的移动的位数次幂；

位运算符还有：&与、|或、^异或、~反码

6.switch语句：

     语句中选择的类型只有四种：byte、short、int、char。

7.循环语句

while循环、do...while循环、for循环。

for(初始化表达式; 循环条件表达式; 循环后的操作表达式){ 执行语句 }：

(1). 执行顺序：初始化表达式（执行一次）->循环表达式->执行语句->循环后操作表达式

(2). 循环条件表达式一定要是能判断true或者false的语句，不然编译出错

无限循环最简单表现形式：for( ; ; ){ }、while(true){ }

8.break、continue语句：

break：作用于switch和循环语句中。如果作用于循环中，表示终止break所在循环语句中的整个循环；

continue：作用于循环语句中。表示终止continue所在循环语句中的本次循环，跳到下一次循环中；

break和contine都不能单独存在于代码中。

9.函数

(1).如何定义一个函数？

a.既然函数是一个独立的功能，那么该功能的运算结果是什么先确定；

b.再明确在定义该功能的过程中是否需要未知的内容参与运算；

(2).函数重载：

a.在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可；

b.与返回值类型无关，只看参数列表；

10.二维数组及相关算法
(1).二维数组定义方式：

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

b.int[][] a = new int[3][];   a[0] = new int[2]; a[1] = new int[3]; a[2] = new int[5];

c.int[][] a = {{1,2},{2,5,6},{1,9}}; 或者int[] y[];

d.另类定义方法：int[] x,y[];  它相当于定义了一个int[] x，还有一个二维数组：int[]y[];

(2).选择排序

原理：一个数组中，选定一个位置不变，然后与其他位置的值进行比较，如果选定位置的值大于某个位置的值，则把它们的值进行交换，直至选定位置的值最小为止；然后再对之前选定位置的下一个位置进行锁定，然后再与其他位置的值进行比较；

代码实现：

           int [] a =   new   int []{1,3,5,4,8,6,2,9};

              for (   int   i=0; i<a.   length -1; i++){    

                   for (   int   j=i+1; j<a.   length ; j++){

                        if (a[i] > a[j]){

                            int   temp = a[i];

                           a[i] = a[j];

                           a[j] = temp;

                     }

                }

           }

(3)冒泡排序

原理：一个数组中，两两位置进行比较；即如果i位置上的值大于i+1位置上的值，则把两个位置进行对调（值也要对调）。对调后i位置就变成了i+1，然后再与i+2位置进行比较，直到比出最大值为止；

代码实现：

           for ( int   i=0; i<a. length -1; i++){     

               for (   int   j=0; j<a.   length -i-1; j++){

                     if (a[j] > a[j+1]){

                          int   temp = a[j];

                          a[j] = a[j+1];

                          a[j+1] = temp;

                     }

                }

           }

(4)折半查找

代码实现：

       public   int   index( int [] b,   int   aa){

              int   min = 0;

              int   max = b.   length -1;

              int   middle = (min + max)/2;

              while (aa != b[middle]){

                   if (aa > b[middle]){

                     min = middle+1;

                }   else   if (aa < b[middle]){

                     max = middle-1;

                }

                   if (min > max){

                        return   -1;

                }

                middle = (min+max)/2;

           }

              return   middle;

     }

题目： 十进制转十六进制

第一种方法：

     public   void   change( int   aa){

           StringBuffer sb =   new   StringBuffer();

              for (   int   i=0; i<8; i++){

                   int   temp = aa & 15;

                   if (temp > 9){

                     sb.append((   char )(temp-10+   'a' ));

                }   else {

                     sb.append(temp);

                }

                aa = aa >>>4;

           }

           System.   out .println(sb.reverse());

     }

第二种方法：

查表法：将所有的元素临时存储起来。建立好对应关系。每一次&15后的值作为索引去查建立好的表。就可以找到对应元素。

这个表怎么建立呢？  可以通过数据的形式来定义。

          public   void   change2( int   aa){

           char [] cc =   new   char []{   '0' ,   '1' ,   '2' ,   '3' ,   '4' ,   '5' ,   '6' ,   '7' ,
                                '8' ,   '9' , 'a' ,   'b' ,   'c' ,   'd' ,   'e' ,   'f' };

         char [] dd =   new   char [8];   //定义一个临时容器来存储转变后的值；

          int   pos=0;

          while (aa != 0){

             int   temp = aa & 15;

             dd[pos] = cc[temp];

             aa = aa >>> 4;

             pos++;

          }

          for (   int   j=pos-1; j>=0; j--){

             System.   out .print(dd[j]);

          }

     }

代码优化：

                     char [] dd =   new   char [8];  

           int   pos= dd. length ;

              while (aa != 0){

                   int   temp = aa & 15;

                 dd[--pos] = cc[temp];

                aa = aa >>> 4;

           }

           for (   int   j=pos; j< dd. length ; j++){

                System.   out .print( dd[j]);

           }