[java学习笔记]java语言基础概述之运算符&程序流程控制&for循环嵌套

一.运算符

• 算数运算符

+，-，*，/，%，++，--

1.+，-，*，/

整数除以整数的结果为舍弃了小数部分的整数。

2.%：取余

1. %左右都为正数，左边小于右边结果为左边值，如，4%5=4
2. %左边大于或等于右边结果为左边除以右边的余数，如，5%5=0，7%2=1
3. 面试题：100%3.0的结果为1.0

应该注意的是：当运算负数的取余运算时，结果的符号和被取余数一致。

如：

System.out.println(-5%2);
System.out.println(-5%-2);
System.out.println(5%-2);

结果为：-1，-1，1

+还可以作为连接符，用于把一个字符串类型值和一个其他基本数据类型连接，结果为字符串数据。

如，2+”3”，结果为”23“的字符串；”5+5=“+5+5，结果为 ”5+5=55“。

3.++自增

在原有数据基础上加1，在赋值给原有数据。

看下面几个程序：

1.

int a = 3;
a++;
System.out.println("a="+a);

2.

int a = 3;
++a;
System.out.println("a="+a);

3.

int a = 3 , b;
b = a++;
System.out.println("a="+a+",b="+b);

4.

int a = 3 , b;
b = ++a;
System.out.println("a="+a+",b="+b);

结果:1，2运行结果相同。都是，a=4

3的结果为a=4,b=3，4的结果为a=4,b=4

分析：1,2是a的独立运算，先增后增结果都一样。3是a和b的运算，先把a的原值赋给b后，a自增。4也是a和b的运算，a自增后，再把a的值（自增后的值）赋给b。

但是在内存中，都是先运算完右边，再赋值给左边的变量。

b = a++；：先把a的原值取出来存在一块临时空间里，在运算a++即a=a+1，运算完成后，把临时空间里的值赋给b；

b = ++a；：先运算右边，把结果赋值给b。

测试：考虑如下代码的运行结果。

int i = 3;
i = i++;

System.out.println("i="+i);

结果：i=3

原因分析：在内存中，先把i的原值取出来放在一个temp临时变量里面，再把i的原值拿到运算区进行运算（i++），把结果（4）赋值给右边的i，最后把临时变量temp里的3再赋值给左边的i。

用代码表示：

int temp = i;
i = i + 1;
i = temp;

• 赋值运算符

赋值运算符：=，+=，-=，*=，/=，%=等

面试题：以下程序的区别

1.

short s = 3;
s+=4;

Sytem.out.println("s="+s);

2.

short s = 3;
s = s + 4;

Sytem.out.println("s="+s);

答案：第一个编译运行正确，第二个报错。

原因：java在编译 short s = 3；时，由于3是int型数据，不能直接赋值给short型数据，可能会丢失精度。java底层会自动判断3在short型数据所表示的范围内，如果在，就强制类型转换，不在则报错（可能丢失精度）。

在编译 s = s+4 时，由于右边s的值不确定，给它加上4可能会丢失精度。所以第二个程序会报可能丢失精度的错误。

在编译 s+=4 时，同  short s = 3；都为赋值运算。

• 比较运算符&逻辑运算符

比较运算符：>,<,>=,<=,==,!=,instanceof

比较运算后的结果：true或false。

逻辑运算符：！，&，&&（短路与），|，||（短路或），^（异或）

逻辑运算符作用：连接两个布尔类型的表达式

• 位运算符

位运算符是直接对二进制进行运算。

位运算能提高效率：

练习：

1.计算2*8

直接使用2*8计算的话，内存中要进行多次的乘法或加法，而使用2<<3，只需要移位即可。

2.互换两个整数的值

int a = 3 , b = 5;
//使用第三方变量
int temp;

temp = a;
a = b;
b = temp;

system.out.println("a="+a+",b="+b);

int a = 3 , b = 5;
//不用第三方变量
a = a + b; //a = 3+5=8
b = a - b; //b = 8-5=3
a = a - b; //a = 8-3 = 5

system.out.println("a="+a+",b="+b);

int a = 3 , b = 5;

//使用移位运算，提高效率
//利用异或的性质：一个数异或两次同一个数，结果还为这个数
a = a^b; //a = 3^5 
b = a^b; //b = (3^5)^5 = 3
a = a^b; //a = (3^5)^3 = 5

system.out.println("a="+a+",b="+b);

• 三元运算符

格式：（条件表达式）？表达式1：表达式2；

如果条件表达式的结果为true，运算后的结果为表达式1，否则为表达式2。

