devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA小白学习日记Day2

作者：Li_阴宅 | 2024-07-31 06:02:25

赞

踩

JAVA小白学习日记Day2

1.位运算符

1.1 二进制运算

  1. //运算符
  2.         int result = 12 & 3;
  3.         System.out.println(result);//结果：0
  4.         //按位与运算  &  A&B
  5.         //将A和B转成二进制，右侧对其，上下比较，两者都为1，结果才为1，否则为0，最后转换成十进制得到结果
  6.         result = 12 & 11;
  7.         System.out.println(result);//结果：8
  8.         //按位或运算  |  A|B
  9.         result = 12 | 11;
  10.         //两者有一个为1，结果就为1，两者全为0，结果才为0
  11.         System.out.println(result);//结果：15
  12.         //按位异或运算
  13.         result = 12 ^ 11;
  14.         //两者转成二进制，右侧对其，上下比较，两者不同则为1，相同则为0
  15.         System.out.println(result);//结果：7

练习：

对两个数的值进行交换

  1. //交换变量值
  2.         int a=11;
  3.         int b=22;
  4.         int c=a;
  5.         a=b;
  6.         b=c;
  7.         System.out.println(a+"----"+b);
  8.         //加法交换
  9.         a=11;
  10.         b=22;
  11.         a=a+b;//   a=33   b=22;
  12.         b=a-b;//   a=33   b=11;
  13.         a=a-b;//   a=22   b=11;
  14.         System.out.println(a+"======="+b);
  15.         //异或运算
  16.         a=11;
  17.         b=22;
  18.         a=a^b;  //   a=29       b=22;
  19.         b=a^b;  //   a=29       b=11;
  20.         a=a^b;  //   a=22       b=11;

1.2反码运算

  1. //反码运算
  2.         result = ~11;
  3.         System.out.println(result);//结果：-12
  4.         //反码   ~   将二进制中的0换1，1换0

1.3移位运算

  1.         //移位运算    <<   向左移位，放大    >>   向右移位，缩小
  2.         result = 1<<2;
  3.         System.out.println(result);//结果：4
  4.         result = -1>>2;
  5.         //向右移位左侧补符号位
  6.         System.out.println(result);//结果：-1
  7.         result = 3>>1;
  8.         System.out.println(result);//结果：1
  9.         //   >>>   空出来的位置补0
  10.         System.out.println(Integer.MAX_VALUE);//2147483647
  11.         result = -1>>>1;
  12.         System.out.println(result);//2147483647

 首先说明正数和负数的二进制表示的区别就是负数的二进制最高位吧正数的0换成1

3的原码为：     00000000 00000000 00000000 00000011
-3的原码就是：10000000 00000000 00000000 00000011
-3 << 3  为：    10000000 00000000 00000000 00011000

比如：-2
原码转补码

原码：               00000000 00000000 00000000 00000010
取反（反码）：11111111 11111111 11111111 11111101
加一（补码）：11111111 11111111 11111111 11111110


补码转原码：

补码：              11111111 11111111 11111111 11111110
取反（反码）：00000000 00000000 00000000 00000001
加一（原码）：00000000 00000000 00000000 00000010

比如：-3>>3

原码：10000000 00000000 00000000 00000010
反码：11111111 11111111 11111111 11111101
补码：11111111 11111111 11111111 11111110

由于负数左右移动是操作的补码，所以-3右移三位补码为
补码：11111111 11111111 11111111 11111111
反码：10000000 00000000 00000000 00000000
原码：10000000 00000000 00000000 00000001
所以为-1
-3>>3=-1

无符号右移(>>>)就是不管是正数还是负数，都是补零。所以当负数进行位运算的时候会和想象的有很大的差别。

1.4其他

  1. //   &   |  也可以对boolean值运算，得到boolean值
  2.         boolean bool = true & false;//  & 和&&运算结果一样，运算过程不一样
  3.         int a=12,b=12;
  4.         bool = a++<12&b++>12;//将a和b的值转成二进制然后比较
  5.         bool = a++<12&&b++>12;
  6.         // & 与 &&的不同：&是位运算符，&&是逻辑运算符 ，&不具有短路效果，即左边false，右边还会执行；&&具有短路效果，左边为false，右边则不执行

2.赋值运算符

  1.         //赋值运算   =  +=  -=  *=  /=  %=
  2.         a=12;
  3.         a+=2;//和a=a+2不一样，只是int可以，byte类型就不行
  4.         a-=2;
  5.         a*=2;
  6.         a/=2;
  7.         a%=2;

3.三元运算符

  1.         //三元运算   A？B：C  A是boolean类型，A是true，取B，是false，取C
  2.         int result1=true?11:22;
  3.         System.out.println(result1);
  4.         result1=12.3!=48?'b':322;//这种形式也可以

练习：

System.out.println(true?3:4.0);//结果是3.0  有double类型参与要用double

4.流程控制

