Java notes

Java

2020-04-16

软件：一系列按照特定顺序组织的计算机数据和指令的集合，主要分为系统软件和应用软件。

常用的DOS命令：

- 盘名: : 进入某一目录，如 d:
- dir: 查看当前目录下得所有文件夹
- md: 创建文件夹
- rd: 删除文件夹
- cd: 进入指定目录
- cd..: 退回到上一级目录
- cd\: 返回到根目录
- del: 删除文件
- exit: 退出

面向过程 ——> 面向对象（封装、继承、多态）

两种核心机制：

• Java虚拟机（Java Virtual Machine，JVM）：实现自动将Java程序转换为不同平台上可以运行的指令，保证跨平台性
• 垃圾回收机制（garbage Collection，GC）：使用系统级线程自动回收不再使用的内存空间

JDK：Java开发工具包

JRE：Java运行环境，包括Java虚拟机和Java所需的核心类库等

Hello World

package com.company;

// 类名需与文件名一致
public class Main {

    public static void main(String[] args) {
        // write your code here
        System.out.println("Hello World");
    }
}

注释：

• 单行注释： //
• 多行注释： / /
• 文档注释：

  /**
  * 文档注释
  */
  

Java关键字：

标识符：见名知意

• 作用：常量、变量、方法、类和包等的名称。
• 命名规则
  • 必须以字母、下划线、美元符”和数字的任意组合。
  • 大小写敏感，长度无限制
  • 不可以是单独Java的关键字，但是可以包含关键字
  • 不能包含空格

命名规范：

• 包名：多单词组成时所有字母都小写
• 类名、接口名：多单词组成时，所有单词首字母大写
• 变量名、方法名：驼峰命名法
• 常量名：所有字母大写

数据类型：

• 基本数据类型（八种）：整数类型（byte, short, int, long）、浮点类型（float, double）、字符类型（char）、boolean类型（true, false）

  • long型变量赋值时后面要在值后面跟上字母 l
  • float型变量赋值时要在值后面跟上字母 f
  • byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制

package com.company;

public class Main {

    public static void main(String[] args) {
        // byte
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        // short
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        // int
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        // long
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        // float
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        // double
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        // char
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE="
                + (int) Character.MIN_VALUE);
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值：Character.MAX_VALUE="
                + (int) Character.MAX_VALUE);
    }
}

/*
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
*/

• 引用数据类型：除了八种基本数据类型之外的都是引用类型
  • String：由0或多个字母数字符号组成的串；可由null初始化；值不可变

• 运算规则：

  • 有多种类型的数据混合计算时，系统首先自动的将所有的数据转换成容量最大的那种数据类型，然后再进行计算，数字类型从大到小为byte、short、int、long、float、double
  • 数字类型的运算中，多个相同类型变量参与的运算，变量要先转换为相应的数据类型的默认类型，这种情况适用于变量的数据类型的容量比默认类型的容量小

  • byte、short、char之间不会互相转换，他们再计算时首先转换为int类型

    public class dataType {
    public static void main(String[] args){
       short s = 2;
       s = (short)(s + 3);
       System.out.println(s); // 5
    
       int i = 1;
       i *= 0.1;
       System.out.println(i); // 0
    
    }
    }
    

• 变量参与运算时，Java程序不知道具体的这个变量在昨晚运算后结果会不会溢出，所以会先把变量转换为一个更大的类型。例如

  short s = 2 // 此时为short型
  s = s + 3 //Java不知道s + 3的结果会不会超出short型的取值范围，
         //因此会先将其转换为int型再计算，结果为int型
         //但int型不能自动转换为short型，因此要想正常运行需进行强制类型转换
         // 即 s = (short)(s + 3)
  

• 在使用扩展赋值运算符时，变量再参与运算时会把结果自动强制转换为当前变量类型，如：

  int i = 1
  i *= 0.1 // 0
  // i 为int型，它和float型值进行运算时会先将其转换为float型变量在计算，结果为0.1，
  //但最后自动执行强制类型转换，，将结果转换为int型，舍弃掉小数部分，最终结果为0
  

Java中的运算符：算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符和其他运算符。

• 逻辑运算符

  • &：逻辑与
  • |：逻辑或
  • ！：逻辑非
  • ^：逻辑异或
  • &&：短路与
  • ||：段落或

    & 和 &&的区别：

    • &时，左边无论真假，右边都要参与运算
    • &&时，如果左边为真，右边参与运算；如果左边为假，那么右边不参与运算

    | 和 || 的区别如上同理。

• 位运算符

