Java语言基础二之Java基本语法

Java基本语法

变量和运算符

关键字和保留字

• 关键字
  • 被Java语言赋予了特殊含义，用作专门用途的字符串
  • 关键字中所有字母都为小写
• 保留字
  • goto 、const
  • 以后版本可能会作为关键字使用

标识符

• 由26个英文字母大小写，0-9， _ 或$组成
• 不能以数字开头
• 不能为关键字和保留字，但可以包含
• 名称命名规范
  • 包名：多单词组成时所有字母都小写 xxxyyyzzz
  • 类名：骆驼命名法 XxxYyyZzz
  • 变量名、方法名：第一个单词首字母小写，之后采用骆驼命名法 xxxYyyZzz
  • 常量名：所有字母都大写，多单词时可以用下划线链接 XXX_YYY_ZZZ

变量

• 变量必须先声明后使用

• 变量的定义格式：__ 变量类型 变量名 = 存储的值__

• 变量在作用域内有效

常量

利用final关键字指示常量，表示只能被赋值一次，之后无法更改
final double CM_PER_INCH = 2.54

数据类型（四类八种）

1. 整型：byte、short、int、long

   • byte也就是字节，1byte = 8bits，byte的默认值是0【-128~127】
   • short占用两个字节，16位，默认值为0
   • int占用四个字节，32位，默认值为0
   • long占用八个字节，64位，默认值为0L（不加L的话默认是int型保存为long型）
   • long > int > short > byte

2. 浮点类型：float、double

   • float是单精度浮点型，4字节，默认值为0.0f（不加f默认是double型，无法向float自动转换，会报错）
   • double是双精度浮点型，8字节，默认值为0.0
   • float表示数值的范围比long还大

3. 字符型

   • char是2字节的Unicode字符，通常使用单引号，最小值为\u0000(0)，最大值为\uffff(65535)，可以存储任何字符，还可以存储转义字符。char a=‘A’，char c =‘中’。

4. 布尔型

   • boolean只有两种值false、true，只表示1位

5. 类型转换（七种数据类型之间的转换，不包含boolean）

   • 自动类型提升
     当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的类型。（容量：表示数的范围的大小）
     byte、char、short --> int --> long --> float --> double
     当byte、char、short三种类型的变量做运算时，结果为int类型
   • 强制类型转换
     自动类型提升的逆运算。
     需要使用强转符：( )
     强制类型转换，可能会导致精度损失

6. 其他
   整型常量，默认为int型；
   浮点型常量，默认为double型

7. String类型
   ① 是引用数据类型，是不可变的
   ② 使用一对 ” “
   ③ 可以和基本数据类型做运算，只有 “+” 连接运算，运算结果仍为String类型

   ④子串

   String greeting = "Hello";
   String s = greeting.substring(0,3);
   //获得Hel的子串
   

   substring方法获得一个前闭后开区间的子串

   substring(a,b)的子串长度为b-a

   ⑤拼接

   如果需要把多个字符串放在一起，用一个定界符分隔，可以使用静态join方法

   String all = String.join("/","S","M","L","XL");
   //输出S/M/L/XL
   

   ⑥ 检测字符串是否相等

   使用equals方法检测两个字符串是否相等

   s.equals(t);
   //true or false
   

   ⑦ 构建字符串

   每次连接字符串，都会构建一个新的String对象，效率较低，使用StringBuilder类就可以避免这个问题的发生。

   • 首先建立一个空的字符串构建器：

   StringBuilder builder = new StringBuilder();
   

   • 当添加一部分内容时，调用append()方法

   builder.append(ch);
   builder.append(str);
   

   • 构造字符串时，就调用toString方法，将可以得到一个String对象

     String s = builder.toString();
     

进制转换

1. 不同进制的表示方式

• 二进制：0,1，满2进1，以0b或0B开头
• 十进制：0-9，满10进1
• 八进制：0-7，满8进1，以数字 0开头表示
• 十六进制：0-9及A-F，满16进1，以0x或0X开头表示。此处的A-F不区分大小写。

运算符

1. 赋值运算符
   =

2. 算数运算符
   +、-、 * 、/、%
   优先级顺序决定了计算顺序，先加减后乘除，__（）__的优先级最高。

