Java学习（2）

整数运算

1、java的整数运算遵循四则运算的规则，可以使用任意镶嵌的小括号。

public class Demo1 {
    public static void main(String[] args) {
        int x = (100 + 200) * (300 + 400);
        System.out.println(x);
         //加和乘
        int x = (100 + 200) * (300 + 400);
        System.out.println(x);
        // 除 获取结果的整数部分
        int y = 200 / 3;
        System.out.println(y);
        // 除 取余数
        int n = 200 % 3;
        System.out.println(n);
        // 溢出 不会报错结果为负值
        int a = 2147483640;
        int b = 100;
        int sum1 = a + b;
        System.out.println(sum1);
        // 溢出正确写法
        int c = 2147483640;
        int d = 10;
        long sum2 = c + d;
        System.out.println(sum2);
    }
}

浮点数运算

package java_study;
public class Demo1 {
    public static void main(String[] args) {
        // 浮点数运算
        double e = 1.0 / 10;
        double f = 1 - 9.0 / 10;
        System.out.println(e);
        System.out.println(f);
        // e,f 值不一样说明浮点数之间的计算存在误差，如需判断两者是否相同，比较方法是判断两个浮点数之差是否小于一个很小的数
        double g = Math.abs(x - y);
        // 判断绝对值之差是否足够小
        if (g < 0.00001) {
            System.out.println("两者相等");
        } else {
            System.out.println("两者不相同");
        }

        // 类型提升 : 如果参与运算的两个数其中一个是整型，那么整型可以自动提升到浮点型
        int h = 5;
        double i = 1.2 + 24.0 / h;//6.0
        System.out.println(i);

        // 注：在一个复杂的运算中，两个整型类型的数据进行运算不会出现自动提升的情况
        double j = 1.2 + 24 / h;
        System.out.println(j);

        // 溢出：整数运算在除数为零时会报错，而浮点数运算在除数为零时，不会报错，会返回几个特殊值
        // NaN 表示not a number
        // Infinity 表示无穷大
        // -Infinity 表示无穷小
        double k1 = 0.0 / 0;//NaN
        double k2 = 1.0 / 0;// Infinity
        double k3 = -1.0 / 0;// -Infinity


        // 强制转型
        int l1 = (int) 12.3; //12
        int l2 = (int) 12.7;//12
        int l3 = (int) -12.7;//-12
        int l4 = (int) (12.7 + 0.5);//13
        int l5 = (int) 1.2e20;//
        //四舍五入 ：加上0.5强制转型

    }
}

布尔运算

1、布尔（boolean）运算的返回值：True;False
2、比较运算符：>,>=,<,<=,==,!=
与运算：&&
或运算：||
非运算：！

示例：
package java_study;

public class Demo2 {
    public static void main(String[] args) {
        // 布尔运算
        boolean isGreater = 5 > 3; // True
        int age = 12;
        boolean isZero = age == 0; //False
        boolean isNonZero = !isZero;//True
        boolean isAdult = age > 18;//False
        boolean isTeenager = age > 6 && age < 18;// true
        System.out.println(isZero);
        System.out.println(isNonZero);
        System.out.println(isAdult);
        System.out.println(isTeenager);
    }
}

3、关系运算符的优先级从高到低
---- !
---- >,>=,<,<=
---- ==,!=
---- &&
---- ||
4、短路运算
短路运算：如果一个布尔表达式能提前确定结果，则后续的计算不在执行，直接返回结果
例：false&&x;结果为false
5、三元运算符
b?x：y -----根据第一个布尔表达式的结果分别返回后续两个表达式之一的计算结果
```
package java_study;

public class Demo2 {
public static void main(String[] args) {
// 三元运算符
int n = -100;
int x = n >= 0 ? n : -n;
System.out.println(x);
}
}

```

字符和字符串

字符与字符串是两个不同的类型
1、字符类型
1.1、字符char是基本数据类型，一个char保存一个U字符

			char c1 = 'A'；
			char c2 = '中'；

1.2、显示Unicode编码：直接将char类型赋值给int类型

			int n1 = 'A';
			int n2 = '中'