• 三元运算符
  格式：（条件表达式）？表达式1：表达式2
  • 条件表达式为true，则执行表达式1
  • 否则执行表达式2

    int i = 1;
    int k = i > 0 ? 1 : 0;
    System.out.println(k); // 1
    

运算符优先级：

数组：

• 动态初始化： ```java // 先声明数组变量a,接着创建大小为4的新数组,最后将新数组的引用赋给a int [] a = new int [4] //[]内为数组容量 int [][] b = new int [2][2] int [][] c = new int [2][] //只定义第一维的长度

int [] x, y[]; // x是一维数组，y是二维数组

- 静态初始化：
```java
int [] a = new int []{1,2,3}
int [][] b = new int [][]({1,2}, {3,4})

• 数组默认初始化：数字数组的默认类型为0，对象数组的默认值为null

常见算法：

• 求数组元素的最大值、最小值、平均值

  int [] a = new int[]{1，2，3，4，5}
  int maxNum = int.MIN_VALUE
  

访问数组元素：

int [] a = new []{1,2,3}
for(int i = 0; i <= a.length; i++){
    System.out.println(a[i])
}

// For - Each 循环
for(int element : a){
    System.out.println(element)
}

数组作为函数的参数：

public static void printArray(int[] array) {
  ...
}

数组作为函数的返回值：

public static int[] reverse(int[] array){
    int [] res = new int[array.length]
    ...
    return res
}

java.util.Arrays类能很方便的操作数组，它所提供的方法都是静态的。如果指定的数组引用为空，则该类中的方法都将抛出一个NullPointerException。

• Array.asList()：返回指定数组支持的固定大小列表
• Array.binarySearch(int[] a, int key)：在给定的数组中执行二分查找寻找key
• Array.binarySearch(int[] a, int fromIndex, int toIndex, int key)：在给定数组的指定区间中使用二分查找寻找key
• Array.copyOf(int[] original, int newLength)：返回值是一个数组 ,也是复制数组的方法,但是会返回一个新的数组,长度和要复制的长度一样
• Array.copyOfRange(int[] original, int from, int to)：将指定数组的指定范围复制到新数组中。
• Array.equals(int[] a, int[] a2)：判断两数组的内容是否相等
• Array.equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)
• Array.fill(int[] a, int val)：填充数组,将数组中的每个元素都替换成输入的值.
• Array.fill(int[] a, int fromIndex, int toIndex, int val)：填充数组的指定区间，将区间中的每个元素都替换成输入的值.
• Array.mismatch(int[] a, int[] b)查找并返回两个int数组之间第一个不匹配的索引，如果没有发现不匹配，则返回-1。
• Array.parallelSort(int[] a)：将指定的数组升序排列
• Array.parallelSort(int[] a, int fromIndex, int toIndex)：将给定数组的指定区间升序排列
• Array.sort(int[] a)：将指定的数组升序排列
• Array.sort(int[] a, int fromIndex, int toIndex)：将给定数组的指定区间升序排列
• Array.toString(int[] a)：返回指定数组内容的字符串表示形式

package com.company;
import java.util.Arrays;

public class utils_Array_Test {
    public static void main(String[] args) {
        int [] a = new int []{1,4,3,2,5};
        int [] b = new int []{1,4,3,2,5};
        int [] c = new int []{4,5,6,7,8};

        System.out.println(Arrays.asList(a));

        // Array.toString()：将数组的内容以string类型输出
        System.out.println(Arrays.toString(a));

        // Array.binarySearch(int[] a, int key)
        System.out.println(Arrays.binarySearch(a, 2));

        //Array.binarySearch(int[] a, int fromIndex, int toIndex, int key)
        System.out.println(Arrays.binarySearch(a, 0, a.length - 1, 3));

        // == :判断数组的地址是否相同
        System.out.println(a == b);

        //Arrays.equals():判断两数组的内容是否相等
        System.out.println(Arrays.equals(a, b));

        //Arrays.copyOf():返回值是一个数组 ,也是复制数组的方法,但是会返回一个新的数组,长度和要复制的长度一样
        int [] d = Arrays.copyOf(c, c.length);
        for(int ele : d){
            System.out.println(ele);
        }

        //Arrays.fill():填充数组,将数组中的每个元素都替换成输入的值.
        Arrays.fill(a, 100);
        for(int ele : a){
            System.out.println(ele);
        }

        //Arrays.sort():对数组升序排列
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));

        //Arrays.parallelSort():对数组升序排列
        Arrays.parallelSort(b);
        System.out.println(Arrays.toString(b));

    }
}