黑马程序员 01基础知识 for 语句等

 

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

//1在做取模运算时, 和%右边的数的符号无关, 只取决于%左边的数的符号
    System.out.println(10 % 3);//1
    System.out.println(10 % -3);//1
    System.out.println(-10 % 3);//-1
    System.out.println(-10 % -3);//-1

2.通过模运算可以进行真假切换

3.  自增自减小技巧： ++  在前，就是先运算后自增 ， ++ 在后，就是先自增后运算。

4. 面试题：

如果Short s=2;

那么S+=3;和s=s+2；结果一致吗？有何区别？

答案，不一致，s+=3是一次运算，+=这个赋值符号具有自动转换功效，直接运算出值是5

而s=s+2；是二次运算，强制运算出的值会丢失精度。

5.java中不允许3<x<6这样的大小关系表达形式，对比关系需要用上运算符号。应表达成x>3&x<6.

6.符号小规律：

&  ：真真为真，其他为假。

&符号

              true & true = true;

              true & false = false;

              false & true = false;

              false & false = false;

|   ：假假为假，其他为真。

| 符号

              true | true = true;

              true | false = true;

              false | true = true;

              false | false = false;

^ 符号（异或）

              true ^ true = false;

              true ^ false = true;

              false ^ true = true;

              false ^ false = false;

 

              总结：两边相同时，结果为false，否则为true。

7：与符号&和短路与&&的区别：

y>5& y<7=false ;(举例：4不大于5而小于7)。

y>5& &y<7=true;（举例： 判断4不大于5后，后面不再判断，物理中的短路）

因此：单与，左右都运算，双与，左为假右不算，所以双与比单与高效。

8.单或|和双或||的区别：

  单|时，左右两边都运算。双||时，左边为真，结果必为真，右边不运算。

9.面试题：

  Class Demo

{

       Public Static void main(String[] args)

{

System.out.println(6^3);

}

}      结果是几呢？

运算方法：6的二进制表达式是110,3的是011，

110

^011

------（相同为假规律）

 101=5

10.负数的二进制表现形式，对整数进行取反，+1.

例如：

6

00000000   00000000  00000000  00000110

—6

11111111    11111111   11111111  11111001=反码

+   00000000   00000000  00000000  00000001

--------------------------------------------------------------------------

11111111    11111111   11111111  11111010= -6

11.位移运算符小技巧：

左移<<  越移越大，如3<<2，其实就是3乘以2的2次方。

右移>>正数是  越移动越小。负数是移动后变大。-16>>1 结果是-8

>>>无符号右移，相对应用于负数的右移，不管最高位是1还是0都是补0。（>>则按最高位来决定）

12.else if意思是否定前面的语句后才进行下一步的操作，下题中读完if语句后就停下来了。结果为a.如果前面条件不满足才会继续往下读。

 

       Int  x=4;

if(x>1)

              {

                     System.out.println("a");

              }

              else if(x>2)

              {

             

                     System.out.println("b");

              }

              else if(x>3)

              {

                     System.out.println("c");       

              }

              else

              {

                     System.out.println("d");              

              }

13.三元运算符的应用？：

变量=（条件表达式）？表达式1：表达式2；

例子：

int y;

if(x>1)

  y=100;

else

  y=200;

上述写法可简写成：y=(x>1)?100:200;

注意：当if else语句执行完有结果出现时，可以使用简写格式，特点：运算后肯定有结果出现。有运算结果时（题中用变量y来记录的）才用三元运算。

14. switch中default 可以至于case前亦可至于case后，程序执行都会最后读default.目前switch语句只支持byte,short,int,char，类型。

15. 如何选用if和swtich：

对判断某些值时两者可以互换；判断区间范围时只能用if,在一个功能执行后结果是布尔型时只有if能判断。当对某几个值进行判断是用switch判断效率会比较高。

 

  int[] arr1 = {1, 2, 3};    // 定义数组, 指定元素, 这种方式只能用在给一个变量赋值的时候
  int[] arr2 = new int[]{1, 2, 3}; // 定义数组, 指定元素, 这种方式在任何情况下都能使用
  int[] arr3 = new int[3];   // 定义数组, 指定长度为3, 其中所有元素都是默认值. 基本数据类型的默认值都是0 

1：3000米绳子每天减少一半多少天少于5米

i为3000只要长度大于5继续循环然后i在不断变化i=i/2;

 int day=0；  

  for(int i=3000;i>=5;i/=2)  

   {  

   day++;  

 }  

  System.out.println(day);  

2. 结果为c，一般先考虑能否通过在想结果是多少因为boolean的特殊性 if(b=false)将b变成了false；结果就为c 

 public static void function1()  

 {  

     boolean b=true;  

     if(b=false)  

     System.out.println("a");  

   else if(b)  

   System.out.println("b");  

      else if(!b)  

         System.out.println("c");  

       else  

         System.out.println("d");  

        

  }  

