java 02()

java变量&数组&标准输入输出&运算符&String

~~ 有出错的地方，我会及时改正owo ~~

标识符（好像包含关键字）命名规则

  • 标识符由字母、数字、下划线、美元等（比如中文也可以但不是所有unicode中所有都可以 比如#）组成
  • 不能用关键字哦（会有歧义）
  • 尽量见名知意（为人方正）
  • 类 驼峰原则 变量、方法 第一个单词首字母不大写 常量全部大写（单词之间用下划线分割） 包要小写（好像和不同系统区分大小写有关 所以这么搞）

java常量

  • 声明 : final 常量类型 常量标识符
  • 只能给一次 值不可以改变了

java变量

  • 程序的基本组成单位
  • 三要素 ： 类型 + 名称 + 值
  • 知道变量对应计算机内存里会怎么样
  • 变量在同一作用域不能重名(一个班重名会有歧义)

数据类型

  • 整数四种(long) 浮点数两种 char boolean(true|false) 三个引用数据类型 类、引用、接口
  • 整形

    知道为啥能表示的数是这个范围
    整形常量默认int型，long的要加L
    整形有固定字段长度（和字节可能不太一样）和表示范围，不受OS的影响
    bit计算机中最小的存储单位，byte基本的存储单元

  • 知道为啥能表示的数是这个范围
  • 整形常量默认int型，long的要加L
  • 整形有固定字段长度（和字节可能不太一样）和表示范围，不受OS的影响
  • bit计算机中最小的存储单位，byte基本的存储单元
  • 浮点型

    为啥这个范围

    常量默认double，float要加f，常量有两种表示方式： 十进制数（.12）、科学计数法（5.12e2）；

    浮点也有固定字段长度和表示范围，不受os影响

    浮点数不精确 ，最好用double（或许这就是为什么默认是double）， 比较最好还是做差比某个数小
    v. 虽然double能被浮点型的数赋值，但没有直接的double来的准确

  • 为啥这个范围
  • 常量默认double，float要加f，常量有两种表示方式： 十进制数（.12）、科学计数法（5.12e2）；
  • 浮点也有固定字段长度和表示范围，不受os影响
  • 浮点数不精确 ，最好用double（或许这就是为什么默认是double）， 比较最好还是做差比某个数小
    v. 虽然double能被浮点型的数赋值，但没有直接的double来的准确 
    double num10 = 2.1234567851;
	double num11 = 2.1234567851f;
    // 这两值不一样
  • 字符型

    两个字节
    没有负号（无符号型），java没有unsigned
    值能有’字符’,65 97 48,转义字符（\u四个数字可带表十六进制对应的字符,\uface）
    字符在计算机中，直接存数（按照的是unicode编码表，有点浪费空间，汉字和字母都一样，文件保存为什么类型是你写的代码对应的字符，不关人家java字符的事）

  • 两个字节
  • 没有负号（无符号型），java没有unsigned
  • 值能有’字符’,65 97 48,转义字符（\u四个数字可带表十六进制对应的字符,\uface）
  • 字符在计算机中，直接存数（按照的是unicode编码表，有点浪费空间，汉字和字母都一样，文件保存为什么类型是你写的代码对应的字符，不关人家java字符的事）
  • 布尔型(boolean)

    值只有true和false（不能用01代替，好像为了强类型？）
    变量占四个字节 数组占一个字节(数组会被当初byte数组)

  • 值只有true和false（不能用01代替，好像为了强类型？）
  • 变量占四个字节 数组占一个字节(数组会被当初byte数组)

数组

  • 数组也是数据类型 ，是引用数据类型（解释二维数组有用）
  • 创建以后长度就确定了，有length这个属性
  • 定义一个数组：声明数组 + 创造数组 ， 各有两种方式
    double[] scores = new double[5]; // 动态初始化
	double scores2[] = {3.14,2.2};
  • 动态初始化 ， 应该是jvm会给默认值的

