千里之行,始于足下。作为我java SE学习日记的第一句,这八个字笔者会谨记。
学习一门程序语言,就如同熟悉一套积木。只有先熟悉了积木的种类,形状,拼接规则,才能在日后游刃有余的用这套积木搭建出雄伟的城堡。
今天的java编程基础,就是为了熟悉java SE这套积木的基本配置,为日后的工作打下坚实的基础。
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello World^_^");
}
}
名称 | 二进制位数 | 包装类 | 最小值 | 最大值 |
---|---|---|---|---|
byte | 8 | java.lang.Byte | -128 | 127 |
short | 16 | java.lang.Short | -32768 | 32767 |
int | 32 | java.lang.Integer | -2147483648 | 2147483647 |
long | 64 | java.lang.Long | -9223372036854775808 | 9223372036854775807 |
float | 32 | java.lang.Float | 1.4E-45 | 3.4028235E38 |
double | 64 | java.lang.Double | 4.9E-324 | 1.7976931348623157E308 |
char | 16 | java.lang.Character | 0 | 65535 |
byte b;
int i = b;
long l = b;
float f = b;
double d = b;
这样的转换会自动进行。
char c = 'c';
int i = c;
System.out.println("output:"+i);
//输出:output:99;
对于byte,short,char三种类型而言,他们是平级的,因此不能相互自动转换,可以使用下述的强制类型转换:
short i = 99;
char c = (char) i;
System.out.println("output:"+c);
//输出:output: c;
但根据笔者的经验,byte,short,int三种类型都是整型,因此如果操作整型数据时,最好统一使用int型。
int i = 99;
byte b = (byte) i;
char c = (char) i;
float f = (float) i;
这种转换可能会导致溢出或精度下降,因此笔者并不推荐这种转换。
byte b = 169;
Byte bo = new Byte(b);
b = bo.byteValue();
short t = 169;
Short to = newShort(t);
t = to.shortValue();
int i = 169;
Integer io = newInteger(i);
i = io.intValue();
long l = 169;
Long lo = new Long(l);
l = lo.longValue();
float f = 169f;
Float fo = new Float(f);
f = fo.floatValue();
double d = 169f;
Double dO = new Double(d);
d = dO.doubleValue();
float f1 = 100.00f;
Float F1 = new float(f1);
Doubled1 = F1.doubleValue();
double d1 = 100.00;
Double D1 = new Double(d1);
int i1 = D1.intValue();
int i1 = 10;
float f1=3.14f;
double d1 = 3.1415926;
Integer I1 = new Integer(i1);
Float F1 = new Float(f1);
Double D1 = new Double(d1);
String si1= I1.toString();
String sf1= F1.toString();
String sd1= D1.toString();
将String类型转换为基本类型,需要
Byte, Short, Integer, Float, Double, Long这些包装类的parse.....类方法,例如:
byte toByte = Integer.parseByte("1");
short toShort = Integer.parseShort("22");
int toInt = Integer.parseInt("1234");
long toLong = Integer.parseLong("123l");
float toFloat = Integer.parseFloat("12.34f");
double toDouble = Integer.parseDouble("12.34");
int i = 2;
String str = Integer.toBinaryString(i);
//输出字符串"10"
int i = 0;
int j = 0;
int a = i++; //a=0, i=1
int b = ++j; //b=1, j=1
算术表达式中,Java将按运算符两边的操作元的最高精度保留结果的精度,特别要注意除法结果的类型,例如:
System.println(5/2); //输出2
System.println(5.0f/2); //输出2.5
byte x=7;
char ch=’B’+x; //不正确
char ch=(char)(’B’+x); //正确
int i = 0;
int j = 0;
// == 运算符陷阱
Integer I = new Integer(i);
Integer J = new Integer(j);
System.out.println(i == j); //true
System.out.println(I == j); //true
System.out.println(I == J); //false
//不等运算符陷阱
System.out.println(i != j); //false
System.out.println(i != J); //false
System.out.println(I != J); //true
System.out.println(i >= j); //true
System.out.println(i >= J); //true
System.out.println(I >= J); //true
对于==运算符,两边至少有一边是基本类型变量时,则包装类会自动拆包,比较基本类型变量的值。而如果两边都是包装类对象时,则不会自动拆包,==比较的是两个包装类对象的引用的值。这两个包装类对象占据内存不同位置,所以比较结果是false,不相等。若想比较它们包装的基本类型变量的值,需要手动拆包后再比较。
综合运算符 | 完整表达式 | 等价综合运算符表达式 |
---|---|---|
+= | a = a + b | a += b |
-= | a = a - b | a -= b |
*= | a = a * b | a *=b |
/= | a=a / b | a /= b |
%= | a = a % b | a %= b |
>>= | a = a >> b | a >>= b |
>>>= | a = a >>> b | a >>>= b |
int i = 0;
System.out.println(false ? i : 'c'); //返回99
System.out.println(false ? 100 : 'c'); //返回c
System.out.println(true ? 100 : 'c'); //返回d
三目表达式在计算时会将较低精度的操作数转换成较高精度的操作数的类型。按照之前基本类型一章中提过的精度顺序,char类型字符’c‘与int类型整数i在一起时被转换成int类型,返回字符’c‘的ASCII码值99。而第二个例子中左边的100被看做char类型字符的ASCII码,该表达式按照char类型返回字符’c‘。如果第二个例子中的false换成true,则返回ASCII码为100的字符d。
优先级 | 运算符 | 结合性 |
---|---|---|
1 | () [] | 从左到右 |
2 | ! +(正) -(负) ~ ++ -- | 从右向左 |
3 | * / % | 从左向右 |
4 | +(加) -(减) | 从左向右 |
5 | << >> >>> | 从左向右 |
6 | < <= > >= instanceof | 从左向右 |
7 | == != | 从左向右 |
8 | &(按位与) | 从左向右 |
9 | ^ | 从左向右 |
10 | | | 从左向右 |
11 | && | 从左向右 |
12 | || | 从左向右 |
13 | ?: | 从右向左 |
14 | = += -= *= /= %= &= |= ^= ~= <<= >>=>>>= | 从右向左 |
int a[];
a = new int[3];
a[0] = 0;
a[1] = 1;
a[2] = 2;
Date days[];
days = new Date[3];
days[0] = new Date(2008,4,5);
days[1] = new Date(2008,2,31);
days[2] = new Date(2008,4,4);
静态初始化:在定义数组的同时就为数组元素分配空间并赋值,例如:
int a[] = {0,1,2};
Date days[] = {new Date(19,42,42),new Date(1,23,54),new Date(5,3,2)};
默认初始化:数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初始化:
int a [] = new int [5] ; //int数组的元素会被隐式地赋初值为0
//public static void System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
//src是源数组,srcPos是源数组开始复制的元素的索引,dest是目标数组,destPos是目标数组开始接收复制元素的位置的索引,length为要复制的元素个数
String[] A = {"H","e","l","l","o"};
String[] B = new String[3];
System.arraycopy(A, 0, B, 1, B.length - 1);
//B的元素为null,"H","e"
数组的填充:
//public static void fill(Object[] a, int fromIndex, int toIndex,Object val)
//向对象数组a从fromIndex到toIndex范围内的元素填充对象val
String[] A = new String[5];
Arrays.fill(A, "Hello");
for(int i = 0; i < A.length; i ++)
System.out.print(A[i] + " ");
//运行结果Hello,Hello,Hello,Hello,Hello
判断数组内容相等:
String[] A = {"1","2","3"};
String[] B = {"一","二","三"};
String[] C = {"1","2","3"};
System.out.println(Arrays.equals(A, B));
System.out.println(Arrays.equals(A, C));
//输出false,true
将数组转换成列表:
public static List asList(T... a)
//返回列表
String[] A = {"H","e","l","l","o"};
System.out.println(Arrays.asList(A));
//输出[H,e,l,l,o]
数组排序:
//按照String类的compareTo()方法排序
String[] A = {"A","B","c","D","e","f","G","H"};
Arrays.sort(A);
System.out.println(Arrays.asList(A));
//运行结果为:[A, B, D, G, H, c, e, f]
数组元素的二分查找:
//必须在排完序的数组上使用
//public static int binarySearch([] a, key)
String[] a = {"a","d","e","w","f"};
Arrays.sort(a);
System.out.println(Arrays.asList(a));
int index1 = Arrays.binarySearch(a, "f");
System.out.println("要查找的值存在的时候:" + index1);
int index2 = Arrays.binarySearch(a, "n");
index2 = index2 - 1;
System.out.print("当不存在的时候输出该值最可能存在的位置:" + index2);
逆向输出数组(用到Collections类的排序接口)
String[] a = {"a","b","c"};
Arrays.sort(a,Collections.reverseOrder());
System.out.println(Arrays.asList(a));
//输出:[c,b,a]
数组的长度:
String[] a = {"a","b"};
System.out.println(a.length);
//输出2
int k, i=3, j=4;
k=i+j; //k=7
System.out.println(″k=″+k); //输出k=7
if (条件表达式)
s1语句;
if...else二分支语句,if语句通常与else语句配套使用,形成二分支结构。当条件表达式的值为true,就执行s1语句,忽略else和s2语句;条件表达式的值为false,程序忽略s1语句,执行else后面的s2语句。s1和s2都可以是复合语句:
if (条件表达式)
s1语句;
else
s2语句;
if....else多分支语句,是if与else关键字嵌套生成的语句,用于复杂的情况。在这里依次计算条件表达式,如果某个条件表达式的值为true,就执行它后面的语句,其余部分被忽略;所有表达式的值都为false,就执行最后一个else后的s3语句。s1、s2和s3都可以是复合语句。
if (条件表达式1)
s1语句;
else if (条件表达式2)
s2语句;
else
s3语句;
switch语句:虽然嵌套的条件语句可实现多个分支处理,但嵌套太多时容易出错和混乱,这时可以使用开关语句switch处理。实际上开关语句switch也是一种if…else结构,不过它使你在编程时很容易写出判断条件,特别是有很多条件选项的时候:
switch (表达式) {
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
case.........
default:
语句n;
}
其中switch、case、default是关键字,default子句可以省略。开关语句先计算表达式,然后将表达式值与各个常量比较,如果表达式值与某个常量相等,就执行该常量后面的语句;如果都不相等,就执行default下面的语句。如果无default子句,就什么都不执行,直接跳出开关语句。
for (表达式1; 表达式2; 表达式3)
循环体
其中表达式1可以给出计数器的初值,是一个赋值语句;表达式2指出循环结束条件,是一个逻辑表达式;表达式3指出计数器每次的增量,是一个赋值语句。
while (条件表达式)
循环体
其中while是关键字。每次循环之前都要计算条件表达式,其值为true时,就执行一次循环体中的语句,然后再计算条件表达式,决定是否再次执行循环体中的语句;如果条件表达式的值为false时,就跳出循环体,执行循环体下面的语句。必须警惕的是while循环中的条件表达式是逻辑表达式,所以循环体中一定要有改变条件表达式值的语句,使条件表达式的值有机会变为false,否则会陷入死循环。
do {
循环体
} while (条件表达式);
其中do、while是关键字。程序首先执行do下面的循环体,然后计算while后面条件表达式的值,如果其值为true,则重复执行循环体;否则,就结束循环。与while循环相同,do循环在循环体中也一定要有改变条件表达式值为false的语句,否则会陷入死循环。do…while循环控制并不是很常用,但有时却非常重要,使用时特别注意不要忘记了while语句结尾处的分号“;”。
while(表达式1)
{
表达式2;
if(表达式3)
break;
}
如果表达式3成立,break语句会立刻让程序跳出while循环。
loop:
while(表达式1)
{
while(表达式2)
{
if(表达式3)
break loop;
}
}
表达式3成立时,循环会直接跳到loop标识符处,相当于直接跳出了两层循环。
while(表达式1)
{
表达式2;
if(表达式3)
continue;
表达式4;
}
执行到if语句时,如果表达式3为真,则continue语句会将程序直接跳回到表达式1处开始下一次循环,从而忽略了表达式4。带标号的continue语句与带标号的break语句相似。
return 表达式;
当程序执行到这个语句时,首先计算“表达式”的值,然后将表达式的值返回到调用该方法的语句。返回值的数据类型必须与方法声明中的返回值类型一致,可以使用强制类型转换来使类型一致。