3，是流程控制语句结果为19 运算的流程算：先 case 1，case 3都不符合情况，然后defalut +4;
  * default 没有break然后又往下循环+5 +6

public static void function3()  

    {  

         int i=4;  

        switch(i)  

        {  

            default: i+=4;  

           case 1:i=i+5;  

            case 3:i=i+6;  

                

           }  

          System.out.println(i);  

    }  

 

 

 // 基本数据类型变量, 传入函数, 函数中对变量修改, 调用处不变

 public static void main(String[] args) throws IOException {
   int x = 5; 
  fun(x);       System.out.println(x);结果是5
  
 }
 static void fun(int x) {
  x = 10; 
 }

 // 引用数据类型变量, 传入函数, 函数中对变量修改, 调用处一起改变

public static void main(String[] args) throws IOException {
  
  int[] arr = {100, 200, 300};
  fun(arr);       System.out.println(arr[0]);//结果是800
 }
 static void fun(int[] arr) {
  arr[0] = 800;
 }
4，冒泡排序：

当内循环结束一次出现最值
相邻两个比1角标和下一个比，如果可以换位置 循环结束一次得到最大值大数一直往后跑
第二次比最后一个就不用比了循环结束后倒数第二位又出现了一个最大值，
都是从0角标开始内循环这样子，y=0 y<arr.length-x-1;y++    每次内循环最后面的几个就不用比所以让长度递减y<arr.length-x
第一个和第二个比  第二个和第三个比  即是arr[y]>arry[y+1]当数组长度为5时 5+1=6就出现了数组越界
所以要减少1：y=0 y<arr.length-x-1;y++

 

  public static void bubbleSort(int []arr)  

     {  

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

          {  

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

           {  

               if(arr[j]>arr[j+1])  

             {  

                  int temp=arr[j+1];  

                   arr[j+1]=arr[j];  

                   arr[j]=temp;  

               }  

           }  

                

          }  

            

}  

5.选择排序

原理内循环结束一次数组0角标会出现最值拿第一个数和每个数去比一次,外循环i<arr.length-1是因为循环到最后一个数的时候自己和自己比没有意义就让倒数第二个和最后一个比，内循环int j=i+1前面已经比较过的了就不用比了也是为了减少比较的次数

 public static void selectSort(int []arr)  

 {  

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

     {  

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

       {  

              if(arr[i]<arr[j])  

             {  

         int temp=arr[j];  

                   arr[j]=arr[i];  

                   arr[i]=temp;  

               }  

         }  

      }  

.         

  }  

6，折半（二分）查找，对数组元素进行查找，获取元素第一次出现的位置条件是数组必须是有序的，当中间的数小于要查找的数的时候此时中间的数的下一个数就为最小的脚本当中间的数大于要查找的数值的时候此时中间的数的前一个数就为最大的脚标

当arr[mid]!=key时就继续循环，在循环的过程中min不断变大 max不断减小所以有当最大脚标和最小脚标仍有距离时就继续循环，有2种写法：

 public static int halfSearch(int[] arr,int key)  

 {  

     int max,min,mid;  

      min = 0;  

     max = arr.length-1;  

     mid = (max+min)/2;  

   

   while(arr[mid]!=key)  

     {  

         if(key>arr[mid])  

            min = mid + 1;  

          else if(key<arr[mid])  

              max = mid - 1;  

         //System.out.println("max="+max+",min="+min);  

         if(min>max)  

              return -1;  

      mid = (max+min)/2;  

      }  

   return mid;  

   }  

 

 <pre class="java" name="code">int max=arr.length-1;  

         int min=0;  

          

          while(min<=max)  

        {  

       int mid=(max+min)/2;  

            if(arr[mid]<key)  

            min=mid+1;  

              else if(arr[mid]>key)  

                   max=mid-1;  

               else   

                  return mid;  

                

         }  

           

         return -1;  

             

.       }  

 

 数组，键盘录入，进制转换

 数组的内存分配

 在语句中定义的变量，或者函数内，函数上的变量都是局部变量存放在栈内存如int x=3在栈内存使用完后就被释放int[]x =new int[3] 其中 x栈内存中 new int【3】就在堆内存同时分配区域x【0】x【1】x【2】会有个地址如0x0089赋给x就可以通过x找到这个数组了如果x=null不会指向任何地址在栈内存的变量会自动清空  堆内存通过java的垃圾回收机制清除

7,，二进制转为10进制，10进制转为16进制 2进制转为10进制是一个不断的除二取余的过程即是%2 ，/2    10进制转为16进制按每4个二进制位对整数进行移位和去高位处理， 得到的结果就是十六进制数的一位只要&上二进制的1111即是10进制的15

10进制转为16进制有3种方法我这里就给出2种