4.1if和switch

  1.         int score = 87;
  2.         if (score >= 60) {
  3.             System.out.println("及格了");
  4.         } else {
  5.             System.out.println("不及格");
  6.         }//必须以if开头，不能只写else
  7.  
  8.         //switch case
  9.         //匹配某一个变量的值，如果匹配到某一个case的项，就从这个case开始运行
  10.         //运行到break或者代码块结束
  11.         //所有的case项都没有匹配成功，会执行default
  12.         //case项和default项的顺序可以打乱
  13.         //switch可以匹配的类型char, byte, short, int, Enum（枚举），String
  14.         int num = 2;
  15.         switch (num) {
  16.             case 1:
  17.                 System.out.println("春");
  18.                 break;
  19.             case 2:
  20.                 System.out.println("夏");
  21.                 break;
  22.             case 3:
  23.                 System.out.println("秋");
  24.                 break;
  25.             case 4:
  26.                 System.out.println("冬");
  27.                 break;//如果不加break，会从2（夏）开始一直到4（冬）运行到代码块结束，输出夏秋冬
  28.             default:
  29.                 System.out.println("季节");
  30.         }

 4.2循环

  1.         //循环
  2.         //while (继续循环的条件){
  3.         //    循环体
  4.         //}
  5. //        int i='a';
  6. //        while (i<'e'){
  7. //            System.out.println((char)i);
  8. //            i++;
  9. //        }
  10.         //do...while至少执行一次，先执行后判断
  11. //        do {
  12. //        }while();
  13.  
  14.         //for循环
  15. //        for(;;){
  16. //            //无限（死）循环
  17. //        }
  18.         for (int n = 0; n < 10; n++) {
  19.             System.out.println(1 + n);
  20.         }
  21. //
  22.         Math.random();//[0,1）随机数
  23.         int cat = 100;
  24.         int count = 0;
  25.         int mouse = (int) (Math.random() * 120);
  26.         while (cat > mouse) {
  27.             count++;
  28.             mouse = (int) (Math.random() * 120);
  29.         }
  30.         System.out.println("猫抓了" + count + "只老鼠。");
  31.         int num1 = 0;
  32.         for (int i = 1; i <= 100; i++) {
  33.             if (i % 3 == 0) {
  34.                 num1 += i;
  35.             }
  36.         }
  37.         System.out.println(num1);
  38.         //break 直接跳出循环体   confinue结束当前一次循环，开始下一次循环
  39.         for (int aa = 1; aa < 10; aa++) {
  40.             if (aa % 7 == 0) {
  41. //                break;
  42.                 continue;
  43.             }
  44.             System.out.println(aa);
  45.         }
  46. //        boolean bool=true;
  47. //        easy:for (;;){
  48. //            for (;;){
  49. //                for (int bb=0;bb<100;bb++)
  50. //                {
  51. //                    if (bb%5==0)
  52. //                    {
  53. //                        break easy;//通过easy来使break跳出多重循环
  54. //                    }
  55. //                    System.out.println(bb);
  56. //                }
  57. //            }
  58. //        }
  59.         //死循环  没有循环结束的条件，之后不能写其他代码
  60.         //无限循环  结束循环的条件永远达不到，可以编写其他代码
  61. //        while (true){
  62. //      }死循环
  63. //        a=0;
  64. //        while(a<100){a--}无限循环
  65.         //死循环会直接报错，无限循环默认有条件可以循环

5.数组

  1.         //数组
  2.         //定义
  3.         int[] arr={1,2,3,4};
  4.         int[] arrB=new int[]{1,2,3};
  5.         //这两种是静态的
  6.         int[] arrA=new int[4];//通过长度定义数组  【4】代表可以存放四个元素
  7.         //这是动态的
  8.         //数组的限定
  9.         //1.只能存放指定类型的数据
  10.         //2.数组的长度是不可变的
  11.         //使用数组的元素    下标  从0开始依次增加
  12.         System.out.println(arr[3]);//结果：4
  13.         System.out.println(arr);//显示数组的地址
  14.         arr[0]=99;//给数组元素赋值
  15.         System.out.println(Arrays.toString(arr));//将数组转化成字符串打印
  16.         //获取数组长度
  17.         System.out.println(arr.length);
  18.         //打印出arr数组中所有元素
  19.         for (int i=0;i<arr.length;i++){
  20.             System.out.println(arr[i]);
  21.         }
  22.  
  23.         //二维数组  将一维数组中的元素变成一维数组
  24.         int[][] arrs=new int[4][3];
  25.         arrs[0][1]=12;
  26.         System.out.println(Arrays.deepToString(arrs));
  27.         //二维数组的限定   一维数组的个数不可变（比如上述arrs的【4】)也就是大的数组个数不可变
  28.         arrs[2]=new int[]{1,2,3,4};
  29.         System.out.println(Arrays.deepToString(arrs));
  30.         //声明一个二维数组  使用随机数为每个元素赋值
  31.         int[][] arrC=new int[5][4];
  32.         for (int i=0;i<arrC.length;i++){
  33.             System.out.println(Arrays.toString(arrC[i]));
  34.             for (int j=0;j<arrC[i].length;j++){
  35.                 arrC[i][j]=(int)(Math.random()*100);
  36.             }
  37.             System.out.println(Arrays.toString(arrC[i]));
  38.         }
  39.         System.out.println(Arrays.deepToString(arrC));
  40.  
  41.         //数组下标越界
  42.         arr=new int[4];
  43.         System.out.println(Arrays.toString(arr));
  44.         arr[2]=9;
  45. //        arr[4]=11;报错越界

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/907319
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号