java-2-运算符-流程控制-数组

[TOC]

运算符

算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模(取余)	7%5	2
++ ++	自增（前）：先运算后取值；自增（后）：先取值后运算	a=2;b=++a; a=2;b=a++;	a=3;b=3 a=3;b=2
- -	自减（前）：先运算后取值自减（后）：先取值后运算	a=2;b=- -a a=2;b=a- -	a=1;b=1 a=1;b=2
+	字符串连接	“He”+”llo”	“Hello”

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如： 5%-2=1。但被模数是负数则不可忽略。此外，取模运算的结果==不一定总是整数==。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x=3510;x=x/1000*1000; x的结果是？ 3000
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如：
System.out.println(“5+5=”+5+5); //打印结果是： 5+5=55
符号： =
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
扩展赋值运算符：+=, -=, *=, /=, %=

short s = 3;
s = s+2; 
s += 2; 
//原因是数字2是int型的常量,s+2会自动转换成int型，将一个int型赋给一个short型的s，自然编译会出错。
//如果一定要使用s+2的话,可以将s+2改为(short)(s+2),这时(short)将(s+2)的值强转为short型,这时便可以/将(s+2)的值赋给s.
//为什么s+=2不会报错呢?
//因为编译器自动将+=运算符后面的操作数强制转换为前面变量的类型,所以s+=2不会报错.
//同时类似的还有: -=  *=  /=  %=
  
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1

int m = 2;
int n = 3;
n *= m++;
System.out.println("m=" + m);
System.out.println("n=" + n);
//m=3
//n=6

比较运算符

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true
instanceof	检查是否是类的对象	“Hello” instanceof String	true

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==”不能误写成“=” 。

逻辑运算符

&—逻辑与 | —逻辑或 ！ —逻辑非

&& —短路与|| —短路或^ —逻辑异或

a	b	a&b	a&&b	a\	b	a\	\
true	true	true	true	true	true	false	false
true	false	false	false	true	true	false	true
false	true	false	false	true	true	true	true
false	false	false	false	false	false	true	false

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6。

“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理， ||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。理解：==异或，追求的是“异==” !

class Test {
	public static void main (String [] args) {
		boolean x=true;
		boolean y=false;
		short z=42;
		//if(y == true)
		if((z++==42)&&(y=true))z++;
		if((x=false) || (++z==45)) z++;

		System. out.println(“z=”+z);
 	}
}
//结果为：
//z= 46

位运算符

运算符	运算	范例
<<	左移	3 << 2 = 12 —> 322=12
>>	右移	3 >> 1 = 1 —> 3/2=1
>>>	无符号右移	3 >>> 1 = 1 —> 3/2=1
&	与运算	6 & 3 = 2
\		或运算	6 \	3 = 7
^	异或运算	6 ^ 3 = 5
~	取反运算	~6 = -7

位运算是直接对整数的二进制进行的运算

==注意：无<<<==

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

左移：

三元运算符

格式:

(条件表达式) ?表达式1：表达式2；
- 条件表达式为true，运算后的结果是表达式1；
- 条件表达式为false，运算后的结果是表达式2；
表达式1和表达式2为同种类型
三元运算符与if-else的联系与区别：
- 三元运算符可简化if-else语句
- 三元运算符要求必须返回一个结果。
- if后的代码块可有多个语句

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如表，上一行运算符总优先于下一行。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

	. () {} ; ,
R—>L	++ — ~ !(data type)
L—>R	* / %
L—>R	+ -
L—>R	<< >> >>>
L—>R	< > <= >= instanceof
L—>R	== !=
L—>R	&
L—>R	^
L—>R	\
L—>R	&&
L—>R	\	\
R—>L	? :
R—>L	= *= /= %= += -= <<= >>= >>>= &= ^=

程序流程控制

程序流程控制 - 顺序结构

Java中定义成员变量时采用合法的前向引用。如：

public class Test{
int num1 = 12;
int num2 = num1 + 2;
}

错误形式：

public class Test{
int num2 = num1 + 2；
int num1 = 12;
}

分支语句1：if-else结构

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

分支结构： if-else使用说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
语句块只有一条执行语句时，一对{}可以省略，但建议保留
if-else语句结构，根据需要可以嵌套使用
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
当多个条件是“包含”关系时，“小上大下 / 子上父下”

分支语句2：switch-case结构

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

实例

String season = "summer";
switch (season) {
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误");
break;
}

switch语句有关规则

