• Java第五课


    Java第五课

    一、逻辑运算符

    • &&、||、!

    • && || 和& |的区别

      &和|是位运算符,是对数字进行运算

      &&和||是逻辑运算符,是对布尔值进行运算

      &&和||有短路的现象,A&&B,如果A为false,则B不被检查

      public class C231 {
         public static void main(String[] args) {
             boolean result = A() && B();
             System.out.println("---------------------");
             result = A() || B();
        }

         private static boolean A() {
             System.out.println("enter A");
             boolean result = false;
             Random random = new Random();
             result = random.nextBoolean();
             System.out.println("result = "+ result);
             return result;
        }
         private static boolean B() {
             System.out.println("enter B");
             boolean result = false;
             Random random = new Random();
             result = random.nextBoolean();
             return result;
        }
      }

    二、赋值运算符

    • =、+=,-=.....

      int num = 1;
      num += 2;
    • byte b = 1;
      b = b + 2;
      // 错误的,因为2是int型,会把整个表达式的数据类型提升至int型,而赋值的左边是byte型,此时会报错。b=(byte)(b+2);(b+2)是int型,通过(byte)型强制转换为byte型
      b+=2;
      // 此处的2是byte型,不存在上述问题,一种语法糖的现象,JVM自动帮程序员做了一些处理

    三、三目运算符

            byte num = 1;
           boolean b = num == 3 ? true:false;
           String msg = (num == 3) ? "yes" : "no";
    System.out.println(c231 instanceof C231);
    // c231是否是C231类的实例
    // instanceof主要用于判断多态的情况下的对象和类的关系

    四、运算符优先级

    1. () .

    2. 一元:++,--,!,~

    3. 乘除:*,/,%

    4. 加减:+,-

    5. 位移:<<,>>,>>>

    6. 关系:==,!=,>,<,>=,<=

    7. 与:&

    8. 异:^

    9. 或:|

    10. 逻辑:&&,||

    11. 三目:?:

    12. 赋值:=,乘除,加减,位移和赋值混合

    public class C233 {
       public static void main(String[] args) {
           byte n1 = 5;
           byte n2 = 6;
           // 5+6*7
           int n3 = n1++ + n1++ * n1++;
           System.out.println(n3);
            byte n1 = 5, n2 = 6;
           // 5 + 4 << 2 + 4 * 5 >> 2
           // 5 + 4 << 2 + 20 >> 2
           // 9 << 22 >> 2
           int n3 = n1-- + n1 << 2 + n1++ * --n2 >> 2;
           System.out.println(n3);
           byte b1 = 8, b2 = 3;
           // 8 - 3 * (8 * 8 << 2)
           // 8 - 3 * 256
           int num = b1-- - b2++ * (++b1 * b1 << 2);
      }
    }
            byte b1 = 2;
           byte b2 = 3;
           // 关系运算符比&|^运算符的优先级高
           System.out.println(b1>b2 & b2>b1);
           System.out.println(b1>b2 | b2>b1);
           System.out.println(b1>b2 ^ b2>b1);
           System.out.println(true & false);
        public static void main(String[] args) {
           byte b1 = 7;
           byte b2 = 9;
           byte b3 = 10;
           byte b4 = 12;
           // 7 & 9 ^ 10 | 12
           // 0000 0111
           // 0000 1001
           // 0000 0001
           // 0000 1010
           // 0000 1011
           // 0000 1100
           // 0000 1111
           System.out.println(b1 & b2 ^ b3 | b4);
      }
        public static void main(String[] args) {
           byte b1 = 7;
           byte b2 = 9;
           byte b3 = 10;
           byte b4 = 12;
           // 7+(9+(9+9))
           System.out.println(b1++ + (++b1 + (b1-- + ++b1)));
      }
        public static void main(String[] args) {
          byte b1 = 5;
          byte b2 = 6;
          // 5 | 6 ^ 7 & 4 * 7 * 3
          int num = b1++ | b2-- ^ ++b1 & --b2 * b1-- * --b2;
          // 0000 0111
           // 0101 0100
           // 0000 0100
           // 0000 0110
           // 0000 0010
           // 0000 0101
           // 0000 0111
           System.out.println(num);
      }

    五、动态数组

    • 数组本身是固定元素个数的,但是为了储存数据,这个数组可能会满,解决这个问题。发现数组满了,就新建一个更大的数组,把原数组的数据复制过来,并销毁原数组。

    • 数组就像一个仓库。一次性新建超大仓库不可取,会浪费空间。每次都比原来的大一点,也不可取,会效率低下。

    • 新建仓库是原来的1.5倍比较合适。

    • 比如:原数组int[] arr = new int[]{1,2,3,4}

    • 4 + (4>>1) arr.length + (arr.length >> 1)

    • int[] newArr = new int[6];

    • for(int i = 0; i<arr.length;i++){

      newArr[i] = arr[i];

      }

    public class C234 {
       /**
        * 存储数据的数组
        */
       int[] arr;
       /**
        * 当前的位置
        */
       int index = 0;

       /**
        * 无参的默认构造方法
        */
       public C234() {
           // 知识点,构造方法嵌套调用,直接写this,不写方法名
           // 此代码只能是第一行
           this(4);
      }

       /**
        * 初始化对象
        * @param capacity 数组初始值
        */
       public C234(int capacity) {
           this.arr = new int[capacity];
      }
       public static void main(String[] args) {
           C234 c234 = new C234();
           for (int i = 0; i < 10; i++) {
               c234.add(i);
          }
           System.out.println(Arrays.toString(c234.arr));
      }

       /**
        * 增加一个数字
        * @param num
        */
       public void add(int num) {
           if (index < arr.length) {
               arr[index++] = num;
          }else {
               int length = arr.length + (arr.length >> 1);
               arr = Arrays.copyOf(arr, length);
          }

      }
    }



    软件下载提取码:qwer
  • 相关阅读:
    如来神掌第一式第十九招----Samba 详解
    如来神掌第一式第十八招----PXE 详解
    如来神掌第二式第七招----典型shell示例
    如来神掌第二式第六招----Shell游戏案例之猜数字
    如来神掌第二式第五招----Shell游戏案例之贪吃蛇
    如来神掌第二式第四招----Shell应用案例之网络监控
    如来神掌第二式第三招----Shell应用案例之主机监控
    如来神掌第二式第二招----Shell应用案例之大文件删除
    如来神掌第二式第一招----Shell脚本基础
    如来神掌第一式第十七招----Mysql 详解
  • 原文地址:https://www.cnblogs.com/ty0910/p/14435334.html
Copyright © 2020-2023  润新知