java基础3

1. 数据类型：boolean

• boolean类型，即布尔类型，适用于逻辑运算，一般在程序流程控制中作为条件判断。
• boolean类型的值只有两个：true/false。不能用0或非0代替true/false。
• boolean类型不能与整数类型做转换

boolean b = false;
if(b){
    // do something
}
 
for(int i = 0; b; i++){
    // do something
}

2. 数据类型转换

• 数据(byte,short)运算之后，结果转换为int了。数据运算的结果，以范围大的为准
• 强制转换：大类型不能直接赋值给小类型，使用强制转换的语法规则，进行数据类型转换。
• 强制数据类型转换：可能会溢出，也可能会损失精度

//强制数据类型转换：可能会溢出，也可能会损失精度
	long data5 = 10000000000L;  // 100亿
	int data6 = (int)data5;
	System.out.println(data6);  // 溢出
	double pi = 3.1415926535897932384;
	float f = (float)pi;
	System.out.println(f); // 损失精度

• boolean类型不能和其他类型转化。
• 强制数据类型转换：从大类型，转到小类型，需要强制转换，可能会有精度损失或者溢出。
• 语法规则：数据类型 变量名 = （数据类型）数据

	long data5 = 10000;
	int data6 = (int)data5;

• 自动数据类型转换（隐式转换）：小类型，自动转为大类型。

  

public class DataTypeDemo{
    public static void main(String[] args){
        // 隐式转换： 小类型自动转为大类型
        byte a1 = 10; // 10是直接量（字面量），编译的时候，可以判断赋值是正确的。
        int k = 3;
        // byte a2 = k;  // k是变量，并且k是int类型，不能直接赋值给byte类型。
        short a2 = a1;
        int a3 = a1;
        long a4 = a1;
        double a5 = a1;
        
        // 强制转换：大类型不能直接赋值为小类型，使用强制转换的语法规则，进行数据类型转换
        // a1 = a4;  // long类型赋值给byte。大类型不能直接赋值给小类型。需要强制转换。
        a1 = (byte)a4;
        
        // boolean类型不能和其他类型转换。
        // boolean a6 = a1;
        boolean a6 = false;
        // a1 = (byte);  boolean 类型不能转换为byte
        
        int a7 = -100000; // 10万
        char a8 = (char)a7; // 强转
        System.out.println(a7);  //34464
        System.out.println((int) '中');  // 20013
        
        // 面试题：
        byte b1 = 5;
        byte b2 = 5;
        // byte b3 = b1 + b2;  // 编译错误：数据(byte,int)运算之后，结果转换为int了。
        					   //  数据运算的结果，以范围大的为准。
        byte b3 = (byte)(b1 + b2);  // 把运算结果，强转为byte。 （int转为byte）
        int b4 = b1 + b2; // 把运算结果（int），赋值给了能存放的数据类型int
        
        short bb1 = 5;
        short bb1 = 5;
        //short bb3 = bb1 + bb2; // 编译错误：直接量（字面量5默认类型是int）运算的结果是int，此时int赋值给short（大类型赋值给小类型）就会报错
        int bb3 = bb1 + bb2;  // 此时正确
    }
}

3. 运算符

3.1 算术运算符

• 算术运算符：+(加or正数)，-(减or负数)，*(乘)，/(除)，%(取余or模)，++(变量自己增加1)，–(变量自己减少1)

public class Demo1{
    public static void main(String[] args){
     	int m = 20;
        double k = 10.5;
        System.out.println( m / 5); // 取整
        System.out.println( k / 5); // 除法的结果
        // 输出1~1000中能被11和21同时整除的数据
        for(int i = 1; i <= 1000; i++){
            if(i % 11 == 0 && i % 21 == 0){
                System.out.println(i);
            }
        }
        // 判断一个数据是否为整数，比如70.5
        double data = 70.5;
        if(data % 1 == 0){
            System.out.println("是整数");
        }else{
            System.out.println("不是整数");
        }
        
        // 前后自增对于变量本身来说，都是要加 1，对于赋值运算中，会影响赋值的结果。
        // 后自增
        int n = 5;
        int num = n++; // ++在变量n的前面，先把n的值增加1，然后把n增加之后的数据值，赋值给变量num
        System.out.println("num "+num);// num就是5
        System.out.println("n "+n);// n自增1，所以n就是6
       	// 前自增
        int n = 5;
        int num = ++n;  // ++在变量n的前面，先把n的值增加1，然后把n增加之后的数据值赋值给变量num
        System.out.println("num "+num); // num就是6
        System.out.println("n "+n);	// n也是6
        
        int a0 = 5;
        // int a1 = a0++ + ++ a0;// 5 + 7 ==> 12
        // System.out.println("a0:"+a0); //  7
        // System.out.println("a1:"+a1); //  12: a0取出来是5 + (a0++ 之后是6， ++a0 是7)= 5+7=12
        int a2 = ++a0 + ++ a0;
        System.out.println("a0:"+a0);  // 7
        System.out.println("a2:"+a2); // 13
        
        int a3 = ++a0; // a0 是8， a3是8
        
        int a4 = 100;
        a4 = -a4;  // 负数
        a4 = -a4;  // 正数
        System.out.println("a4:"+a4); 
        System.out.println("绝对值："+Math.abs(-20));  // absolute: 绝对值
        
        // 自减同理
    }
}