1.3、直接用转义字符 \u + Unicode编码表示一个字符

		char c3 = '\u0041';
		char c4 = '\u4e2d';

2、字符串类型
2.1、一个字符串可以存储0到任意个字符

// 字符串类型
        String s = "";
        String s1 = "A";
        String s2 = "ABC";
        String s3 = "中文 ABC";
        String s4 = "中文 \"ABC";
        String s5 = "\\";
        

2.2、常见的转义字符
" 表示字符"
’ 表示字符’
\ 表示字符
\n 表示换行符
\r 表示回车符
\t 表示Tab
\u#### 表示一个Unicode编码的字符

String s = "ABC\n\u4e2d\u6587"; // 包含6个字符: A, B, C, 换行符, 中, 文

3、字符串连接
3.1、可以使用“+”连接任意字符串和其他数据类型，使用“+”连接字符串和其他数据类型，会将其他数据类型转为字符串
3.2、多行字符串
从java13开始可以使用"“”…“”"表示多行字符串

String s6 = """ 
                SELECT * FROM
                users
                WHERE id > 100
                ORDER BY name DESC""";

3.3、不可变特性

        // 字符串的不可变性
        String a = "hello";
        System.out.println(a);//打印hello
        a = "world";
        System.out.println(a);//打印word
    }
}

注：执行 String a = “hello”;时，JVM虚拟机首先创建字符串"hello",然后把字符串变量a指向它；
在执行a = “world"是，JVM虚拟机先创建字符串"world”,然后把字符串变量s指向他；
远在的字符串"hello"还在，只是我们无法访问他；因此字符串的不可变指的是字符串的内容不可变
4、控制null
引用的类型变量可以指向一个空值null，表示他不存在，即该变量不指向任何对象

String s1 = null; // s1是null
String s2; // 没有赋初值值，s2也是null
String s3 = s1; // s3也是null
String s4 = ""; // s4指向空字符串，不是null

数组类型

package java_study;

public class Demo2 {
    public static void main(String[] args) {
        // 数组类型
        int[] ns = new int[5];
        ns[0] = 68;
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
        System.out.println(ns[0]);
    }
}

1、定义一个数组类型变量，使用数组类型“类型[]”，例如int[]。和单个基本类型变量不同，数组变量初始化必须使用 new int[5]表示创建一个可容纳5个int元素的数组。
2、java数组的几个特点：
数组所有元素初始化默认值，整型都是0，浮点型时0.0，布尔型是false;
数组一旦创建大小不可改变
3、访问数据使用索引；修改数组中的某一个元素；使用数组变量.length获取数组大小；

package java_study;

public class Demo2 {
    public static void main(String[] args) {
        // 数组类型
        int[] ns = new int[5];
        ns[0] = 68;
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
        System.out.println(ns[0]);
        System.out.println(ns.length);
        ns[2] = 99;
        System.out.println(ns[2]);
    }
}

4、数组是引用类型，在使用索引访问数组元素数，如果索引超过范围就会报错，
5、可以在定义数组时直接赋值

int[] ns = new int[] { 68, 79, 91, 85, 62 };
// 可以简写
int[] ns = { 68, 79, 91, 85, 62 };

6、

int[] ns = new int[] {68,79,91,85,62};
System.out.println(ns.length);
ns = new int[]{1,2,3};
System.out.println(ns.length);

对于数组ns来说，执行ns = new int[] { 68, 79, 91, 85, 62 };时，它指向一个5个元素的数组;
执行ns = new int[] { 1, 2, 3 };时，它指向一个_新的_3个元素的数组;
但是，原有的5个元素的数组并没有改变，只是无法通过变量ns引用到它们而已。
7、字符串数组

String[] names = {
    "ABC", "XYZ", "zoo"
};

对于String[]类型的数组变量names，它实际上包含3个元素，但每个元素都指向某个字符串对象;
对names[1]进行赋值，例如names[1] = “cat”;
names[1]指向的字符串"XYZ"并没有改变，仅仅是将names[1]的引用从指向"XYZ"改成了指向"cat"，其结果是字符串"XYZ"再也无法通过names[1]访问到了。