键盘录入细节：windows中回车是由2个字符表示、\r\n，\r\n时不装入到缓存为\r\n将数据变成字符数据，回车后又将缓存清除用来保存重新输入的数据如果不是\r\n就存储所有的数据

好累了不加过多的解释有时间我在修改可以改进的给我留言我会非常感激的

 以下是通过键盘录入将字符串变成10进制的数值在转成二进制数值，还有挺多问题的有改进的地方提建议

 

  //二进制转10进制  

     public static void toBin(int num)  

    {  

          ArrayList<Integer> list = new ArrayList<Integer>();  

      while (num > 0)  

         {  

            list.add(num % 2);  

             num = num / 2;  

  

           }  

.           for (int i = list.size() - 1; i >= 0; i--)  

         {  

             System.out.print(list.get(i));  

          }  

      }  

      //键盘录入  

     public static void InputNum() throws Exception  

    {  

         StringBuilder sb = new StringBuilder();  

            

          while (true)  

          {     

             int ch = System.in.read();  

              if (ch == '\r')  

                 continue;  

               if (ch == '\n')  

              {   //当按回车的时候  

                 if(sb.length()==0)  

                  {  

                       System.out.println("转为10进制："+1310);  

                    System.out.print("转为二进制：");  

                       toBin(1310);  

                     continue;  

                  }  

                      

                  String str=sb.toString();  

                   Double value=new Double(str);  

                if(value<Integer.MAX_VALUE)  

                   {  

                     System.out.println("转为10进制："+value.intValue());  

                      System.out.print("转为二进制：");  

                       toBin(value.intValue());  

                    sb.delete(0, sb.length());  

                   }else  

                  {  

.                       System.out.println("转为10进制："+str);  

                     System.out.println("超出范围无法转换");  

                   }  

               }else  

                  sb.append(ch);  

                

          }  

      }  

 

 10进制转为16进制的其中2种方法

 public static void toHex(int num)  

      {  

        StringBuilder sb=new StringBuilder();  

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

         {  

              int temp=num&15;  

            if(temp>9)  

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

            else  

                 sb.append(temp);  

             num=num>>4;  

         }   

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

      }  

 public static void toHex2(int num)  

        

       {     

           StringBuilder sb=new StringBuilder();  

           char []chs ={  

                '0','1','2','3',  

                   '4','5','6','7',  

                 '8','9','a','b',  

                  'c','d','e','f',};  

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

         {     

            

               int temp=num&15;  

               sb.append(chs[temp]);  

           num=num>>4;  

          }  

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

     }  

       

 

语句的总结

程序流程控制是需要语言来完成的。
1，判断结构。

 if语句：
 三种格式：
 其中第二种格式if(条件表达式)else
 该种可以简写成三元运算符。？：
 简写和全写区别：
 只有当if else判断完返回结果时，才可以写成简写格式。

 好处：增强了代码的阅读性，简化了代码的书写。
 而且只要是运算符，都会有运算结果。

 只要有if后面一定有条件表达式，而条件表达式，运算后一定有boolean类型的值出现。

 

2，选择结构。
 
 swtich语句；
 特点：
 1，被选择值只能是四种类型 byte,short,intchar.
 2，case和default之间是没有顺序的。
 3，运行switch语句肯定先读第一个case，将所以case都执行完也没有匹配结果时，才会读default。
 4，switch语句只有两种情况，1，读到break语句，2，读到switch语句结束。

3，循环结构。
 while  ， do while，for。
 do while：无论条件是否满足，循环体至少执行一次。

 for：初始化表达式只执行一次，循环在条件表达式，循环体，循环后的操作表达式三者间循环。

  for(int x=0; x<3; x++)  

 {  

  System.out.println("x="+x);  

 }  

 

 int y=0;  

 for( ; y<3; )  

  {  

  System.out.println("y="+y);  

  y++;  

  }  

     

   for(;;)  

 {  

    System.out.println("yes");  

  }  

  

  while(true)  

   {  

    

  }  

 int x = 0;
  do {
   System.out.println(x); 
  } while(x++ < 10);

开发时，什么时候该用什么语句呢？

对于if和switch。都可以用于判断。
当对于几个值进行判断，可以if可以用switch建议switch，因为相对高效。

但对范围进行判断时，用if。

当对运算后结果是boolean型是也用if。

什么时候用循环呢？
当某些语句需要执行很多次的时候，使用循环结构。

使用循环需要注意：
1，控制循环条件，
2，哪些语句需要参与循环哪些不需要一定要先明确。

编程思想：
1，累加思想：
 原理：
 其实就是通过一个变量记录不断累加后的结果。在进行下一次的累加。
 还有需要进行程序自动化，也就是循环。

int sum = 0;  

 for(int x=1; x<=100; x++)  

 {  

 sum+=x;  

  }  

  System.out.println("sum="+sum);  

 

 

 

 

 

 

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