举例：获取两个数中的较大值。

z = (x>y)?x:y;  /运算后z的值就是x，y中较大的一个。

二.程序流程控制

• 顺序结构

从上到下依次运行。

• 判断结构

if语句：

1. 格式1：

   if(条件表达式){

          执行语句;

   }

2. 格式2

   if(条件表达式){

         执行语句;

   }else{

         执行语句;

   }

3. 格式3

   if(条件表达式1){

         执行语句;

   }else if(条件表达式2){

         执行语句;

   }

   …

   else{

         执行语句;

   }

• 选择结构

switch语句：

格式：

switch(表达式){

      case 取值1:

      执行语句;

      break;

     case 取值2:

     执行语句;

    break;

     …

     default:

     break;

}

注意：1.default可以写在第一个判断，但是程序会从第一个case开始执行，判断完所有case，才执行default。

2.右花括号前面的一个“break”可以省略。

3.多个case下的执行语句一致，应该这样：

case 1:
case 2:
...
    //执行语句
    break;

switch中的表达式只能为byte，short，int，char。

java1.5加入了枚举

java7加入了字符串

if和switch的区别：

if：

1. 对具体的值进行判断
2. 对区间判断
3. 对运算结果是boolean的表达式进行判断

switch：

1. 对具体的值进行判断
2. 值得个数通常是固定的

对于几个固定值得判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率较高。

常用的还是if语句，相比switch书写简单，功能较强。

• 循环结构

循环的使用场景：

1. 当对某些代码执行很多次时，使用循环结构完成。
2. 当对一个条件进行一次判断时，可以使用if语句，当对一个条件进行多次判断时，可以使用while语句。

注意：

1. 在使用循环时，一定要明确，哪些语句需要参与循环，哪些不需要。
2. 通常情况下，需要定义条件，需要控制次数。

循环结构由三种方式：

1.while

格式：

while(条件表达式){

       执行的循环语句;

}

2. do while

do{

        执行的循环语句;

}

while(条件表达式) ;

注意：while后有分号

do while无论条件是否满足，要执行的循环语句都会执行一遍。

3. for循环

for(初始化表达式;循环条件表达式;循环后的操作表达式){

        执行的循环语句（循环体）;

}

先执行初始化表达式，并且知道循环结束，只读一次，然后判断循环条件，为真就执行一次循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复整个过程，直到条件不满足为止。

• for和while的特点：

1. for和while可以互换
2. 格式上的不同，在使用上有些区别：

                    如果需要通过变量来对循环进行控制，该变量只作为循环增量存在时，区别就体现出来了。

                    这个变量的作用域不同，一般while循环的控制变量在while循环外，而for循环一般定义在for循环内，for循环外面访问不了；如果不在循环外使用这个变量使用for循环可以做到优化内存，因为for循环完后，这个控制变量就被销毁。

面试题：求下面程序的执行结果.

int x = 1;
for(System.out.println("a"); x<3; System.out.println("b")){

    System.out.println("c");
    x++;
}

答案:：a c b c b

while练习：

累加器思想：

//计算1~10的和
int x = 1;
int sum = 0;

while(x<11){
    sum += x;
    x++;    
}

计数器思想：

//求1~100中能被6整数的数的个数
int x = 1;
int k = 0;

while(x<101){
    if(x%6==0){
        k++;
    }
    x++;    
}
System.out.println(k);

无限循环最简单的形式：

while(true){}

for(; ; ){}

for循环的嵌套：

一种重复情况下的每一次重复都对应另外一种情况的重复，就使用for循环的嵌套。

范例：

/*
*****
****
***
**
*
*/
for (int i = 0; i<5; i++) {
    for (int y = 0; y<5-i; y++) {
        System.out.print("*");
    }
    System.out.println();
}

/*
54321
4321
321
21
1
*/
for (int i = 0; i<5; i++) {
    for (int j = 5-i; j>0; j--) {
        System.out.print(j);
    }
    System.out.println();
}

//九九乘法表
for (int i = 1; i<10; i++) {
    for (int j=1 ; j<=i; j++) {
        System.out.print(j+"*"+i+"="+j*i+"	");
    }
    System.out.println();
}

/*
* * * * *
 * * * *
  * * *
   * *
    *
*/
for (int i = 0; i<5; i++) {
    for (int j = 0; j<i; j++) {
        System.out.print(" ");
    }
    for (int j = 0; j<5-i;j++ ) {
        System.out.print("* ");
    }
    System.out.println();
}