3. 自增、自减运算符
   a++、++a

4. 比较运算符
   

   比较运算符的运算结果是boolean型，结果是true或false。

5. 逻辑运算符
   

6. 按位运算符
   操作整数基本类型中的每个比特位，也就是二进制位。
   

7. 移位运算符

运算符	含义
>>	右移运算符
<<	左移运算符

用来将操作数向某个方向（向左或者右）移动指定的二进制位数
<< ：在一定范围内，每向左移1位，相当于 * 2

>> : 在一定范围内，每向右移1位，相当于 / 2

8. 三元运算符

   条件表达式？表达式1：表达式2

   为true时调用表达式1，为false时调用表达式2。

9. 运算符的优先级
   想早运算就加括号

输入输出

读取输入

1. 构造一个Scanner对象，并与标准输入流System.in关联

   Scanner in = new Scanner(System.in);
   

2. 可以使用Scanner类的各种方法实现输入操作了

   例如，使用nextLine方法将输入一行

   String name = in.nextLine();
   

   如果想读入一个单词（以空白符作为分隔符），调用next

   String firstName = in.next();
   

   想读取一个整数，调用nextInt方法

   int age = in.nextInt();
   

   想读取下一个浮点数，调用nextDouble方法

   Scanner类定义在java.util包中，要使用import导入

   import java.util.*;
   

3. Console类实现读取密码

   因为输入可见，所以Scanner类不适用于从控制台读取密码，引入了Console类实现这个目的。想要读取一个密码，采取下列代码：

   Console cons = System.console();
   String username = cons.readLine("User name:");
   char[] passed = cons.readPassword("Password:");
   

4. 检测输入中是否有其他单词

   使用hasNext（），返回一个boolean值

输出

1. 使用System.out.print(x)输出数值x

2. 格式化输出

   使用printf方法

   System.out.printf("%8.2f",x);
   //用八个字符的宽度和小数点后两个字符的精度打印x
   //3333.33（1个空格和7个字符）
   

   可以使用多个参数，以%开始

   System.out.printf("Hello,%s.Next year,you'll be %d",name,age);
   

   转换符	类型	举例
   d	十进制整数	159
   x	十六进制整数	9f
   o	八进制整数	237
   f	定点浮点数	15.9
   e	指数浮点数	1.59e+01
   s	字符串	Hellp
   c	字符	H
   b	布尔	True

   控制格式化输出的各种标志

   System.out.printf("%,.2f",10000.0/3.0);
   //打印：3,333.33
   //添加分组分隔符
   

   可以使用多个标志，例如，”%,(.2f“使用分组的分隔符并将负数括在括号内

文件的输入与输出

想对文件进行读取，需要一个用File对象构造一个Scanner对象

Scanner in = new Scanner(Paths.get("myfile.txt"),"UTF-8");

如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠。

想要写入文件，需要构造一个PrintWriter对象。在构造器中，只需要提供文件名：

PrintWriter out = new PrintWriter("myFile.txt","UTF-8");

可以像输出到System.out一样使用print、println、printf命令。

也可以使用绝对路径。

程序流程控制

条件语句

1. if-else 结构

   • if语句的三种格式

     if(条件表达式){
         执行代码块;
     }
     

     if(条件表达式){
         执行代码块1;
     }else{
         执行代码块2;
     }
     

     if(条件1){
         执行代码块1;
     }else if(条件2){
         执行代码块2;
     }.....
     else{
         执行代码块;
     }
     

2. switch-case 结构

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

循环语句

1. for循环

   • 在第一次迭代前进行初始化

   for(初始化;布尔表达式;步进){
       
   }
   

   ​ 每次迭代前会测试布尔表达式，如果结果false，则跳出循环

   • 可以在for语句内定义多个变量，但它们必须有相同的类型

   for(int i=1;j=i+10;i<5;i++,j=j*2){
       
   }
   

   • for-each语句

     方便对数组和集合进行遍历的方法：for-each

   int a[] = {7,8,9};
   for(int arr : a){
       System.out.println(arr);
   }
   

2. while循环

   while(布尔值){
   	表达式
   }
   

   布尔值也是一个表达式

3. do-while循环

   while循环和do-while循环的唯一区别是do-while语句至少执行一次。即使第一次的条件为false。

   do{
       表达式
   }while(布尔值);
   

4. 跳转语句

   有三种跳转语句：break、continue、return

   • break

     强行退出当前循环，默认结束最近的循环

     • 带标签的break

       用于跳出多重嵌套的循环语句，结束指定循环

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

   • continue

     直接执行下一次循环

   • return

     可以从一个方法返回，并把控制权交给调用它的语句

大数值

如果基本的整数和浮点数精度不能满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger（处理整数）和BigDecimal（处理浮点数）。这两个类可以处理包含任意长度数字序列的数值。

将普通数值转化为大数值

使用静态的valueOf方法

BigInteger a = BigInteger.valueOf(100);

大数值的运算

1. 加法运算

   add方法

   BigInteger c = a.add(b);
   

2. 减法运算

   subtract()方法

   BigInteger c = a.subtract(b);
   

3. 乘法运算

   multiply()方法

4. 除法运算

   divide()方法

例如计算：

lotteryOdds = lotteryOdds*(n-i+1) / i;

换成大数值计算为：

lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n-i+1)).devide(BigInteger.valueOf(i));