3.2 关系运算符

• Java中的关系运算符，包含：>（大于）,<（小于）,==（等于）,>=（大于等于）,<=（小于等于）,!=（不等于）。

• 关系运算的结果为boolean类型

// 关系运算：
public class Demo2{
  public static void main(String[] args){
      int a = 100;
      int b = 100;
      boolean c = a++ > b++;  
      System.out.println("c:"+c);
      b--;
      c = a < b;  
      System.out.println("c:"+c);
      // 练习：判断一个数据不是一个整数
      double data = 70.5;
      if(data % 1 == 0){
          System.out.println("是整数")；
      }else{
          System.out.println("不是整数")；
      }
      // 练习：判断两个数组中的元素是否一一对应相等
      // 数组：引用类型，变量中存储的是引用地址。
      // *** 基本数据类型，可以使用==判断数据值是否相等。引用类型不能使用==判断其数据值是否相等。
      // int :基本数据类型
      int[] arr1 = {10,20,30,40,60};
      int[] arr2 = {10,20,30,40,50};
      System.out.println(arr1); // [I@6bf256fa
    System.out.println(arr2); // [I@6cd8737
      System.out.println(arr1==arr2); // false
      // 判断数据值是否相等
      boolean flag = true;  // 代表两个数组数据相等
      for(int i = 0; i < arr1.length; i++);{
          if(arr1[i]!=arr2[i]){ // 关系运算符的结果为boolean
              flag = false;  //代表两个数组不相等
              break; // 结束循环
          }
      }
      if(flag){
          System.out.println("两个数组中的元素相等");
      }else{
          System.out.println("两个数组中的元素不相等");
      }
      // 练习：计算1~100中，能被3整除的数据的和
      int sum = 0;
      for(int i = 1; i <= 100; i++){
          if(i % 3 == 0){
              sum = sum + i;
              System.out.print(i+" ");
          }
      }
      System.out.print("sum:"+sum);

      // 练习：产生10个100以内的随机整数，如果产生的数开平方后小于等于6，就给该数加上100以内的随机整数，最后对这些数据进行排序，然后输出这些数据
      int[] data1 = new int[10];
      for(int i = 0; i < data1.length; i++){
          int rnum = (int)(Math,random()*100);
          data1[i] = rnum;
      }
      System.out.println("原数组："+Arrays.toString(data1));
      for(int i = 0; i < data1.length; i++){
          if(Math.sqrt(data1[i])==6){
              System.out.print(data[i]+"+"+(int)(Math.random()*100)+"=");
              data1[i] = data1[i] + (int)(Math.random()*100);
              System.out.print.(data1[i]+" ");
          }
      }
      System.out.println("\n"+"修改后"+Arrays.toString(data1));
      // 排序
      Arrays.sort(data1);  // jdk提供的类中的排序方法，对数据进行排序
      System.out.println("排序后："+Arrays.toString(data1));
  }
}

3.3 逻辑运算

运算规则：与运算，两真为真；或运算，两假才假；非运算，真变假，假变真。

• &&

• ||

• !

• 逻辑运算的结果为boolean类型

  A	b	!a	a&&b	a||b	a&b	a|b
  true	true	false	true	true	true	true
  True	false	false	false	true	false	true
  False	true	true	false	true	false	true
  false	false	true	false	false	false	false

• "短路逻辑"的原则

// 对于&&运算，如果第一个结果为false，那么其后的运算将不再执行。
int a = 3, b = 5;
boolean b1 = a > b && a++>0; // 根据运算顺序从左往右计算，左边逻辑结果已经为false，所以后面的逻辑运算将会跳过而执行
// 对于||运算，如果第一个为结果true，那么其后的运算也将不再执行。
int a = 3,b =5;
boolean b1 = a < b || a++>0;  // 后面的a++>0不会判断

• 练习代码