基本数据类型转换

  • frame :

    赋值时
    运算时

  • 赋值时
  • 运算时
  • boolean 不参与
  • 自动类型转换:

    知道精度大小排序有两个表（char不能与 byte和short互相转换，当然说的是变量）
    运算时 ， 结果会是精度最高的那个 （过程中好像也没有所有数据先转到最高的，比如 double a = 1.0 + 2/3）;
    运算时 ， 感觉和c的差不多啊 不过byte char short 最低应该是会变成int的

  • 知道精度大小排序有两个表（char不能与 byte和short互相转换，当然说的是变量）
  • 运算时 ， 结果会是精度最高的那个 （过程中好像也没有所有数据先转到最高的，比如 double a = 1.0 + 2/3）;
  • 运算时 ， 感觉和c的差不多啊 不过byte char short 最低应该是会变成int的
  • 强制类型转换：

    （int）这种优先级挺高的 记得给后面加括号哦 （double）（……）
    应该不是截取的 比如 ： byte a = (byte)128; 结果就不是0 而是-128 感觉更像多出来的那部分做循环啊
    int 常量可以给 byte 和 short 和 char 赋值 不过要在范围内

  • （int）这种优先级挺高的 记得给后面加括号哦 （double）（……）
  • 应该不是截取的 比如 ： byte a = (byte)128; 结果就不是0 而是-128 感觉更像多出来的那部分做循环啊
  • int 常量可以给 byte 和 short 和 char 赋值 不过要在范围内

基本数据类型和String的转换

  • 基本类型变String// 高冷的boolean都低下了头， 但不能强转 +””即可
    boolean a = false;
    String b = a + “” ;
    System.out.println(b);

  • String 变基本数据类型// 使用包装类的相应方法 爱来自java.lang(这个自带不用import)
    boolean c1 = Boolean.parseBoolean(b1);
    byte c2 = Byte.parseByte(b2);
    short c3 = Short.parseShort(b3);
    int c4 = Integer.parseInt(b4);
    float c6 = Float.parseFloat(b6);
    double c7 = Double.parseDouble(b7);
    // char 可以用s1.CharAt(int postion)
    String s1 = “hello”;
    char a = s1.charAt(0);
    // String 里面东西要对
    int a1 = Integer.parseInt(“hello”);

标准输入输出

  • 标准输入分为三步

    import 引进来
    创建对象(扫描器)
    使用方法

    // 居然没有空白字符的问题 下次遇到 在考虑 开始 结束 和处理空白符的问题ba
    Scanner myScanner = new Scanner(System.in); // System.in 算是一个参数把 代表从键盘输入
    People lcj = new People();
    lcj.name = myScanner.next();

    lcj.age = myScanner.nextInt();
    lcj.where = myScanner.next();
    lcj.count = myScanner.nextDouble();

  • import 引进来
  • 创建对象(扫描器)
  • 使用方法
  • 标准输出

    System.out.println

    // 分开行时 可以用 + 连起来 (曾经的\)
    System.out.println(“woainiRik” +
    “ka”);

    System.out.print 和上面区别在不换行
    out 可以使用printf方法(雾)

    System.out.printf(“%d”,12); // 不过不能用\连到下一行了(遗憾)

  • System.out.println
  • System.out.print 和上面区别在不换行
  • out 可以使用printf方法(雾)

运算符

  • 算术运算符

    / 就记住 小数的问题
    a%b 知道本质 a-(int)(a/b)*b 知道有负数的话 符号取决于 被模数 知道有小数的情况
    ++ — 实际上 java 中会有一个temp的存在

    // 这里 三步是
    // 1.int temp = i;
    // 2. i++;
    // 3. i = temp
    int i = 1;
    i = i++; // i = 1

    // 还有就是 虽然经常说 i++ => i = i+1 但这里 其实是 i++ => i = (byte)(i+1) 类型 是不会提升的 感觉也是合理的
    byte i = 127;
    i++;

    运算符
    运算

    +正号
    -负号
    +加
    -减
    *乘
    /除
    %取模(求余)
    ++自增
    –自减
    +字符串相加

    // 关于 0 之前没见过的
    System.out.println(7.5 / 0); // 输出的运算结果为Infinity
    System.out.println(-7.5 / 0); // 输出的运算结果为-Infinity
    System.out.println(7.5 % 0); // 输出的运算结果为NaN
    System.out.println(-7.5 % 0); // 输出的运算结果为NaN

  • / 就记住 小数的问题
  • a%b 知道本质 a-(int)(a/b)*b 知道有负数的话 符号取决于 被模数 知道有小数的情况
  • ++ — 实际上 java 中会有一个temp的存在
