JavaSE之基本语法及数组

一、Java语言概述

1、Java语言概述

1.1、基础常识

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

• 系统软件：windows , mac os , linux ,unix,android,ios,…
• 应用软件：word ,ppt,画图板,…

应用程序 = 算法 + 数据结构

1.2、常用的 DOS 命令

命令	备注
dir	列出当前目录下的文件以及文件夹
md	创建目录
rd	删除目录
cd	进入指定目录
cd …	退回到上一级目录
cd \	退回到根目录
del	删除文件
exit	退出 dos 命令行

1.3、计算机语言的发展迭代史

第一代：机器语言

第二代：汇编语言

第三代：高级语言

• 面向过程：C、Pascal、Fortran
• 面向对象：Java、JS、Python、Scala…

1.4、Java语言版本迭代概述

1991年 Green项目，开发语言最初命名为Oak (橡树)

1994年，开发组意识到Oak 非常适合于互联网

1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作

1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最

1998年，发布JDK 1.2，同年发布企业平台J2EE

1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生

2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0

2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME

2009年，Oracle公司收购SUN，交易价格74亿美元

2011年，发布JDK 7.0

2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本

2017年，发布JDK 9.0，最大限度实现模块化

2018年3月，发布JDK 10.0，版本号也称为18.3

2018年9月，发布JDK 11.0，版本号也称为18.9

1.5、Java语言的特点

面向对象性：

• 两个要素：类、对象
• 三个特征：封装、继承、多态

健壮性：

• 去除了C语言中的指针
• 自动的垃圾回收机制 -->仍然会出现内存溢出、内存泄漏

跨平台性：

• write once,run anywhere：一次编译，到处运行

2、开发环境搭建

2.1、JDK、JRE、JVM的关系

JDK = JRE + 开发工具集（例如 Javac 编译工具 等）

JRE = JVM + Java SE 标准类库

2.2、JDK的下载、安装

注意问题：安装软件的路径中不能包含中文、空格。

2.3、path环境变量的配置

为什么配置path环境变量

• path环境变量：windows操作系统执行命令时所要搜寻的路径
• 希望java的开发工具（javac.exe,java.exe)在任何的文件路径下都可以执行成功。

• 如何配置
  

3、编译Java程序

编写：将编写的java代码保存在以".java"结尾的源文件中

编译：使用javac.exe命令编译java源文件。格式：javac 源文件名.java

运行：使用java.exe命令解释运行字节码文件。 格式：java 类名

4、总结

在一个java源文件中可以声明多个class。但是，只能最多有一个类声明为public的。而且要求声明为public的类的类名必须与源文件名相同。

程序的入口是main()方法。格式是固定的。

输出语句：

• System.out.println():先输出数据，然后换行
• System.out.print():只输出数据

每一行执行语句都以";"结束。

编译的过程：编译以后，会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。

5、注释和API

5.1、三种注释方式

单行注释：

• 对所写的程序进行解释说明，增强可读性。方便自己，方便别人
• 调试所写的代码
• 编译以后生成的.class结尾的字节码文件中不包含注释掉的信息

多行注释

• 对所写的程序进行解释说明，增强可读性。方便自己，方便别人
• 调试所写的代码
• 编译以后生成的.class结尾的字节码文件中不包含注释掉的信息
• 不可以嵌套使用

文档注释(java特有)

• 注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
• javadoc -d mydoc -author -verson HelloWorld.java

5.2、API

API：application programming interface。习惯上：将语言提供的类库，都称为api

API文档：针对于提供的类库如何使用，给的一个说明书。类

二、基本语法

1、关键字和标识符

1.1、java关键字

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所字母都为小写

1.2、保留字

现Java版本尚未使用，但以后版本可能会作为关键字使用。

具体哪些保留字：goto 、const

注意：自己命名标识符时要避免使用这些保留字

1.3、标识符