比较大数值相等

使用 compareTo()函数，a.compareTo(b)如果a和b相等，返回0；如果a<b，返回负数；否则，返回正数。

数组

数组的概述

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

声明数组变量：

int[] a;

并未真正将a初始化，使用new运算符创建数组：

int[] a = new int[100];

创建一个数字数组时，所有元素都初始化为0；创建一个boolean数组时，所有元素都初始化为false；创建一个对象数组时，所有元素都初始化为null。

String[] names = new String[10];
//所有字符串均为null

获取数组的元素个数

使用array.length

一旦创建了数组，就不能再改变它的大小。

数组的内存解析：

JVM解析：

对象的属性（非static）加载在堆空间中。

数组初始化以及匿名数组

创建数组对象并同时赋予初始值（不需要调用new）：

int[] smallPrimes = {2,3,5,7,11,13};

初始化一个匿名的数组：

new int[]{17,19,23}

使用匿名数组，在不创建新变量的情况下重新初始化一个数组：

smallPrimes = new int[]{17,19,23};

数组拷贝

1. 两个变量引用同一个数组

   int[] luckyNum = smallPrimes;
   luckyNum[5] = 12;
   //此时smallPrimes[5]=12
   

2. copyOf

   如果希望将一个数组的所有值拷贝到一个新的数组中去，使用Arrays类的copyOf方法

   int[] newArray = Arrays.copyOf(arrayName,arrayName.length);
   

   第二个参数是新数组的长度，通常用来增加数组的大小

命令行参数

public static void main(String[] args)中的String[] args参数表明main方法将接收一个字符串数组，即命令行参数

java className -g cruel world
//args[0]="-g"
//args[1]="cruel"
//args[2]="world"

数组排序

使用Arrays类中的sort方法进行排序。（优化的快速排序算法）

int[] a = new int[10000];
...
Arrays.sort(a);

得到0~n-1之间的随机数

(int)(Math.random()*n)

将所有数组元素设置为一个值

fill(type[] a , type v)

将数组的所有数据元素值设置为v

比较两个数组的大小

equals(type[] a, type[] b)

如果两个数组大小相同，并且下标相同的元素都对应相等，返回true

输出数组信息

toString(type[] a)

输出 [a[0],a[1],…]

二维数组

初始化

1. 调用new进行初始化

   //动态初始化
   double[][] balances = new double[3][2];
   double[][] balance = new double[3][];
   //静态初始化
   int[][] balances2 = new int[][]{{1,2,3},{4,5,6}};
   

2. 不调用new

   int[][] a = {{16,3,2},{35,2,10}};
   

访问

a[i][j]

快速的打印二维数组的数据元素列表

Arrays.deepToString(a);
//打印[[16,3,2],[35,2,10]]

实际上没有多维数组，多维数组是数组的数组

内存解析：

不规则数组

数组的每一行都有不同的长度

int[][] ods = new int[maxn+1];
for(int n =0;n<=max;n++){
    ods[n] = new int[n+1];
}
//得到一个三角形的矩阵，第i行有i+1个