运算符 运算
+ 正号
– 负号
+ 加
– 减
* 乘
/ 除
% 取模(求余)
++ 自增
— 自减
+ 字符串相加
  • 关系运算符(好感度谁高呢 qwq)

    六个 + instanceof

    // true
    System.out.println(“LCJ” instanceof String);

  • 六个 + instanceof
  • 逻辑运算符

    短路与&& 短路或|| 取反! (关于会不会执行 给他个操作就行 看结果的变化)
    逻辑与& 逻辑或 | 逻辑异或 ^

  • 短路与&& 短路或|| 取反! (关于会不会执行 给他个操作就行 看结果的变化)
  • 逻辑与& 逻辑或 | 逻辑异或 ^
  • 赋值运算符

    基本赋值运算符
    复合赋值运算符

    先算右边 再算左边 且不会有类型提升

    // 先算右边 再左边 所以 10/3 = 3 无类型提升
    double d = 3;
    d += 10/3;

    // b += 1 => b =(byte)(b+1)
    byte b = 127;
    b += 1;

  • 基本赋值运算符
  • 复合赋值运算符

    先算右边 再算左边 且不会有类型提升

    // 先算右边 再左边 所以 10/3 = 3 无类型提升
    double d = 3;
    d += 10/3;

    // b += 1 => b =(byte)(b+1)
    byte b = 127;
    b += 1;

  • 先算右边 再算左边 且不会有类型提升
  • 三元运算符

    语法 : 条件表达式 ? 表达式1 ：表达式2;
    口诀 一真大师

    // 是去选择哪个执行 并且要值
    int a = 3;
    int b = 2;
    int c = a > b ? a++ : b++;

  • 语法 : 条件表达式 ? 表达式1 ：表达式2;
  • 口诀 一真大师
  • 运算符优先级

    只有单目运算符 和 赋值 运算符 是 从右向左的
    一个大概的顺序

    () {}
    单目运算符 强转那个
    算术运算符
    移位运算符
    关系运算符
    逻辑运算符
    三元运算符
    赋值运算符

  • 只有单目运算符 和 赋值 运算符 是 从右向左的
  • 一个大概的顺序

    () {}
    单目运算符 强转那个
    算术运算符
    移位运算符
    关系运算符
    逻辑运算符
    三元运算符
    赋值运算符

  • () {}
  • 单目运算符 强转那个
  • 算术运算符
  • 移位运算符
  • 关系运算符
  • 逻辑运算符
  • 三元运算符
  • 赋值运算符

进制

  • 有哪些
    二进制 0b开头
    八进制
    十进制 数字0开头
    十六进制 0x开头

  • 二进制 0b开头
  • 八进制
  • 十进制 数字0开头
  • 十六进制 0x开头
  • 记住

    有的字符是哪些 比如 二进制 没有2
    再就是逢几进   一

  • 有的字符是哪些 比如 二进制 没有2
  • 再就是逢几进   一
  • 会 这些给我一种 一种 进制 中 有 等级的感觉

    2 8 16 转 10
    10 转 2 8 16 不断除 直到 商为0 余数倒过来排
    2 转 8 16 => 转8 就是 三位一起 有顺序的变过去
    8 16 转 2 => 8转2 就是 一位拆成 3位 排过去

  • 2 8 16 转 10
  • 10 转 2 8 16 不断除 直到 商为0 余数倒过来排
  • 2 转 8 16 => 转8 就是 三位一起 有顺序的变过去
  • 8 16 转 2 => 8转2 就是 一位拆成 3位 排过去

原码 反码 补码

  • qwq 为何诞生 ： 好像是和 负数 （好像是还有两个0的问题 我忘了@.@）
  • 正数 三码 合 一 负数 反码为原码(除符号位)都取反 补码 就是 再加一 (反过来也要会哦 )
  • 运算时 以 补码的方式运算的 看结果时 看原码
  • java 没有无符号数（char 就不要捣乱>_<）

位运算符

  • 逻辑位运算

    按位与
    按位或
    按位异或
    按位取反

  • 按位与
  • 按位或
  • 按位异或
  • 按位取反
  • 移位运算

    算术右移 对于负数 好像 乘2 除 2这种不一定
    算术左移
    无符号右移

  • 算术右移 对于负数 好像 乘2 除 2这种不一定
  • 算术左移
  • 无符号右移