Java对各种变量、方法和类等要素命名时使用的字符序列。

凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

• 由 26 个英文字母大小写， 0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java 中严格区分大小写，长度无限制。
• 标识符不能包含空格。

Java 中的名称命名规范：

• 包名 ：多单词组成时所有字母都小写 xxxyyyzzz
• 类名、接口名 ：多单词组成时，所有单词的首字母大写 XxxYyyZzz
• 变量名、方法名 ：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写： xxxYyyZzz
• 常量名 ：所有字母都大写。多单词时每个单词用下划线连接 XXX_YYY_ZZZ
• 注意：在起名字时，为了提高阅读性，要尽量意义，“见名知意”。

2、变量

2.1、变量分类

按数据类型分

类型	表示	说明
整型	byte(1字节=8bit) short(2字节) int(4字节) long(8字节)	1、byte范围：-128 ~ 127 2、声明long型变量，必须以"l"或"L"结尾 3、通常，定义整型变量时，使用int型。 4、整型的常量，默认类型是：int型
浮点型	float(4字节) double(8字节)	1、浮点型，表示带小数点的数值 2、float表示数值的范围比long还大 3、定义float类型变量时，变量要以"f"或"F"结尾 4、通常，定义浮点型变量时，使用double型。 5、浮点型的常量，默认类型为：double
字符型	char (1字符=2字节)	1、定义char型变量，通常使用一对’',内部只能写一个字符 2、表示方式：1.声明一个字符 ；2.转义字符 ；3.直接使用 Unicode 值来表示字符型常量
布尔型	boolean	1、只能取两个值之一：true 、 false 2、常常在条件判断、循环结构中使用

按声明位置分类（了解）

2.2、定义变量的格式

数据类型 变量名 = 变量值;

数据类型 变量名；变量名 = 变量值;

2.3、变量使用的注意点

变量必须先声明，后使用。

变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了。

同一个作用域内，不可以声明两个同名的变量。

2.4、自动类型转换

只涉及7种基本数据类型。

结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

数据类型按容量大小排序：byte 、char 、short --> int --> long --> float --> double

特别的：当byte、char、short三种类型的变量做运算时，结果为int型。

2.5、强制类型转换

只涉及7种基本数据类型。

自动类型提升运算的逆运算。

需要使用强转符：()

注意点：强制类型转换，可能导致精度损失。

2.6、String与8种基本数据类型间的运算

String属于引用数据类型，翻译为：字符串。

声明String类型变量时，使用一对""

String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+

运算的结果仍然是String类型

3、进制（了解）

3.1、进制及表示方式

二进制(binary)：0，1，满2进1，以0b或0B开头。

八进制(octal)：0-7，满8进1，以数字0开头。

十六进制(hex)：0-9及A-F，满16进1，以0x或0X开头，不区分大小写。

3.2、二进制的使用说明

计算机底层的存储方式：所有数字在计算机底层都以二进制形式存在。

二进制数据的存储方式：所有的数值，不管正负，底层都以补码的方式存储。

原码、反码、补码的说明：

• 正数：三码合一
• 原码：直接将一个数值转换成二进制数，最高位是符号位。
• 负数的反码：对原码按位取反，只是最高位（符号位）确定为1
• 负数的补码：其反码加1

4、运算符

4.1、算术运算符

%取余运算

• 结果的符号与被模数的符号相同。
• 开发中，经常使用%来判断能否被除尽的情况。

(前)++ ：先自增1，后运算；(后)++ ：先运算，后自增1

(前)–：先自减1，后运算；(后)–：先运算，后自减1

连接符+：只能使用在String与其他数据类型变量之间使用。

4.2、赋值运算符

= += -= *= /= %=

运算的结果不会改变变量本身的数据类型。

4.3、比较运算符

比较运算符的结果是boolean类型。

< >= <=：只能使用在数值类型的数据之间。

== 和 !=：不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

4.4、逻辑运算符

