3.1 简单Java程序
public class FirstSample {
public static void main(String[] args) {
System.out.println("We will not use Hello,World!");
}
}
类名命名规则:
1.大小写敏感
2.以大写字母开头,后面跟数字和字母任意组合,无长度限制,保留关键字
3.驼峰命名法
4.源文件名与公共类库名必须相同
每个java程序必须有一个main方法,退出返回0,其它返回值用’System.exit()`方法
3.2 注释
注释3种:
1.//
2./* */ 不能嵌套
3. /**
*/ 能够生成文档
3.3 基本数值类型
Java基本数据类型8种:整型 4 种、浮点型 2 种、1种 Unicode char 、另一种 boolean
3.3.1 整型
都是有符号数,没有无符号数
类型 | 存储字节 | 范围 |
---|---|---|
int | 4 | |
short | 2 | |
long | 8 | |
byte | 1 | -128~127 |
1. 长整形 20000L
2. 16 进制 前缀 0x ,8 进制前缀 0 ,2进制 java7 可以加 前缀0b,数字之间可以加_分隔,编译时去掉
3. Java整形与目标平台无关
3.3.2 浮点型
类型 | 存储字节 | 范围 |
---|---|---|
float | 4 | |
double | 8 |
1. float 类型加后缀 L;
浮点值遵循IEEE754 规范。
3类特殊浮点值:
1)正无穷(Double.POSITIVE_INFINITY) 2)负无穷(Double.NEGATIVE_INFINITY)
3) NaN(非数字,如负数平方根 Double.NaN)
if(x==Double.NaN)//never true 不能这样判断
Double.isNaN(x)//正确判断
4.浮点数不能用于四舍五入,使用BigDecimal类
2.0-1.1=0.8999999999999999
3.3.3 char类型
char 用来表示单个字符,16位的Unicode码表示\u0052
3.3.4 boolean类型
boolean类型值有两个 true 和false,Java中boolean和整形两者之间不能相互转换
3.4 变量
变量命名规则:
1.大小写敏感
2.以大写字母开头,后面跟数字和字母任意组合,无长度限制,保留关键字。字母可以包括“_”等Unicode字符
3.驼峰命名法
4.不能使用保留关键字
3.4.1初始化
1.声明变量后,使用前必须进行初始化。
2.变量声明尽可能放在第一次使用的地方
3.5 常量
Java中用final
关键字声明常量。常量名通常大写。常量只能被赋值一次。
final double CM_PRE_INCH = 2.54
如果常量能够在多个地方使用,用static final 声明类常量
3.5 运算符
3.5.1 自增、自减
++i,i++
3.5.2 关系运算符与布尔运算符
1.> < == >= <= !=
2.&& 、||短路运算符
3. condition? a:nb 三目运算符
3.5.3 位运算符
&(与)、|(或)、^(异或)、~ (非)
int forthBitFromRight =(n&0b1000)/0b1000;
int forthBitFormRight =(n&(1<<3))>>3;
>>>
运算符将用0填充高位,>>
运算符用符号位填充高位,没有<<<
运算符移位运算符右侧操作数应当取模32。
3.5.6 数学函数与常量
Math.sqrt(a); //a的开方
Math.pow(x, a);// x的a次幂
Math.log(a);
Math.log10(a);
Math.PI;
3.5.7 数值类型转换
graph TD
A[byte]-->B[short]
B[short]-->C[int]
D[char]-->C[int]
C[int]-->E[long]
C[int]-->F[float]
C[int]-->G[doule]
E[long]-->F[float]
E[long]-->G[doule]
整形转浮点型会发生数据丢失
int n =123456789
float f =n ;// f is 1.23456792e8
3.5.8 强制类型转换
String类是常量,是不以被改变的。
double x = 9.97;
int nx =(int)x; //高精度向低精度需要强制类型转换
double x = 9.97f;
int nx =(int)Math.round(x);
3.6 子符串
3.6.1 子串
String greeting ="Hello";
String s = greeting.substring(0, 3);
//输出 Hel
容易计算长度 length= 3 - 0;
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
3.6.2 拼接
String expletive ="Expletive";
String PG13 = "delete";
String message = expletive + PG13;
非字符串与字符串拼接时,会被转成字符串
int age = 13;
String rating ="PC"+age;
3.6.3 不可变字符串
String类是常量,是不以被改变的。每次字符串操作都是返回的一个新的String对象。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[]; //final 声明
.....
}
不可变字符串优点:编译器可以让不可变字符串共享
3.6.4 检测字符串是否相等
String greeting ="Hello";
if(!"hello".equals(greeting)){
System.out.println("true");
}//输出true
if("hello".equalsIgnoreCase(greeting)){
System.out.println("true");
}//输出flase
比较字符串时,使用equals
而不使用==
,
Object.equals
默认比较的是地址,String复写了equals
方法,比较的是字符相等。
String{
...
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
...
}
而==
比较是值或者是地址值是否相等,由于只有字符串常量被虚拟机共享,所以不能用==
比较字符串的相等性。
3.6.5 空串与null
空串”“是长度为0的字符串
if(str.length() == 0)
或者
if(str.equals(""))
空串是一个Java 对象,可以为null:
检查一个字符串既不是null
也不是空串。
if(str !=null && str.length() !=0)
3.6.6 代码点与代码单元
char类型为UTF-16编码表示Unicode代码点的代码单元。
length 表示采用UTF-16编码表示的字符串所需要的代码单元数量。
String greeting ="Hello";
greeting.codePointCount(0, greeting.length())// is 5
3.6.7 字符串 API
3.6.8 阅读联机API文档
3.6.9 构建字符串
拼接字符串时,每次都会创建一个新的String对象。既耗时,又浪费空间。可采用 StringBuilder 类解决,它对字符串进行修改之后,返回的仍是当前对象。
StringBuilder sb = new StringBuilder();//默认容量为16个字符
常用操作
append
insert
delete
indexOf
调用 toString() 方法返回String 类对象
3.7 输入输出
3.7.1 读取输入
package inputtest;
import java.util.Scanner;
public class InputTest {
public static void main(String[] args) {
Scanner in= new Scanner(System.in);
System.out.print("What is 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));
}
}
3.7.2 格式化输出
double x = 10000.0 /3.0;
System.out.println(x);
System.out.printf("%8.2f",x);
System.out.printf("Hello,%s. Next year,you'll be %d","suxiang",13);
String message = String.format("Hello,%s . Next year, you'll be %d ","suxiang",13);
System.out.printf("%tc",new Date());
//格式化参数索引,下标从1开始
System.out.printf("%1$s %2$tB %2$te, %2$tY","Due date:",new Date());
3.7.3 文件输入输出
//格式化参数索引,下标从1开始
System.out.printf("%1$s %2$tB %2$te, %2$tY","Due date:",new Date());
System.out.println(System.getProperty("user.dir")+"\\myfile.txt");
Scanner in = new Scanner(Paths.get(System.getProperty("user.dir")+"//myfile.txt"));
PrintWriter out = new PrintWriter(System.getProperty("user.dir")+"//myfile2.txt");
out.println("hahaha");
out.flush();
3.8 控制流程
3.8.1 块作用域
Java中不能在嵌套的两个块中声明同名的变量。C++ 允许,会进行同名覆盖。
{int n;
{
int k;
int n;
}
} //不允许
3.8.2 条件语句
3.8.3
3.9 大数值
package bigintegertest;
import java.math.BigInteger;
import java.util.Scanner;
public class BigIntegerTest {
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
System.out.print("How many numbers do you need to draw?");
int k = in.nextInt();
System.out.print("What is the highest number you can draw?");
int n = in.nextInt();
BigInteger lotteryOdds = BigInteger.valueOf(1);
for(int i = 1;i<=k;i++)
lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n-i+1)).divide(BigInteger.valueOf(i));
System.out.println("your olds are 1 "+lotteryOdds+".Good luck");
}
}
3.10 数组
一维数组初始化之前不能使用它。
int[] a = new int[100];
3.10.1 for each循环
数组或者是实现了Iterable接口的类对象可以用
for(int element : a)
System.out.println(element);
或者用Arrays.toString(int [])
对象。
3.10.2 数组化及匿名数组
int [] smallPrimes ={2,3,5,7,11,13};//声明并初始化
new int[]{17,19,23,29,31,37};
//初始化匿名数组
smallPrimes = new int[]{17,19,23,29,31,37};
int[] anonymous ={17,19,23,29,31,37};
smallPrimes = anonymous;
3.10.3 数组拷贝
Java中允许将一个数组变量。这时,两个变量将引用同一个数组。
int[] luckyNumbers = smallPrimes;
luckyNumbers[5]=12;//now smallPrimes[5] is also 12
Arrays.copyOf将一个数组的所有值都拷贝到一个新的数组中。第2个参数是数组的长度。
int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length*2);
3.10.4 命令行参数
3.10.5 数组排序
Arrays.sort
返回的仍是原数组
public class LotteryDrawing {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("How many numbers do you need to draw?");
int k = in.nextInt();
System.out.print("What is the highest number you can draw?");
int n = in.nextInt();
int[] numbers = new int[n];
for(int i =0;i<numbers.length;i++)
{
numbers[i]=i+1;
}
int [] result = new int[k];
for(int i=0;i< result.length;i++){
int r =(int)(Math.random()*n);
result[i]= numbers[r];
numbers[r]=numbers[n-1];
n--;
}
Arrays.sort(result);
System.out.println("Bet the following combination.It'll make you rich!");
for(int r:result)
System.out.println(r);
}
}
3.10.6 多维数组
多维数组初始化之前不能使用它
double [][] balances = new double [NYEARS][NRATES];
int [][] magicSquare={{16,2,2,13},{5,10,11,8},{9,6,7,12},{4,15,14,1}};
package CompoundInterest;
public class CompoundInterest {
public static void main(String[] args){
final double STARTRATE = 10;
final int NRATES = 6;
final int NYEARS = 10;
double [] interestRate = new double[NRATES];
for(int j =0;j<interestRate.length;j++){
interestRate[j]=(STARTRATE+j)/100.0;
}
double[][] balances = new double[NYEARS][NRATES];
for(int j = 0;j<balances[0].length;j++)
balances[0][j]=10000;
for(int i =1;i<balances.length;i++)
{
for(int j =0 ;j<balances[i].length;j++)
{
double oldBalance = balances[i-1][j];
double interest = oldBalance * interestRate[j];
balances[i][j]= oldBalance + interest;
}
}
for(int j=0;j<interestRate.length;j++)
System.out.printf("%9.0f%%",100*interestRate[j]);
System.out.println();
for(double[] row:balances){
for(double b : row)
System.out.printf("%10.2f", b);
System.out.println();
}
}
}
3.10.6 不规则数组
Java实际上没有多维数组,只有一维数组
package lotteryarray;
public class LotteryArray {
public static void main(String[] args) {
final int NMAX = 10;
int[][] odds = new int[NMAX+1][];
for(int n =0;n<=NMAX;n++)
odds[n]= new int [n+1];
for(int n =0;n<odds.length;n++){
for(int k = 0;k <odds[n].length;k++){
int lotteryOdds = 1;
for(int i =1;i <=k;i++)
lotteryOdds = lotteryOdds * (n -i+1)/i;
odds[n][k]=lotteryOdds;
}
}
for(int [] row:odds)
{
for(int odd : row)
System.out.printf("%4d",odd);
System.out.println();
}
}
}