String

  • 定义 : String 字符串变量 = 字符串; String s1 = null; // 好久没有见null 小姐 la
    String s2 = “”;
    String s3 = “Rikka”;

  • 字符串 操作

    比较字符串

    String s1 = “Rikka”;
    // 之前 看过 一种值 一样的话 引用值 是一样的 不知道以后 会不会遇见
    System.out.println(s1.equals(“rikka”)); // equals 方法区分大小写
    System.out.println(s1.equalsIgnoreCase(“rikka”)); // 不区分
    System.out.println(s1.startsWith(“r”));
    System.out.println(s1.endsWith(“Rikka”));
    // starts有重载 第二个参数 为 位置
    System.out.println(s1.startsWith(“a”,s1.length()-1));
    // int pos = 4;
    // System.out.println(s1.endsWith(“kka”,pos));
    // 没有

    获取字符串长度

    // 和数组 那里 差个括号
    String s1 = “Rikka”;
    System.out.println(s1.length());

    大小写转换

    String str = “AbCDefGh”;
    String lStr = str.toLowerCase(); // 结果为“abcdefgh”
    String uStr = str.toUpperCase(); // 结果为“ABCDEFGH”

    查找字符串

    // 0123456789
    String s1 = “RikkaRikka”;

    System.out.println(“i第一次出现的位置 : ” + s1.indexOf(‘i’));
    System.out.println(“i最后一次出现的位置 : ” + s1.lastIndexOf(‘i’));

    System.out.println(“ikk字符串第一次出现的位置 : ” + s1.indexOf(“ikk”));
    System.out.println(“ikk字符串最后一次出现的位置 : ” + s1.lastIndexOf(“ikk”));

    System.out.println(“i在位置5后 第一次出现的位置 : ” + s1.indexOf(‘i’,5));
    System.out.println(“i在位置7后 最后一次出现的位置 : ” + s1.lastIndexOf(‘i’,7)); // 为什么这里是6

    System.out.println(“ikk字符串在位置5 后 最后一次出现的位置 : ” + s1.lastIndexOf(“ikk”,5)); // 为什么是1
    // 如果 last 指定的位置 是 有边界 就可以了
    // 试试
    System.out.println(“i在位置7后 最后一次出现的位置 : ” + s1.lastIndexOf(‘i’,5)); // 为什么这里是6
    // 应该是

    截取字符串

    String s1 = “RikkaRikka”;
    // S居然没大写
    System.out.println(s1.substring(6));
    System.out.println(s1.substring(6,8));

    去掉首尾 空格

    String s1 = ” mzmzrw “;
    System.out.println(s1.length()); // 8
    String s2 = s1.trim();
    System.out.println(s2.length()); // 6

    替换 字符 或 字串

    String s1 = “mzmzrw”;
    String s2 = s1.replace(‘m’ , ‘L’);
    System.out.println(s2); // LzLzrw

    String s3 = s1.replaceAll(“zrw” , “Rikka”);
    System.out.println(s3); // mzmRikka

    分割字符串 // 方法
    public String[] split(String regex, int limit)
    // regex 指定一段就好 （应该）
    // limit 最大 分割 次数 为 limit – 1 也就是 limit 会限制 一个 最大 数组长度
    // limit 为负数 （都多余了 爱谁谁） 次数无限
    // limt 为0 String数组中 最后的 所有 空字符串(指值) 会被丢弃
    String str = “boo:and:foo”;
    String[] a = str.split(“:”, 2); // “boo”, “and:foo”
    String[] b = str.split(“:”, 5); // “boo”, “and”, “foo”
    String[] c = str.split(“:”, -2); // “boo”, “and”, “foo”
    String[] d = str.split(“o”, 5); // “b”, “”, “:and:f”, “”, “”
    String[] e = str.split(“o”, -2); // “b”, “”, “:and:f”, “”, “”
    String[] f = str.split(“o”, 0); // “b”, “”, “:and:f”
    String[] g = str.split(“m”, 0); // “boo:and:foo”

  • 比较字符串
  • 获取字符串长度
  • 大小写转换
  • 查找字符串
  • 截取字符串
  • 去掉首尾 空格
  • 替换 字符 或 字串
  • 分割字符串 // 方法
    public String[] split(String regex, int limit)
    // regex 指定一段就好 （应该）
    // limit 最大 分割 次数 为 limit – 1 也就是 limit 会限制 一个 最大 数组长度
    // limit 为负数 （都多余了 爱谁谁） 次数无限
    // limt 为0 String数组中 最后的 所有 空字符串(指值) 会被丢弃
    String str = “boo:and:foo”;
    String[] a = str.split(“:”, 2); // “boo”, “and:foo”
    String[] b = str.split(“:”, 5); // “boo”, “and”, “foo”
    String[] c = str.split(“:”, -2); // “boo”, “and”, “foo”
    String[] d = str.split(“o”, 5); // “b”, “”, “:and:f”, “”, “”
    String[] e = str.split(“o”, -2); // “b”, “”, “:and:f”, “”, “”
    String[] f = str.split(“o”, 0); // “b”, “”, “:and:f”
    String[] g = str.split(“m”, 0); // “boo:and:foo”