区分& 与 &&

• 相同点1：& 与 && 的运算结果相同。
• 相同点2：当符号左边是true时，二者都会执行符号右边的运算。
• 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
• 开发中，推荐使用&&

区分| 与 ||

• 相同点1：| 与 || 的运算结果相同。
• 相同点2：当符号左边是false时，二者都会执行符号右边的运算。
• 不同点：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算。
• 开发中，推荐使用||
• 逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型。

4.5、位运算符

运算符	运算	说明
<<	左移	空位补0 ，被移除的高位丢弃，空缺位补 0
>>	右移	被移位的二进制最高位是0 ，右移后，空缺位补 0；最高位是1 ，空缺位补 1
>>>	无符号右移	被移位二进制最高位无论是0 或者是 1 ，空缺位都用 0 补。
&	与运算	二进制位进行&运算，只有 1&1 时结果是 1 ，否则是 0
|	或运算	二进制位进行|运算，只有 0&0 时结果是 0 ，否则是 1
^	异或运算	相同二进制位进行^ 运算，结果是 0； 不相同二进制位进行^ 运算，结果是 1 。
~	取反运算	正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反

【面试题】你能否写出最高效的2 * 8的实现方式？ 答案：2 << 3 或 8 << 1

• 位运算符操作的都是整型的数据。
• << ：在一定范围内，每向左移1位，相当于 * 2
• 》》：在一定范围内，每向右移1位，相当于 / 2

4.6、三元运算符

格式：(条件表达式)? 表达式1 : 表达式2

• 条件表达式的结果为boolean类型。
• 根据条件表达式真或假，决定执行表达式1，还是表达式2：
  • 如果表达式为true，则执行表达式1。
  • 如果表达式为false，则执行表达式2。
• 表达式1 和表达式2要求是一致的。
• 三元运算符可以嵌套使用。
• 凡是可以使用三元运算符的地方，都可以改写为if-else；反之，不成立。
• 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。

5、流程控制

5.1、分支结构

5.1.1、if-else结构

if语句三种格式：

    第一种：
    if(条件表达式){
    	执行表达式
    }
    
    第二种：二选一
    if(条件表达式){
    	执行表达式1
    }else{
    	执行表达式2
    }
    
    第三种：n选一
    if(条件表达式){
    	执行表达式1
    }else if(条件表达式){
    	执行表达式2
    }else if(条件表达式){
    	执行表达式3
    }
    ...
    else{
    	执行表达式n
    }

• else 结构是可选的。
• 针对于条件表达式：
  • 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
  • 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
  • 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
• if-else结构是可以相互嵌套的。
• 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。

5.1.2、switch-case结构

格式

    switch(表达式){
    case 常量1:
    	执行语句1;
    	//break;
    case 常量2:
    	执行语句2;
    	//break;
    ...
    default:
    	执行语句n;
    	//break;
    }

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

• break可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

• switch结构中的表达式，只能是如下的6种数据类型之一：byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)

• case 之后只能声明常量。不能声明范围。

• break关键字是可选的。

• default：相当于if-else结构中的else。default结构是可选的，而且位置是灵活的。

• 如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。

• break在switch-case中是可选的。

5.2、循环结构

5.2.1、循环结构的四要素

• ①初始化条件
• ②循环条件 —>是boolean类型
• ③循环体
• ④迭代条件

通常情况下，循环结束都是因为②中循环条件返回false了。

5.2.2、for循环

  for(初始化条件;循环条件;迭代条件){
  	循环体
  }

执行过程：初始化条件 - 循环条件 - 循环体 - 迭代条件 - 循环条件 - 循环体 - 迭代条件 - … - 循环条

5.2.3、while循环

  初始化条件
  while(循环条件){
  	循环体;
  	迭代条件;
  }

执行过程：初始化条件 - 循环条件 - 循环体 - 迭代条件 - 循环条件 - 循环体 - 迭代条件- … - 循环条件

