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

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

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

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

java常量

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

java变量

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

数据类型

1. 整数四种(long) 浮点数两种 char boolean(true|false) 三个引用数据类型 类、引用、接口
2. 整形
   1. 知道为啥能表示的数是这个范围
   2. 整形常量默认int型，long的要加L
   3. 整形有固定字段长度（和字节可能不太一样）和表示范围，不受OS的影响
   4. bit计算机中最小的存储单位，byte基本的存储单元
3. 浮点型

   1. 为啥这个范围

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

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

   4. 浮点数不精确 ，最好用double（或许这就是为什么默认是double）， 比较最好还是做差比某个数小

      v. 虽然double能被浮点型的数赋值，但没有直接的double来的准确

    double num10 = 2.1234567851;
	double num11 = 2.1234567851f;
    // 这两值不一样

4. 字符型
   1. 两个字节
   2. 没有负号（无符号型），java没有unsigned
   3. 值能有'字符',65 97 48,转义字符（\u四个数字可带表十六进制对应的字符,\uface）
   4. 字符在计算机中，直接存数（按照的是unicode编码表，有点浪费空间，汉字和字母都一样，文件保存为什么类型是你写的代码对应的字符，不关人家java字符的事）
5. 布尔型(boolean)
   1. 值只有true和false（不能用01代替，好像为了强类型？）
   2. 变量占四个字节 数组占一个字节(数组会被当初byte数组)

数组

1. 数组也是数据类型 ，是引用数据类型（解释二维数组有用）
2. 创建以后长度就确定了，有length这个属性
3. 定义一个数组：声明数组 + 创造数组 ， 各有两种方式

    double[] scores = new double[5]; // 动态初始化
	double scores2[] = {3.14,2.2};

4. 动态初始化 ， 应该是jvm会给默认值的

基本数据类型转换

1. frame :
   1. 赋值时
   2. 运算时
2. boolean 不参与
3. 自动类型转换:
   1. 知道精度大小排序有两个表（char不能与 byte和short互相转换，当然说的是变量）
   2. 运算时 ， 结果会是精度最高的那个 （过程中好像也没有所有数据先转到最高的，比如 double a = 1.0 + 2/3）;
   3. 运算时 ， 感觉和c的差不多啊 不过byte char short 最低应该是会变成int的
4. 强制类型转换：
   1. （int）这种优先级挺高的 记得给后面加括号哦 （double）（……）
   2. 应该不是截取的 比如 ： byte a = (byte)128; 结果就不是0 而是-128 感觉更像多出来的那部分做循环啊
   3. int 常量可以给 byte 和 short 和 char 赋值 不过要在范围内

基本数据类型和String的转换

1. 基本类型变String

   // 高冷的boolean都低下了头， 但不能强转 +""即可
       boolean a = false;
    	String b = a + "" ;
    	System.out.println(b);
   

2. 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");
   

标准输入输出

1. 标准输入分为三步
   1. import 引进来
   2. 创建对象(扫描器)
   3. 使用方法

      // 居然没有空白字符的问题 下次遇到 在考虑 开始 结束 和处理空白符的问题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();
   

2. 标准输出
   1. System.out.println

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

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

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

运算符

1. 算术运算符

   1. / 就记住 小数的问题
   2. a%b 知道本质 a-(int)(a/b)*b 知道有负数的话 符号取决于 被模数 知道有小数的情况
   3. ++ -- 实际上 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
   
   

2. 关系运算符(好感度谁高呢 qwq)

   1. 六个 + instanceof

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

3. 逻辑运算符

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

4. 赋值运算符

   1. 基本赋值运算符
   2. 复合赋值运算符
      1. 先算右边 再算左边 且不会有类型提升

         // 先算右边 再左边 所以 10/3 = 3 无类型提升
         double d = 3;
           d += 10/3;
         
         // b += 1 => b =(byte)(b+1)
         byte b = 127;
           b += 1;
      

5. 三元运算符

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

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

6. 运算符优先级

   1. 只有单目运算符 和 赋值 运算符 是 从右向左的
   2. 一个大概的顺序
      1. () {}
      2. 单目运算符 强转那个
      3. 算术运算符
      4. 移位运算符
      5. 关系运算符
      6. 逻辑运算符
      7. 三元运算符
      8. 赋值运算符

进制

1. 有哪些
   1. 二进制 0b开头
   2. 八进制
   3. 十进制 数字0开头
   4. 十六进制 0x开头
2. 记住
   1. 有的字符是哪些 比如 二进制 没有2
   2. 再就是逢几进   一
3. 会
   这些给我一种 一种 进制 中 有 等级的感觉
   1. 2 8 16 转 10
   2. 10 转 2 8 16 不断除 直到 商为0 余数倒过来排
   3. 2 转 8 16 => 转8 就是 三位一起 有顺序的变过去
   4. 8 16 转 2 => 8转2 就是 一位拆成 3位 排过去

原码 反码 补码

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

位运算符

1. 逻辑位运算
   1. 按位与
   2. 按位或
   3. 按位异或
   4. 按位取反
2. 移位运算
   1. 算术右移 对于负数 好像 乘2 除 2这种不一定
   2. 算术左移
   3. 无符号右移

String

1. 定义 : String 字符串变量 = 字符串;

      String s1 = null;  // 好久没有见null 小姐 la
      String s2 = "";
      String s3 = "Rikka";
   

2. 字符串 操作
   1. 比较字符串

        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));
        // 没有
   

   2. 获取字符串长度

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

   3. 大小写转换

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

   4. 查找字符串

      //           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
        // 应该是
   

   5. 截取字符串

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

   6. 去掉首尾 空格

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

   7. 替换 字符 或 字串

        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
   

   8. 分割字符串

         // 方法
         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"