————————

java变量&数组&标准输入输出&运算符&String

~~ 有出错的地方，我会及时改正owo ~~

标识符（好像包含关键字）命名规则

  • 标识符由字母、数字、下划线、美元等（比如中文也可以但不是所有unicode中所有都可以 比如#）组成
  • 不能用关键字哦（会有歧义）
  • 尽量见名知意（为人方正）
  • 类 驼峰原则 变量、方法 第一个单词首字母不大写 常量全部大写（单词之间用下划线分割） 包要小写（好像和不同系统区分大小写有关 所以这么搞）

java常量

  • 声明 : final 常量类型 常量标识符
  • 只能给一次 值不可以改变了

java变量

  • 程序的基本组成单位
  • 三要素 ： 类型 + 名称 + 值
  • 知道变量对应计算机内存里会怎么样
  • 变量在同一作用域不能重名(一个班重名会有歧义)

数据类型

  • 整数四种(long) 浮点数两种 char boolean(true|false) 三个引用数据类型 类、引用、接口
  • 整形

    知道为啥能表示的数是这个范围
    整形常量默认int型，long的要加L
    整形有固定字段长度（和字节可能不太一样）和表示范围，不受OS的影响
    bit计算机中最小的存储单位，byte基本的存储单元

  • 知道为啥能表示的数是这个范围
  • 整形常量默认int型，long的要加L
  • 整形有固定字段长度（和字节可能不太一样）和表示范围，不受OS的影响
  • bit计算机中最小的存储单位，byte基本的存储单元
  • 浮点型

    为啥这个范围

    常量默认double，float要加f，常量有两种表示方式： 十进制数（.12）、科学计数法（5.12e2）；

    浮点也有固定字段长度和表示范围，不受os影响

    浮点数不精确 ，最好用double（或许这就是为什么默认是double）， 比较最好还是做差比某个数小
    v. 虽然double能被浮点型的数赋值，但没有直接的double来的准确

  • 为啥这个范围
  • 常量默认double，float要加f，常量有两种表示方式： 十进制数（.12）、科学计数法（5.12e2）；
  • 浮点也有固定字段长度和表示范围，不受os影响
  • 浮点数不精确 ，最好用double（或许这就是为什么默认是double）， 比较最好还是做差比某个数小
    v. 虽然double能被浮点型的数赋值，但没有直接的double来的准确 
    double num10 = 2.1234567851;
	double num11 = 2.1234567851f;
    // 这两值不一样
  • 字符型

    两个字节
    没有负号（无符号型），java没有unsigned
    值能有’字符’,65 97 48,转义字符（\u四个数字可带表十六进制对应的字符,\uface）
    字符在计算机中，直接存数（按照的是unicode编码表，有点浪费空间，汉字和字母都一样，文件保存为什么类型是你写的代码对应的字符，不关人家java字符的事）

  • 两个字节
  • 没有负号（无符号型），java没有unsigned
  • 值能有’字符’,65 97 48,转义字符（\u四个数字可带表十六进制对应的字符,\uface）
  • 字符在计算机中，直接存数（按照的是unicode编码表，有点浪费空间，汉字和字母都一样，文件保存为什么类型是你写的代码对应的字符，不关人家java字符的事）
  • 布尔型(boolean)

    值只有true和false（不能用01代替，好像为了强类型？）
    变量占四个字节 数组占一个字节(数组会被当初byte数组)

  • 值只有true和false（不能用01代替，好像为了强类型？）
  • 变量占四个字节 数组占一个字节(数组会被当初byte数组)

数组

  • 数组也是数据类型 ，是引用数据类型（解释二维数组有用）
  • 创建以后长度就确定了，有length这个属性
  • 定义一个数组：声明数组 + 创造数组 ， 各有两种方式
    double[] scores = new double[5]; // 动态初始化
	double scores2[] = {3.14,2.2};
  • 动态初始化 ， 应该是jvm会给默认值的