• 写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！

for和while循环总结：

• 开发中，基本上我们都会从for、while中进行选择，实现循环结构。
• for循环和while循环是可以相互转换的！
• 区别：for循环和while循环的初始化条件部分的作用范围不同。

5.2.4、do-while循环

 初始化条件
 do{
 	循环体;
 	迭代条件;
 }while(循环条件);

执行过程：初始化条件 - 循环体 - 迭代条件 - 循环条件 - 循环体 -迭代条件 - … - 循环条件

• do-while循环至少会执行一次循环体！
• 开发中，使用for和while更多一些。较少使用do-while。

5.2.5、无限循环结构

while(true) 或 for(;;)

如何结束一个循环结构

• 方式一：当循环条件是false时
• 方式二：在循环体中，执行break

5.2.6、嵌套循环

将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环。

• 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次。
• 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次。
• 外层循环控制行数，内层循环控制列数。

补充：衡量一个功能代码的优劣

• 正确性
• 可读性
• 健壮性
• 高效率与低存储：时间复杂度 、空间复杂度 （衡量算法的好坏）

5.3、break和continue

关键字	适用范围	循环中使用的作用（不同点）	相同点
break	switch-case结构 循环结构	结束当前循环	关键字后面不能声明执行语句
continue	循环结构中	结束当次循环	关键字后面不能声明执行语句

带标签的break和continue的使用

    label:for(int i = 1;i <= 4;i++){
        for(int j = 1;j <= 10;j++){
    		if(j % 4 == 0){
                //break label;//结束指定标识的一层循环结构
                continue label;//结束指定标识的一层循环结构当次循环
            }
            System.out.print(j);
        }
        System.out.println();
    }

5.4、Scanner类的使用

从键盘获取不同类型的变量时需要使用Scanner类。

具体实现步骤：

• 导包：import java.util.Scanner;

• Scanner的实例化:Scanner scan = new Scanner(System.in);

• 调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

    //调用Scanner类的相关方法
    String name = scan.next();
    int age = scan.nextInt();
    double weight = scan.nextDouble();
    boolean isLove = scan.nextBoolean();
    
    //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串。
    String gender = scan.next();
    char genderChar = gender.charAt(0);//获取索引为0位置上的字符

注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException，导致程序终止。

三、数组

1、数组概述

数组的理解：数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组相关的概念：

• 数组名

• 元素

• 角标、下标、索引

• 数组的长度：元素的个数

数组的特点：

• 数组是有序排列的。
• 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间。
• 数组的长度一旦确定，就不能修改。

数组的分类：

• 照维数：一维数组、二维数组、。。。
• 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组。

2、一维数组

2.1、声明与初始化

  //静态初始化:数组的初始化和数组元素的赋值操作同时进行
  int[] ids = new int[]{1001,1002,1003,1004};
  //动态初始化:数组的初始化和数组元素的赋值操作分开进行
  String[] names = new String[5];
  //类型推断
  int[] arr4 = {1,2,3,4,5};

2.2、元素的引用

通过角标的方式调用。

数组的角标（或索引）从0开始，到数组的长度-1结束。

2.3、length属性

说明：数组一旦初始化，其长度就是确定的。数组长度一旦确定，就不可修改。

2.4、遍历

 for(int i = 0;i < names.length;i++){
 	System.out.println(names[i]);
 }

2.5、默认初始化值

数组元素是整型：0

数组元素是浮点型：0.0

数组元素是char型：0或’\u0000’，而非’0’

数组元素是boolean型：false

数组元素是引用数据类型：null

2.6、内存解析

3、二维数组

3.1、如何理解二维数组

数组属于引用数据类型。

数组的元素也可以是引用数据类型。

一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

3.2、声明与初始化

  //静态初始化
  int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
  //动态初始化1
  String[][] arr2 = new String[3][2];
  //动态初始化2
  String[][] arr3 = new String[3][];
  //类型推断
  int[] arr4[] = {{1,2,3},{4,5},{6,7,8}};