switch(表达式)中表达式的值必须是下述几种类型之一： byte， short，char， int，枚举 (jdk 5.0)， String (jdk 7.0)；
case子句中的值必须是常量，不能是变量名或不确定的表达式值；
同一个switch语句，所有case子句中的常量值互不相同；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default

循环结构

循环语句的四个组成部分

初始化部分(init_statement)
循环条件部分(test_exp)
循环体部分(body_statement)
迭代部分(alter_statement)

循环结构1：for循环

语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分)｛
③循环体部分;
｝
执行过程：
①-②-③-④-②-③-④-②-③-④-…..-②
说明：

②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔

public class ForLoop {
public static void main(String args[]) {
int result = 0;
for (int i = 1; i <= 100; i++) {
result += i;
}
System.out.println("result=" + result);
}
}

循环结构2：while循环

语法格式

 ①初始化部分
while(②循环条件部分)｛
         ③循环体部分
         ④迭代部分;
}

执行过程：
①-②-③-④-②-③-④-②-③-④-…-②
说明：

注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
for循环和while循环可以相互转换

public class WhileLoop {
public static void main(String args[]) {
int result = 0;
int i = 1;
while (i <= 100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
}

循环结构3: do-while循环

语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
执行过程：

①-③-④-②-③-④-②-③-④-…②

说明：

do-while循环至少执行一次循环体。

public class DoWhileLoop {
public static void main(String args[]) {
int result = 0, i = 1;
do {
result += i;
i++;
} while (i <= 100);
System.out.println("result=" + result);
}
}

关键字的使用：break、 continue

break 语句

break语句用于终止某个语句块的执行
{ ……
break;
……}

continue 语句

continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

特殊流程控制语句说明

return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是， return直接结束整个方法，不管这个return处于多少层循环之内
break只能用于switch语句和循环语句中。
continue 只能用于循环语句中。
二者功能类似，但continue是终止本次循环， break是终止本层循环。
break、 continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
很多语言都有goto语句， goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。 Java中的break和continue是不同于goto的。

数组

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

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组的分类：
- 按照维度：一维数组、二维数组、三维数组、 …
- 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对
  象数组)

一维数组的声明方式：

==type var[] 或 type[] var；==
例如：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组
Java语言中声明数组时不能指定其长度(数组中元素的数)，例如： int a[5]; //非法

一维数组的使用：初始化

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

//1
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;
// 2
String names[];
names = new String[3];
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”;

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int arr[] = new int[]{ 3, 9, 8};
// 或
int[] arr = {3,9,8}

//2 

String names[] = {
“李四光”,“茅以升” ,“华罗庚”
}

一维数组的使用：数组元素的引用

定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

数组元素的引用方式：数组名[数组元素下标]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、 a[1]、 a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
- 数组一旦初始化，其长度是不可变的

一维数组的使用：数组元素的默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：

public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}

对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null(注意与0不同！

数组元素类型	元素默认初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:’\u0000’(表现为空)
boolean	false
引用类型	null

public class Test{
public static void main(String args[]){
int[] s;
s = new int[10]; //下图左
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1; // 下图右
System.out.println(s[i]);
		}
	}
}

多维数组的使用

二维数组[][]：数组中的数组

格式1（动态初始化）： int[][] arr = new int[3] [2];

定义了名称为arr的二维数组，二维数组中有3个一维数组，每一个一维数组中有2个元素，一维数组的名称分别为arr[0], arr[1], arr[2]。给第一个一维数组1脚标位赋值为78写法是： arr[0] [1] = 78;

格式2（动态初始化）：int[][] arr = new int[3] []

二维数组中有3个一维数组。

每个一维数组都是默认初始化值null (注意：区别于格式1），

可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

注： int [] []arr = new int[][3]; //非法

格式3（静态初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组，二维数组中有三个一维数组每一个一维数组中具体元素也都已初始化第一个一维数组 arr[0] = {3,8,2}; 第二个一维数组 arr[1] = {2,7}; 第三个一维数组 arr[2] = {9,0,1,6}; 第三个一维数组的长度表示方式： arr[2].length;

注意特殊写法情况： int[] x,y[]; x是一维数组， y是二维数组。 Java中多维数组不必都是规则矩阵形式

数组使用中的常见异常

数组脚标越界异常(ArrayIndexOutOfBoundsException)

1
2
3

int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);

访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)

1 2	int[] arr = null; System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时。

Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

1	boolean equals(int[] a,int[] b)	判断两个数组是否相等。
2	String toString(int[] a)	输出数组信息。
3	void fill(int[] a,int val)	将指定值填充到数组之中。
4	void sort(int[] a)	对数组进行排序。
5	int binarySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值。