基本数据类型转换

  • frame :

    赋值时
    运算时

  • 赋值时
  • 运算时
  • boolean 不参与
  • 自动类型转换:

    知道精度大小排序有两个表（char不能与 byte和short互相转换，当然说的是变量）
    运算时 ， 结果会是精度最高的那个 （过程中好像也没有所有数据先转到最高的，比如 double a = 1.0 + 2/3）;
    运算时 ， 感觉和c的差不多啊 不过byte char short 最低应该是会变成int的

  • 知道精度大小排序有两个表（char不能与 byte和short互相转换，当然说的是变量）
  • 运算时 ， 结果会是精度最高的那个 （过程中好像也没有所有数据先转到最高的，比如 double a = 1.0 + 2/3）;
  • 运算时 ， 感觉和c的差不多啊 不过byte char short 最低应该是会变成int的
  • 强制类型转换：

    （int）这种优先级挺高的 记得给后面加括号哦 （double）（……）
    应该不是截取的 比如 ： byte a = (byte)128; 结果就不是0 而是-128 感觉更像多出来的那部分做循环啊
    int 常量可以给 byte 和 short 和 char 赋值 不过要在范围内

  • （int）这种优先级挺高的 记得给后面加括号哦 （double）（……）
  • 应该不是截取的 比如 ： byte a = (byte)128; 结果就不是0 而是-128 感觉更像多出来的那部分做循环啊
  • int 常量可以给 byte 和 short 和 char 赋值 不过要在范围内

基本数据类型和String的转换

  • 基本类型变String// 高冷的boolean都低下了头， 但不能强转 +””即可
    boolean a = false;
    String b = a + “” ;
    System.out.println(b);

  • String 变基本数据类型// 使用包装类的相应方法 爱来自java.lang(这个自带不用import)
    boolean c1 = Boolean.parseBoolean(b1);
    byte c2 = Byte.parseByte(b2);
    short c3 = Short.parseShort(b3);
    int c4 = Integer.parseInt(b4);
    float c6 = Float.parseFloat(b6);
    double c7 = Double.parseDouble(b7);
    // char 可以用s1.CharAt(int postion)
    String s1 = “hello”;
    char a = s1.charAt(0);
    // String 里面东西要对
    int a1 = Integer.parseInt(“hello”);

标准输入输出

  • 标准输入分为三步

    import 引进来
    创建对象(扫描器)
    使用方法

    // 居然没有空白字符的问题 下次遇到 在考虑 开始 结束 和处理空白符的问题ba
    Scanner myScanner = new Scanner(System.in); // System.in 算是一个参数把 代表从键盘输入
    People lcj = new People();
    lcj.name = myScanner.next();

    lcj.age = myScanner.nextInt();
    lcj.where = myScanner.next();
    lcj.count = myScanner.nextDouble();

  • import 引进来
  • 创建对象(扫描器)
  • 使用方法
  • 标准输出

    System.out.println

    // 分开行时 可以用 + 连起来 (曾经的\)
    System.out.println(“woainiRik” +
    “ka”);

    System.out.print 和上面区别在不换行
    out 可以使用printf方法(雾)

    System.out.printf(“%d”,12); // 不过不能用\连到下一行了(遗憾)

  • System.out.println
  • System.out.print 和上面区别在不换行
  • out 可以使用printf方法(雾)

运算符

  • 算术运算符

    / 就记住 小数的问题
    a%b 知道本质 a-(int)(a/b)*b 知道有负数的话 符号取决于 被模数 知道有小数的情况
    ++ — 实际上 java 中会有一个temp的存在

    // 这里 三步是
    // 1.int temp = i;
    // 2. i++;
    // 3. i = temp
    int i = 1;
    i = i++; // i = 1

    // 还有就是 虽然经常说 i++ => i = i+1 但这里 其实是 i++ => i = (byte)(i+1) 类型 是不会提升的 感觉也是合理的
    byte i = 127;
    i++;

    运算符
    运算

    +正号
    -负号
    +加
    -减
    *乘
    /除
    %取模(求余)
    ++自增
    –自减
    +字符串相加

    // 关于 0 之前没见过的
    System.out.println(7.5 / 0); // 输出的运算结果为Infinity
    System.out.println(-7.5 / 0); // 输出的运算结果为-Infinity
    System.out.println(7.5 % 0); // 输出的运算结果为NaN
    System.out.println(-7.5 % 0); // 输出的运算结果为NaN

  • / 就记住 小数的问题
  • a%b 知道本质 a-(int)(a/b)*b 知道有负数的话 符号取决于 被模数 知道有小数的情况
  • ++ — 实际上 java 中会有一个temp的存在