3.3、元素的引用

 System.out.println(arr1[0][1]);//2
 System.out.println(arr2[1][1]);//null
 		
 arr3[1] = new String[4];
 System.out.println(arr3[1][0]);
 System.out.println(arr3[0]);

3.4、获取数组长度

 System.out.println(arr4.length);//3
 System.out.println(arr4[0].length);//3

3.5、遍历

 for(int i = 0;i < arr4.length;i++){	
     for(int j = 0;j < arr4[i].length;j++){
         System.out.print(arr4[i][j] + "  ");
     }
     System.out.println();
 }

3.6、默认初始化值

针对于初始化方式一：比如：int[][] arr = new int[4][3];

• 外层元素的初始化值为：地址值

• 内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];

• 外层元素的初始化值为：null

• 内层元素的初始化值为：不能调用，否则报错。

3.7、内存结构

4、数组常见算法

4.1、数组的创建与元素赋值

杨辉三角（二维数组）

1、第一行有1个元素，第n行有n个元素
2、每一行的第一个元素和最后一个元素都是1
3、从第三行开始，对于非第一个元素和最后一个元素的元素。即：yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

    public class YangHuiTest {
        public static void main(String[] args) {
            //1.声明并初始化二维数组
            int[][] array = new int[10][];
    
            //2.给数组的元素赋值
            for (int i = 0; i < array.length; i++) {
                array[i] = new int[i + 1];
                //2.1 给首末元素赋值
                array[i][0] = array[i][i] = 1;
                //2.2 给每行的非首末元素赋值
                for (int j = 1; j < array[i].length -1; j++) {
                    array[i][j] = array[i-1][j] + array[i-1][j-1];
                }
            }
    
            //3.遍历二维数组
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    System.out.print(array[i][j] + " ");
                }
                System.out.println();
            }
        }
    }

4.2、针对数值型的数组

求最大值、最小值、总和、平均数等。

随机数获取[10,99]：(int)(Math.random() * (99 - 10 + 1) + 10)

4.3、数组的赋值与复制

赋值：array2 = array1

如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

复制

    array2 = new int[array1.length];
    for(int i = 0;i < array2.length;i++){
    	array2[i] = array1[i];
    }

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.4、数组元素的反转

 //方法一：
 for(int i = 0;i < arr.length / 2;i++){
     String temp = arr[i];
     arr[i] = arr[arr.length - i -1];
     arr[arr.length - i -1] = temp;
 }
 //方法二：
 for(int i = 0,j = arr.length - 1;i < j;i++,j--){
     String temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
 }

4.5、数组中指定元素的查找

线性查找

• 实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
• 适用性：具有普遍适用性。

二分法查找

• 实现思路：每次比较中间值，折半的方式检索。
• 适用性：（前提：数组必须有序）。

4.6、数组的排序算法

冒泡排序

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
    
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

5、Arrays工具类的使用

定义在java.util包下。Arrays提供了很多操作数组的方法。

 //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
 boolean isEquals = Arrays.equals(arr1, arr2);
 
 //2.String toString(int[] a):输出数组信息。
 System.out.println(Arrays.toString(arr1));
 
 //3.void fill(int[] a,int val):将指定值填充到数组之中。
 Arrays.fill(arr1,10);
 
 //4.void sort(int[] a):对数组进行排序。
 Arrays.sort(arr2);
 
 //5.int binarySearch(int[] a,int key)
 int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
 int index = Arrays.binarySearch(arr3, 210);
 if(index >= 0){
     System.out.println(index);
 }else{
     System.out.println("未找到");
 }

6、数组常见异常

数组角标越界的异常：ArrayIndexOutOfBoundsExcetion

空指针异常：NullPointerException

注意：一旦程序出现异常，未处理时，就终止执行。