// 逻辑运算： &&、||、！，短路逻辑：如果逻辑运算的结果由第一个表达式已经得到了，那么就不计算第二表达式。
//          &  、| ----不短路逻辑：参与逻辑运算的表达式都需要计算结果，使用较少，效率没有短路逻辑高
public class Demo3{
    public static void main(String[] args){
        // 闰年的判断 ：能被4整除，但不能100整除、或者能被400整除
       	int year = 1988;
        //boolean flag = isRunYear(year);
        String str = ((year % 4 == 0 && year % 100 != 0)|| year % 400 == 0) ? "是闰年":"是平年";
        System.out.println(year + str);
        
        if(flag){
            System.out.println("是闰年"); // 闰年：366
        }else{
            System.out.println("是平年"); // 平年：365
        }
        
         // 练习：1~100以内的能同时被2,3,5整除的数的和
        int sum = 0;
        fot(int i = 1; i < 100; i++){
            if(i % 2 == 0 && i % 3 == 0 && i % 5 == 0){
                sum = sum + i;
            }
        }
        System.out.println("sum:"+sum);
        
       	// 短路与
       	int a = 3,b =5;
        boolean b1 = a > b && a++ > 0;  // 短路与， 第一个表达式已经决定了逻辑运算的结果，所以第二个表达式不执行
        System.out.println("b1:"+b1);
        System.out.println("a:"+a); // 3
        // ***不短路与
        int a0 = 3,b0 = 5; 
        boolean boo = a > b && a0++ > 0;  // 不短路与，第一个表达式，第二个表达式都要执行，所以a0++会被执行
        System.out.println("boo:"+boo);
        System.out.println("a0:"+a0); // 4
        // 短路或
        int a2 = 3,b2 = 5;
        boolean boo2 = a2 < b2 || a2++ > 0; // 短路或， 第一个表达式已经决定了逻辑运算的结果，所以第二个表达式不执行
        System.out.println("boo2:"+boo2);
        System.out.println("a2:"+a2); // 3
        // 不短路或
        int a3 = 3,b3 = 5;
        boolean boo3 = a2 < b2 | a2++ > 0; // 短路或， 第一个表达式已经决定了逻辑运算的结果，所以第二个表达式不执行
        System.out.println("boo3:"+boo3);
        System.out.println("a3:"+a3); // 4
        
    }
    public static boolean isRunYear(int year){
        if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
            return true;
        }else{
            return false;
        }
    }
}

3.4 赋值运算

• 赋值运算符“=”是最常用的赋值运算符。它将“=”右边的运算结果的值，赋给“=”左边的变量。

• 赋值运算符的优先级最低。（低于算术运算符）

• 赋值运算符吸纳计算右边的值，再赋值给左边的变量。

  int a,b,c;

  a = b = c = 200; // 计算顺序：从右往左依次赋值

3.5 扩展的赋值运算

• 在赋值运算符的前面，加入算术运算符，即为扩展赋值运算符。

• +=，-=，*=，/=，%=

int a = 5;
a += 10; // a = a + 10;  -- 扩展运算符效率高
// 当我们使用变量自己和某个数进行运算的时候，可以使用扩展运算符，简化表达式。
int sum = 0;
sum += a;
sum -= b;
sum *= c;
sum /= d;
sum = a + b;  // 无法使用扩展的赋值运算符

3.6 “+”字符串拼接

• 运算符“+”，用于数据类型，加法运算

• 运算符“+”，用于字符串型，字符串拼接运算

• 字符串（String）+ 数据，java中会自动将数据转换为字符串，然后两个字符串相连，生成一个新的字符串。

String s = 1+2+3+"";  // 因为数字在前面，所以先加法运算，再字符串拼接
String s1 = ""+1+2+3; // 因为顺序是从左往右，字符串在前面先作运算，所以变为了字符串的拼接
String s2 = ""+(1+2+3); // 括号改变了运算的优先级 
System.out.println("s:" + s); // "6"
System.out.println("s1:" + s1); // "123"
System.out.println("s2:" + s2); // "6"

3.7 三目运算符

• 三目运算符格式：

  X?Y:Z —boolean表达式？表达式1：表达式2;

• X为boolean表达式，如果X为true，则运算结果为Y的值，如果X为false，则运算结果为Z的值。

  eg: int a = 5,b =6;

  int max = a > b ? a : b; // 找出a，b中的最大值

// 三目运算：？，可以简化简单的if..else
int a1 = 5;
int b1 = 10;
int max1 = a1 > b1 ? a1 : b1;  // 10
// int a2 = 5 > 3 ? 5 : 5.5;   // 编译错误：结算结果中存在double类型数据，不能直接将double类型赋值给int类型变量
double a2 = 5 > 3 ? 5 : 5.5; // 将赋值变量改为double即为正确
System.out.println("a2:"+a2);

4. 数据类型的使用

随机生成字母

public class Home2{
    // 生成随机的字符
    public static void main(String[] args){
        double r = Math.random(); // r 范围[0,1)
		// [65,90] --->[65,91)
        // 91 - 65 = 26
        // r * 26 ==>得到[0,26)的任意一个数
        // [0,26) + 65  ==> 得到这个[65,91)区间嘞数
        double rnum = r * ('Z' -'A' - 1) + 'A'; // r * 26
        char c = (char)(Math.ceil(rnum)); // rnum = 90.9
        System.out.println(c);
        // 取整相关的函数
        System.out.println(Math.round(90.6));  // 四舍五入  - 91
        System.out.println(Math.round(90.4));  // 四舍五入  - 90
        System.out.println(Math.floor(90.6));  // 向下取整  - 90
        System.out.println(Math.ceil(90.6));   // 向上取整  - 91
    }
}