运算符 运算
+ 正号
– 负号
+ 加
– 减
* 乘
/ 除
% 取模(求余)
++ 自增
— 自减
+ 字符串相加
  • 关系运算符(好感度谁高呢 qwq)

    六个 + instanceof

    // true
    System.out.println(“LCJ” instanceof String);

  • 六个 + instanceof
  • 逻辑运算符

    短路与&& 短路或|| 取反! (关于会不会执行 给他个操作就行 看结果的变化)
    逻辑与& 逻辑或 | 逻辑异或 ^

  • 短路与&& 短路或|| 取反! (关于会不会执行 给他个操作就行 看结果的变化)
  • 逻辑与& 逻辑或 | 逻辑异或 ^
  • 赋值运算符

    基本赋值运算符
    复合赋值运算符

    先算右边 再算左边 且不会有类型提升

    // 先算右边 再左边 所以 10/3 = 3 无类型提升
    double d = 3;
    d += 10/3;

    // b += 1 => b =(byte)(b+1)
    byte b = 127;
    b += 1;

  • 基本赋值运算符
  • 复合赋值运算符

    先算右边 再算左边 且不会有类型提升

    // 先算右边 再左边 所以 10/3 = 3 无类型提升
    double d = 3;
    d += 10/3;

    // b += 1 => b =(byte)(b+1)
    byte b = 127;
    b += 1;

  • 先算右边 再算左边 且不会有类型提升
  • 三元运算符

    语法 : 条件表达式 ? 表达式1 ：表达式2;
    口诀 一真大师

    // 是去选择哪个执行 并且要值
    int a = 3;
    int b = 2;
    int c = a > b ? a++ : b++;

  • 语法 : 条件表达式 ? 表达式1 ：表达式2;
  • 口诀 一真大师
  • 运算符优先级

    只有单目运算符 和 赋值 运算符 是 从右向左的
    一个大概的顺序

    () {}
    单目运算符 强转那个
    算术运算符
    移位运算符
    关系运算符
    逻辑运算符
    三元运算符
    赋值运算符

  • 只有单目运算符 和 赋值 运算符 是 从右向左的
  • 一个大概的顺序

    () {}
    单目运算符 强转那个
    算术运算符
    移位运算符
    关系运算符
    逻辑运算符
    三元运算符
    赋值运算符

  • () {}
  • 单目运算符 强转那个
  • 算术运算符
  • 移位运算符
  • 关系运算符
  • 逻辑运算符
  • 三元运算符
  • 赋值运算符

进制

  • 有哪些
    二进制 0b开头
    八进制
    十进制 数字0开头
    十六进制 0x开头

  • 二进制 0b开头
  • 八进制
  • 十进制 数字0开头
  • 十六进制 0x开头
  • 记住

    有的字符是哪些 比如 二进制 没有2
    再就是逢几进   一

  • 有的字符是哪些 比如 二进制 没有2
  • 再就是逢几进   一
  • 会 这些给我一种 一种 进制 中 有 等级的感觉

    2 8 16 转 10
    10 转 2 8 16 不断除 直到 商为0 余数倒过来排
    2 转 8 16 => 转8 就是 三位一起 有顺序的变过去
    8 16 转 2 => 8转2 就是 一位拆成 3位 排过去

  • 2 8 16 转 10
  • 10 转 2 8 16 不断除 直到 商为0 余数倒过来排
  • 2 转 8 16 => 转8 就是 三位一起 有顺序的变过去
  • 8 16 转 2 => 8转2 就是 一位拆成 3位 排过去

原码 反码 补码

  • qwq 为何诞生 ： 好像是和 负数 （好像是还有两个0的问题 我忘了@.@）
  • 正数 三码 合 一 负数 反码为原码(除符号位)都取反 补码 就是 再加一 (反过来也要会哦 )
  • 运算时 以 补码的方式运算的 看结果时 看原码
  • java 没有无符号数（char 就不要捣乱>_<）

位运算符

  • 逻辑位运算

    按位与
    按位或
    按位异或
    按位取反

  • 按位与
  • 按位或
  • 按位异或
  • 按位取反
  • 移位运算

    算术右移 对于负数 好像 乘2 除 2这种不一定
    算术左移
    无符号右移

  • 算术右移 对于负数 好像 乘2 除 2这种不一定
  • 算术左移
  • 无符号右移

