一、逻辑运算符
-
&&、||、!
-
&& || 和& |的区别
&和|是位运算符,是对数字进行运算
&&和||是逻辑运算符,是对布尔值进行运算
&&和||有短路的现象,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主要用于判断多态的情况下的对象和类的关系
四、运算符优先级
-
() .
-
一元:++,--,!,~
-
乘除:*,/,%
-
加减:+,-
-
位移:<<,>>,>>>
-
关系:==,!=,>,<,>=,<=
-
与:&
-
异:^
-
或:|
-
逻辑:&&,||
-
三目:?:
-
赋值:=,乘除,加减,位移和赋值混合
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);
}
}
}