3.1 一个简单的Java应用程序
public class FirstSample{
public static void main(String[] args){
System.out.println("We will not use 'Hello World!'");
}
}
- Java对大小写敏感
- public关键字称为访问修饰符（access modifier），用于控制程序的其他部分对这段代码的访问级别
- class关键字 - 类是构建所有Java应用程序的构建块，Java应用程序中的全部内容都必须放置在类中。
- 类名命名规范：
2)骆驼命名法：如果类名中有多个单词组成，每个单词的第一个字母都应该大写
3)源代码文件名必须与公共类的名字相同，并用.java作为扩展名。对于上面源代码，文件命名为FirstSample.
- javac FirstSample.java
- java FirstSample
- 每条语句必须由分号结束
- 可以将一条语句写在多行上，回车不是语句结束的标志。
- 三种注释方式
2)/* */ -----多行注释，注释内容可以写在多行，此注释方式不能嵌套
3)/**
*This is the first sample program in Core Java
*@version 1.01 1997-03-22
*@author Gary Cornell
*/
public class FirstSample{
public static void main(String[] args){
System.out.println("We will not use 'Hello World!'");
}
}
这种方式的注释可以用来自动生成文档
3.3 数据类型
- Java是一种强类型语言，即必须为每一个变量声明一种数据类型。
- 8种基本类型（primitive type）
2)2种浮点型 float double
3)1种字符类型char ---用于表示Unicode编码的字符单元的字符类型char
4)1种用于表示真值的boolean类型
- 整型 ----用于表示没有小数部分的数值，允许是负数
1)int类型最常用
2)表示地球上的人数，就要用long型了
3)byte和short类型主要用于特定场合
4)Java中整型的范围与运行Java代码的机器无关。这就解决了软件在不同平台或同平台不同操作系统间移植的问题。由于Java程序必须保证在所有机器上都能够得到相同的运行结果，所以每种数据类型的取值范围必须固定。
5)长整型数值有一个后缀L（如4000000000L）
6)十六进制数有一个前缀0x（如0xCAFE）
7)八进制数有一个前缀0（如010）
8)二进制数有一个前缀（如0b1001，就是9） 【Java7开始】
9)可以为数字字面量加下划线,，（如1_000_000或0b1111_0100_0010_0000 表示1百万），只是为了更易读，Java编译器会去除这些下划线。
10)Java没有任何无符号类型（unsighed）
- 浮点类型 -----用于表示有小数部分的数值
1)double表示这种类型的数据精度是float类型的两倍，绝大部分应用程序都采用double类型
2)只有很少情况下，使用使用float类型
3)float类型的数值有一个后缀F(如3.14F)，没有后缀F的浮点数值（如3.14）默认为double型
4)三个特殊的浮点数值 ---- 用于表示溢出和出错的情况
a)正无穷大 ---- 对应常量Double.POSITIVE_INFINITY
一个正整数除以0的结果为正无穷大
b)负无穷大 ---- 对应常量Double.NEGATIVE_INFINITY
c)NaN（不是一个数字） ----- 对应常量Double.NaN
0/0或者负数的平方根结果为NaN
5)所有非数值的值都是不相同的，可以使用Double.isNaN方法来检验某个值是否为NaN
if(Double.isNaN(x))
而不能使用如下方式检验
if(x==Double.NaN)
6)如果需要在数值计算中不含任何舍入误差，就用该使用BigDecimal类
- char类型 ----用于表示单个字符。通常用来表示字符常量。
2)强烈建议不要在程序中使用char类型，最好将需要处理的字符串用抽象数据类型表示。
- boolean类型
3.4 变量
- 每一个变量属于一种类型（type），声明变量时，变量所属的类型位于变量名之前。声明是完整语句，必须由分号结尾。变量名必须以字母开头的由字母、下划线和数字组成。
int vacationDays;
long earthPopulation;
boolean done;
- 也可以在一行中声明多个同类型的变量，但不提倡这种做法，可读性差。
- 变量名是大小写敏感的。hireDay和hireday是两个完全不同的变量。
- 变量名不能使用java保留字。
- 变量初始化
int vacationDays; //声明变量
System.out.println(vacationDays); //未被初始化就使用了，出错 variable not initialized
2)对已经声明过的变量进行赋值
int vacationDays;
vacationDays = 12;
3)也可以将变量的声明和初始化放在同一行
int vacationDays = 12;
4)Java中可以将变量声明放在代码中的任何位置（有些语言必须将所有变量声明放在最前面的位置）
5)在Java中，变量的声明尽可能的靠近变量第一次使用的地方，这是一种良好的编程风格。
- 常量
利用关键字final定义。表示这个变量只能被赋值一次，一旦被赋值之后，就不能再被改变了。习惯上常量名使用全大写。
public class Constants{
public static void main(String[] args){
final double CM_PER_INCH = 2.54; //位于main方法内部
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
}
}
2)类常量
Java中，经常希望某个常量能在一个类中的多个方法中使用，或者提供给其他类使用，通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。
public class Constants2{
public static final double CM_PER_INCH = 2.54; //位于main方法外部（类的成员变量），因此可供类内部的所有方法使用，而且由于定义为public，因此其他类的方法也能使用这个常量，使用方法为Constants2.CM_PER_INCH
public static void main(String[] args){
double paperWidth = 8.5;
double paperHeight = 11;
System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH);
}
}
3.5 运算符
- 算术运算符
1) 加 +
2) 减 -
3) 乘 *
4) 除 /
a)当参与/运算的两个操作数都是整数时，表示整数除法；
15/2等于7
整数被0整除会产生一个异常
b)否则，表示浮点除法。
15.0/2等于7.5
浮点数被0除会得到无穷大或NaN结果。
5)求余（取模） %
15%2等于1
6)可以在赋值语句中采用简化格式书写二元算术运算符
x += 4;
等价于：
x = x+4;
类似还有：*=或%=
- 自增运算符与自减运算符
int n = 7;
int a = 2 * ++m; //a为16，m为8 前缀方式，先自增，后使用
int b = 2 * n++; //b为14, n为8 后缀方式，先使用，后自增
- 关系运算符和boolean运算符
a) == 检测是否相等
3 == 7 的值为false
b) != 检测是否不想等
3 != 7 的值为true
c) 经常使用的关系运算符还有：
< 小于
> 大于
<= 小于等于
>= 大于等于
2)boolean逻辑运算符
a) && 表示逻辑“与”
按照短路方式求值，如果第一个操作数能够确定表达式的值，第二个操作数就不必计算了。
expression1 && expression2
若expression1值为false，则整个逻辑表达式的值为false，因此expression2就不计算了，即expression2有异常也不会报错。
b) || 表示逻辑“或”
按照短路方式求值，如果第一个操作数能够确定表达式的值，第二个操作数就不必计算了。
expression1 || expression2
若expression1值为true，则整个逻辑表达式的值为true，因此expression2就不计算了，即expression2有异常也不会报错。
c) ！ 表示逻辑“非”
3) ? 三元操作符
condition ? expression1 : expression2
当条件condition为真时，计算第一个表达式，并将表达式值作为整个三元表达式的值。
当条件condition为假时，计算第二个表达式，并将表达式值作为整个三元表达式的值。
- 位运算符
2) | 或
3) ^ 异或
4) ~ 非
5) >> 右移位
6) << 左移位
7) >>> 右移位
public class BitOperator {
public static void main(String[] args) {
//转换为十进制输出，结果为8
int i = 0b1000;
System.out.println(i);
//取非,结果为-9，不明白为什么？
int j = ~i;
System.out.println(j);
//取余，结果为8
int x = i & 0b11000;
System.out.println(x);
//取或，结果为9
int y = i | 0b0001;
System.out.println(y);
//取异或，结果为5
int z = i ^ 0b1101;
System.out.println(z);
//向左移两位，结果为32
int a = i << 2;
System.out.println(a);
//向右移两位，结果为2
int b = i >> 2;
System.out.println(b);
//向右移两位，结果为2.和上面的区别还是不清楚。>>>运算符将用0填充高位；>>运算符用符号位填充高位
int c = i >>> 2;
System.out.println(c);
//当int类型时，需要对>>右侧的操作数求摸32预算后，再移位.结果为2
int d = i >> 34;
System.out.println(d);
//当int类型时，需要对>>右侧的操作数求摸64预算后，再移位,结果为2
long e = i >> 66;
System.out.println(e);
}
- 数学函数与常量
a) Math.sqrt(x) //计算一个数值的平方根
b) Math.power(x,a) //幂运算 求x的a次幂
c) 常用三角函数
Math.sin
Math.cos
Math.tan
Math.atan
Math.atan2
d) 指数函数以及他的反函数——自然对数以及以10为底的对数
Math.exp
Math.log
Math.log10
e) Math.round(x) //舍入运算符，返回long类型的数值
2)Java还提供两个表示π和e常量的近似值
Math.PI
Math.E
- 数值类型之间的转换
1)上图6个实心箭头，表示无信息丢失的转换。有三个虚箭头，表示可能有精度损失的转换。
当两个数值进行二元操作时，先要将两个操作数转换为同一种类型，然后再进行计算。
如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个操作数将会转换为long类型。
否则，两个操作数都会被转换成int类型。
- 强制类型转换
- 括号 与运算符级别
- 枚举类型
enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
Size s = Size.MEDIUM;
Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者null值。null表示这个变量没有设置任何值。
3.6 字符串
- Java字符串就是Unicode字符序列。Java没有内置的字符串类型，而是在标准的Java类库中提供一个预定义类，很自然的叫做String。每个用双引号括起来的字符串都是String类的一个实例。
String greeting="Hello";
- 子串
String greeting = "Hello";
String s = greeting.substring(0,3); //第二个参数是不想赋值的第一个位置，从0开始计数，指导3为止，但不包含3.
创建一个由“Hel”组成的字符串
substring的工作方式有一个优点：容易计算字串的长度，字符串s.substring(a,b)的长度为b-a
- 拼接
当将一个字符串与一个非字符串拼接时，后者被转换成字符串，任何一个Java对象都可以转换为字符串
- 不可变字符串
greeting = greeting.substring(0,3) + "p!";
2)由于不能修改Java字符串中的字符，所以在Java文档中将String类对象称为不可变字符串。当然可以修改字符串变量 greeting，让他引用另外一个字符串。
3)不可变字符串有一个优点，编译器可以让字符串共享。字符串放在公共的存储池中，字符串变量指向存储池中相应的位置，如果复制一个字符串变量，原始字符串变量和复制的字符串变量共享相同的字符。Java设计者认为，共享的效率远远胜过提取、拼接字符串带来的低效率。
- 检测字符串是否相等
s.equals(t)
相等返回true，不相等返回false。
s与t可以是字符串变量，也可以是字符串常量。
"Hello".equals(greeting);
检查两个字符串是否相等，而不区分大小写
"Hello".equalsIgnoreCase("hello");
2)一定不能使用==运算符检测两个字符串是否相等。这个预算符只能检查这两个字符串是否放在同一个位置上。当然如果字符串放置在同一个位置上必然相等，但是，完全有可能将内容相同的多个字符串拷贝放置在不同的位置上。
String greeting = "Hello";
if(greeting == "Hello") ...
也许返回true
if(greeting.substring(0,3) == "Hel")...
也许返回false
如果虚拟机始终将相同的字符串共享，就可以使用==运算符检测是否相等。但实际上只有字符串常量是共享的，而+或substring等操作的结果并不是共享的。
- 空串和Null串
if(str.length() == 0)
或
if(str.equals(""))
空串是一个Java对象，有自己的串长度（0）和内容（空）
2)String变量还可以存放一个特殊值，null
表示目前没有任何对象与该变量关联。
要检查一个字符串是否为null，要使用以下条件：
if(str == null)
要检查一个字符串即不是null也不为空
if(str != null && str.length() != 0)
如果在一个null值上调用方法，会出现错误。
- 代码点与代码单元
- 字符串API
- 阅读联机API文档
- 构建字符串
由较短的字符串构建字符串，解决字符串连接方式低效率问题。
StringBuilder builder = new StringBuilder();
builder.append(ch); //追加单个字符
builder.append(str); //追加字符串
在需要构建字符串时，就调用toString()方法，得到一个String对象。
String completeString = builder.toString();
2)StringBuffer
是StringBuilder的前身，其效率稍低。但允许采用多线程执行添加或删除字符的操作。如果所有字符串在一个单线程中编辑（通常都是这样），则应该用StringBuilder替代。这两个类的API是相同的。
- 读取输入（标准输入流 System.in）
import java.util.*;
public class InputTest {
public static void main(String[] args) {Scanner in = new Scanner(System.in); //构造一个Scanner对象，并于标准输入流关联System.out.print("What's your name?");String name = in.nextLine(); //输入一行System.out.print("How old are you?");int age = in.nextInt(); //输入一个整型数值System.out.println("Hello, " + name + ". Next year, you'll be" + (age + 1));}
}
- 格式化输出
- 文件输入与输出
package corejava;import java.io.FileNotFoundException;import java.io.IOException;import java.io.PrintWriter;import java.nio.file.Paths;import java.util.*;public class FileInOutput {public static void main(String[] args) throws FileNotFoundException,IOException {
//PrintWriter out = new PrintWriter("F:\Java\corejava\book.txt"); 绝对路径写法PrintWriter out = new PrintWriter("book.txt"); //相对路径写法out.println("code complete");out.println("Spring in action");out.close();//Scanner in = new Scanner(Paths.get("F:\Java\corejava\book.txt"));Scanner in = new Scanner(Paths.get("book.txt"));String book1 = in.nextLine();String book2 = in.nextLine();in.close();System.out.println("book1:" + book1);System.out.println("book2:" + book2);System.out.println(System.getProperty("user.dir")); //Java虚拟机启动路径为F:Javacorejava 因此上面的绝对路径和相对路径写法是等价的。}
}
3.8 控制流程
- 块（block）作用域
1)块（即复合语句），是指由以对花括号括起来的若干简单的Java语句。2)块确定了变量的作用域3)一个块可以嵌套在另一个块中，但是不能在两个嵌套的块中声明同名的变量。
- 条件语句
statement;
}
- 循环
while (condition) statement; //循环体中的内容，可能一次都不被执行
2)do..while循环
do statement while(condition); //循环体中的内容，至少被执行一次
3)for循环
- 多重选择：switch语句
2)枚举常量
enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE};
Size sz = Size.LARGE;
switch(sz)
{
case SMALL: //no need to use Size.SMALL
....
break;
...
}
3)Java SE7开始，case标签还可以是字符串字面量
String input = ...;
switch(input.toLowerCase())
{
case "yes";
....
break;
.....
}
- 中断控制流程语句
用于退出switch语句、while语句、do..while语句、for语句
2)带标签的break语句，用于跳出多重嵌套的循环语句。只能跳出语句块，而不能跳入语句块。
......
read_data:
while(...)
{
....
for(...)
{
......
break read_data:
.......
}
}
//跳出标签后，从下面语句开始执行
................
3)continue语句
越过当前循环体的剩余部分，立刻跳到循环首部。计数器自增后，继续执行循环体。
4)带标签的continue语句
将跳到与标签匹配的循环首部。
3.9 大数值
- java.Math包中的两个很有用的类：BigInteger和BigDecimal
- 这两个类实现了可以处理包含任意长度数字序列的数值
- BigInteger a= BigInteger.valueOf(100); //使用静态的valueOf方法将普通的数值转换为大数值
- 不能使用普通的算术运算符 + - * /来处理大数值，而需要使用大数值类中的add和multipy方法。
BigInteger d = c.multiply(b.add(BigInter.valueOf(2))); // d= c*(b + 2)
import java.math.BigInteger;
public class BigIntegerTest {public static void main(String[] args) {BigInteger a = BigInteger.valueOf(5);BigInteger b = BigInteger.valueOf(6);BigInteger c = a.add(b);BigInteger d = a.multiply(b);System.out.println(c);System.out.println(d);}}
3.10 数组
- 数组是一种数据结构，用来存储同类型的值的集合。
- 通过一个整型小标可以访问数组中的每个值。a[i]表示整型数组中，第i个元素。
- 申明数据变量
- 初始化数组
int[] a = new int[100]; //这个数组的下标是0-99，若访问a[100]，或任何在0-99之外下标的元素，就会引发“array index out of bounds”异常而终止执行。
- 创建一个数字数组时，所有元素都初始为0，boolean数组的元素会初始化为false。对象数组的元素则初始化为null
for(int i =0;i<10;i++){
names[i] = "";
}
//此时，数组中的元素都为""，空串。
- 一旦创建了数组，就不能改变它的大小，尽管可以改变数组中的每个元素的值。
- 如果经常需要在运行的过程中扩展数组的大小，则应该使用另一种数据结构：数组列表(array list)
- for each循环
statement;
}
//variable--定义一个变量用于暂存集合中的每一个元素
//collection--这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象。如，ArrayList
- 在很多情况下，还是需要使用传统的for循环，例如，不希望遍历集合中的每个元素，或者在循环内部需要使用下标等。
- 打印数组中的所有值
Arrays.toString(a); //返回一个包含数组元素的字符串 [2,3,5,10]
- 数组初始化
使用这种语法，不需要调用new
利用括号中提供的值进行初始化，数组的大小就是初始值的个数。
- 匿名数组
这种语法形式可以在不创建新变量的情况下重新初始化一个数组。
smallPrimes = new int[]{17,19,23,29,31,37}
- Java中，允许数组长度为0
- 数组拷贝
int[] a = {1,2,3,4,5};
int[] b = a; //两个引用指向堆上的相同数组数组对象。
b[2] = 30; //此时a[2]的值也变成了30
2)将一个数组的值拷贝到新的数组中去（开辟新的空间保存，互不影响），则使用Arrays类的copyTo方法：
int[] b= Arrays.copyOf(a,a.length);
//第二个参数是新数组的长度，这个方法通常用来增加数组的大小。
int[] c =Arrays.copyOf(b,b.length*2);
如果数组元素的类型是数值型，那么多余的元素将被赋予0；如果数组元素是布尔型，则将赋值为false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
- 命令行参数
package corejava;
public class CommandLineArgs {
public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println(args.length);for(String s:args){System.out.println(s);}
}}
java CommandLineArgs -jrr tmac -lbj
- 数组排序
import java.util.Arrays;public class SortTest {
public static void main(String[] args) {// TODO Auto-generated method stubint[] a = {1,3,2,5,9,7};System.out.println(Arrays.toString(a));Arrays.sort(a); //采用优化的快速排序法，对数组进行排序System.out.println(Arrays.toString(a));}
}
- 数组搜索
Arrays.binarySearch
- Arrays.equals(type[] a,type[] b)
- 多维数组
balance = new double[2][3]; //初始化数组
//另一种初始化方式
int[][] magicSquare ={
{16,3,2,13},
{5,10,11,8},
{9,6,7,12},
{4,15,14,1}
}
一旦数组被初始化，就可以利用两个方括号访问每个元素，balances[i][j]
for each循环处理二维数组时，必须使用两个for each循环进行嵌套遍历
for(double[] row:a)
for(double value:row)
do something with value;
快速打印一个二维数组元素的列表
System.out.println(Arrays.deepToString(a));
- 不规则数组
2)不规则数组：即数组的每一行有不同的长度
//首先需要分配一个具有所含行数的数组
int[][] odds = new int[NMAX + 1][];
for(int n=0; n < NMAX; n++)
odds[n] = new int[n+1];