String

  • 定义 : String 字符串变量 = 字符串; String s1 = null; // 好久没有见null 小姐 la
    String s2 = “”;
    String s3 = “Rikka”;

  • 字符串 操作

    比较字符串

    String s1 = “Rikka”;
    // 之前 看过 一种值 一样的话 引用值 是一样的 不知道以后 会不会遇见
    System.out.println(s1.equals(“rikka”)); // equals 方法区分大小写
    System.out.println(s1.equalsIgnoreCase(“rikka”)); // 不区分
    System.out.println(s1.startsWith(“r”));
    System.out.println(s1.endsWith(“Rikka”));
    // starts有重载 第二个参数 为 位置
    System.out.println(s1.startsWith(“a”,s1.length()-1));
    // int pos = 4;
    // System.out.println(s1.endsWith(“kka”,pos));
    // 没有

    获取字符串长度

    // 和数组 那里 差个括号
    String s1 = “Rikka”;
    System.out.println(s1.length());

    大小写转换

    String str = “AbCDefGh”;
    String lStr = str.toLowerCase(); // 结果为“abcdefgh”
    String uStr = str.toUpperCase(); // 结果为“ABCDEFGH”

    查找字符串

    // 0123456789
    String s1 = “RikkaRikka”;

    System.out.println(“i第一次出现的位置 : ” + s1.indexOf(‘i’));
    System.out.println(“i最后一次出现的位置 : ” + s1.lastIndexOf(‘i’));

    System.out.println(“ikk字符串第一次出现的位置 : ” + s1.indexOf(“ikk”));
    System.out.println(“ikk字符串最后一次出现的位置 : ” + s1.lastIndexOf(“ikk”));

    System.out.println(“i在位置5后 第一次出现的位置 : ” + s1.indexOf(‘i’,5));
    System.out.println(“i在位置7后 最后一次出现的位置 : ” + s1.lastIndexOf(‘i’,7)); // 为什么这里是6

    System.out.println(“ikk字符串在位置5 后 最后一次出现的位置 : ” + s1.lastIndexOf(“ikk”,5)); // 为什么是1
    // 如果 last 指定的位置 是 有边界 就可以了
    // 试试
    System.out.println(“i在位置7后 最后一次出现的位置 : ” + s1.lastIndexOf(‘i’,5)); // 为什么这里是6
    // 应该是

    截取字符串

    String s1 = “RikkaRikka”;
    // S居然没大写
    System.out.println(s1.substring(6));
    System.out.println(s1.substring(6,8));

    去掉首尾 空格

    String s1 = ” mzmzrw “;
    System.out.println(s1.length()); // 8
    String s2 = s1.trim();
    System.out.println(s2.length()); // 6

    替换 字符 或 字串

    String s1 = “mzmzrw”;
    String s2 = s1.replace(‘m’ , ‘L’);
    System.out.println(s2); // LzLzrw

    String s3 = s1.replaceAll(“zrw” , “Rikka”);
    System.out.println(s3); // mzmRikka

    分割字符串 // 方法
    public String[] split(String regex, int limit)
    // regex 指定一段就好 （应该）
    // limit 最大 分割 次数 为 limit – 1 也就是 limit 会限制 一个 最大 数组长度
    // limit 为负数 （都多余了 爱谁谁） 次数无限
    // limt 为0 String数组中 最后的 所有 空字符串(指值) 会被丢弃
    String str = “boo:and:foo”;
    String[] a = str.split(“:”, 2); // “boo”, “and:foo”
    String[] b = str.split(“:”, 5); // “boo”, “and”, “foo”
    String[] c = str.split(“:”, -2); // “boo”, “and”, “foo”
    String[] d = str.split(“o”, 5); // “b”, “”, “:and:f”, “”, “”
    String[] e = str.split(“o”, -2); // “b”, “”, “:and:f”, “”, “”
    String[] f = str.split(“o”, 0); // “b”, “”, “:and:f”
    String[] g = str.split(“m”, 0); // “boo:and:foo”

  • 比较字符串
  • 获取字符串长度
  • 大小写转换
  • 查找字符串
  • 截取字符串
  • 去掉首尾 空格
  • 替换 字符 或 字串
  • 分割字符串 // 方法
    public String[] split(String regex, int limit)
    // regex 指定一段就好 （应该）
    // limit 最大 分割 次数 为 limit – 1 也就是 limit 会限制 一个 最大 数组长度
    // limit 为负数 （都多余了 爱谁谁） 次数无限
    // limt 为0 String数组中 最后的 所有 空字符串(指值) 会被丢弃
    String str = “boo:and:foo”;
    String[] a = str.split(“:”, 2); // “boo”, “and:foo”
    String[] b = str.split(“:”, 5); // “boo”, “and”, “foo”
    String[] c = str.split(“:”, -2); // “boo”, “and”, “foo”
    String[] d = str.split(“o”, 5); // “b”, “”, “:and:f”, “”, “”
    String[] e = str.split(“o”, -2); // “b”, “”, “:and:f”, “”, “”
    String[] f = str.split(“o”, 0); // “b”, “”, “:and:f”
    String[] g = str.split(“m”, 0); // “boo:and:foo”