首页 > > 程序设计 > Java技术 >

java基础------运算符

2018-08-26 17:19:05来源：博客园阅读 ()

一.运算符

　　　　　　　　1.算术运算符

　　　　　　　　　　　　+（正号、加、连接符）

　　　　　　　　　　　　　　　连接符的作用：让任何数据都可以与字符串连接

　　　　　　　　　　　　　　　连接符要注意的事项：任何类型的数据与字符串使用连接符连接时，结果都是字符串的数据类型

class Demo1{
       public static void main(String[] args){
            byte age=+10;//"+"代表整数的符号，是正数
            System.out.println("age="+age);//输出的结果:age=10

            int a=10;//声明一个int类型的变量，该变量名为a,并把10赋值给变量a
            int b=20;//声明一个int类型的变量，该变量名为b,并把20赋值给变量b
            int c=a+b;//分别取出变量a、b的值，求和，并赋值给变量c
            System.out.println("a+b="+c);//输出的结果:a+b=30

            //任何类型的数据与字符串使用连接符连接时，结果都是字符串的数据类型
            System.out.println("Hello"+a);//输出的结果:Hello10

            //计算机每次运算的时候只能取两个数据运算。
            System.out.println(1+2+3+"Hello"+4+5+6);//输出的结果:6Hello456
        } 
}

View Code

　　　　　　　　　　　　-（负号、减）

　　　　　　　　　　　　*（乘）

　　　　　　　　　　　　/（除）：做除法时求得的结果取整

class Demo2{
        public static void main(String[] args){
             int a=3;
             double b=12.0;
             //前面说过，两个不同数据类型的数据在运算的时候，结果取决于大的数据类型
             System.out.println("b/a="+(b/a));//输出的结果:4.0
         }
}

View Code

　　　　　　　　　　　　%（取余/取模）：所求出的结果取余数

class Demo3{
        public static void main(String[] args){
            //java在做取模运算时，结果的正负号取决于被除数
            System.out.println("结果:"+(10%3)); //输出的结果:1
            System.out.println("结果:"+(10%-3)); //输出的结果:1
            System.out.println("结果:"+(-10%3)); //输出的结果:-1
            System.out.println("结果:"+(-10%-3)); //输出的结果:-1
        }
}

View Code

　　　　　　　　　　　　　　　++（自增）：自增就是操作数加1

　　　　　　　　　　　　　　　前自增：++位于操作数的前面。例如：++i

　　　　　　　　　　　　　　　前自增：先自增，后使用

class Demo4{
        public static void main(String[] args){
            int a=0;
            int sum=++a;//前自增 a=a+1,sum=a
            System.out.println("sum="+sum+"a="+a);//输出的结果:sum=1 a=1
}
}

View Code

　　　　　　　　　　　　　　　后自增：++位于操作数的后面。例如：i++

　　　　　　　　　　　　　　　后自增：先使用，后自增

class Demo5{
        public static void main(String[] args){
            int a=0;
            int sum=a++;//后自增 sum=a,a=a+0
            System.out.println("sum="+sum+" a="+a);//输出的结果:sum=0 a=1
　 
            /*
            i=i++原理：
            1. int temp = i; // 声明了一个临时变量temp用于记录了i没有加1之前的值。i=0,temp=0
            2. 自增。 i = i+1; i = 1;
            3. 把临时变量temp用作了表达式的结果。
            */
　　　　 int i=0;
　　　　 i=i++;
            System.out.println("i="+i);//输出的结果:i=0
        }
}

View Code

　　　　　　　　　　　 --（自减）：自减就是操作数减1

　　　　　　　　　　　　　　　前自减：--位于操作数的前面。例如：--i

　　　　　　　　　　　　　　　前自减：先自减，后使用

class Demo6{
        public static void main(String[] args){
            int a=1;
            int difference=--a;//前自减 a=a-1,difference=a
            System.out.println("difference="+difference+"a="+a);//输出的结果:difference=0 a=0
        }
}

View Code

　　　　　　　　　　　　　　　后自减：--位于操作数的后面。例如：i--

　　　　　　　　　　　　　　　后自减：先使用，后自减

class Demo7{
        public static void main(String[] args){
            int a=1;
            int difference=a--;//后自减 difference=a,a=a-1
            System.out.println("difference="+difference+" a="+a);//输出的结果:difference=1 a=0
        }
}

View Code

　　　　　　　　2.赋值运算符

　　　　　　　　　　　　=（赋值）

　　　　　　　　　　　　+=（加等于）

　　　　　　　　　　　　-+（减等于）

　　　　　　　　　　　　*=（乘等于）

　　　　　　　　　　　　/=（除等于）

　　　　　　　　　　　　%=（模等于）

class Demo8 
{
    public static void main(String[] args) 
    {        
        int i = 10; // 把10赋予给i变量。
        i+=2;  // 相当于i = i+2; 
        System.out.println("i = "+i);//结果是:i=12
    
        byte b1 = 1;
        byte b2 = 2;
        b2+=b1;  //相当于b2 = b2+ b1;b2+=b1在编译的时候，java编译器会进行强制类型转换，不需要我们手动去转换。如果写成b2=b2+b1,则需要我们手动强制类型转换，变成b2=（byte）b2+b1;
        System.out.println("b2="+ b2);//结果是:b2=3
    }
}

View Code

　　　　　　　　3.比较运算符：比较运算符的返回结果都是布尔值

　　　　　　　　　　　　==（等于）

　　　　　　　　　　　　　　==用于比较两个基本数据类型的时候，比较的是两个变量存储的值是否相等

　　　　　　　　　　　　　　==用于比较两个引用数据类型的时候，比较的是两个引用类型变量所记录的内存地址是否相等

class Demo8{
public static void main(String[] args){
                int a=10;
                int b=10;
                System.out.println("a==b?",(a==b));//结果是:a==b?true
    
                String str1="Hello";
                String str2="Hello";
                System.out.println("str1==str2?",(str1==str2));//结果是:str==str2?false
    }
}

View Code

　　　　　　　　　　　！=（不等于）

　　　　　　　　　　　　>（大于）

　　　　　　　　　　　　<（小于）

　　　　　　　　　　　　>=(大于等于）

　　　　　　　　　　　　<=（小于等于）

class Demo9
{
    public static void main(String[] args) 
    {
                int a = 10;
                int b =2;
                System.out.println("a!=b？"+ (a!=b) );//结果是:a!=b？true
                System.out.println("a>b？"+ (a>b) );//结果是:a>b？true
                System.out.println("a<b？"+ (a<b) );//结果是:a<b？false
                System.out.println("a>=b？"+ (a>=b) );//结果是:a>=b？true
                System.out.println("a<=b？"+ (a<=b) );//结果是:a<=b？false

                int b  = 10;
                long l = 30;
                /*两个不同类型的数据是否可以比较呢?
                   可以的，但是两个不同类型的数据必须是兼用的数据;这个比较的过程会先把b转换了long类型的数据，然后再进行比较 */
                System.out.println(l>b);//true
    }
}

View Code

　　　　　　　　4.逻辑运算符：用于连接布尔表达式　

　　　　　　　　　　　　&（与）

　　　　　　　　　　　　&&（短路与）

　　　　　　　　　　　　　　规律：只有两边的布尔表达式同时为true，那么结果才是true；否则为false

　　　　　　　　　　　　　　&&与&的相同点及不同点：

　　　　　　　　　　　　　　　　　　相同点：&&与&的运算结果是一样的

　　　　　　　　　　　　　　　　　　不用点：使用&&的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了效率；使用&的时候，即使左边的布尔表达式为false，还是会运算右边的布尔表达式

　　　　　　　　　　　　|（或）

　　　　　　　　　　　　||（短路或）

　　　　　　　　　　　　　　规律：只要两边的布尔表达式有一边为true，结果就为true；如果两边同时都为false，才为false　　　　　

　　　　　　　　　　　　　　相同点：||与|的运算结果是一样的

　　　　　　　　　　　　　不用点：使用||的时候，如果左边的布尔表达式为true，则不会在运算右边的布尔表达式，从而提高了效率；使用|的时候，即使左边的布尔表达式为true，还是会运算右边的布尔表达式

　　　　　　　　　　　　^（异或）

　　　　　　　　　　　　　　规律：只要两边的布尔表达式不一致，结果就为true；如果两边的布尔表达式一致，则为false

　　　　　　　　　　　　!（非）　　　　

class Demo11 
{
    public static void main(String[] args) 
    {
                //&（与）
        System.out.println(true&true); //结果是:true
        System.out.println(true&false); //结果是: false
        System.out.println(false&true); //结果是:false
        System.out.println(false&false); //结果是:false
        
                //&&（短路与）
                System.out.println(true&&true); //结果是:true
        System.out.println(true&&false); //结果是:false
        System.out.println(false&&true); //结果是: false
        System.out.println(false&&false); //结果是: false

                //|（或）
        System.out.println(true|true);  //结果是: true
        System.out.println(true|false); //结果是:true
        System.out.println(false|true); // 结果是:true
        System.out.println(false|false); //结果是: false

                //||（短路或）
        System.out.println(true||true);  //结果是:true
        System.out.println(true||false); //结果是:true
        System.out.println(false||true); //结果是: true
        System.out.println(false||false); //结果是: false
        
               //^（异或）
        System.out.println(true^true);  //结果是: false
        System.out.println(true^false); //结果是:true
        System.out.println(false^true); //结果是: true
        System.out.println(false^false); //结果是: false
        
                //!（非）
        System.out.println(!true); //结果是: false
        System.out.println(!false); //结果是:true
    }
}

View Code

　　　　　　　　5.位运算符：直接操作二进制位的

　　　　　　　　　　　　&（与）

　　　　　　　　　　　　|（或）

　　　　　　　　　　　　^（异或）　　

　　　　　　　　　　　　　　规律：如果操作数A连续异或同一个操作数两次，那么结果还是操作数A　　　

　　　　　　　　　　　　~（取反）

class Demo12{
    public static void main(String[] args){
        System.out.println(6&3); //结果是:2 
        System.out.println(6|3); //结果是:7
        System.out.println(6^3); //结果是:5
        System.out.println(~7);  // 结果是:-8
    }
}

View Code

　　　　　　　　6.移位运算符

　　　　　　　　　　　　<<（左移）

　　　　　　　　　　　　　　规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数

　　　　　　　　　　　　　　3<<1=3*2^1=6

　　　　　　　　　　　　　　3<<2=3*2^2=12

　　　　　　　　　　　　>>（右移）

　　　　　　　　　　　　　　规律：一个操作数进行右移运算的时候，结果就是等于操作数除以2的n次方，n就是右移的位数

　　　　　　　　　　　　　　3>>1=3/2^1=1

　　　　　　　　　　　　　　3>>2=3/2^2=0

　　　　　　　　　　　　>>>（无符号右移）

　　　　　　　　　　　　　　无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺用0补，如果操作数是一个负数，那么左边的空缺用1补；使用无符号右移的时候，不管操作数是正数还是负数，空缺的位置都用0补

class Demo13{
    public static void main(String[] args){
        //左移：
        System.out.println(3<<1); //结果是:6 
        System.out.println(3<<2); //结果是:12
        System.out.println(3<<3); //结果是:24 

                //右移
                System.out.println(3>>1);结果是:1
                System.out.println(3>>2);//结果是:0

        //无符号右移：
        System.out.println(3>>>1); //结果是:1 
        System.out.println(3>>>2);  //结果是:0 
    }
}

View Code

　　　　　　　　7.三元运算符

　　　　　　　　　　　　格式：布尔表达式?值1:值2；

　　　　　　　　　　　　使用三元运算符要注意的细节：使用三元运算符的时候，一定要使用该表达式返回的结果或者是定义一个变量接收该表达式返回的结果

class Demo14{
    public static void main(String[] args) {
            int age = 26;
            String result = age>=18?"成年人":"未成年人";
            System.out.println(result);//结果是:成年人

                    int a = 1;
            int b = 2;
            int c = 3;
            int result = a*b+c/2+2*(a+b)/c;
            System.out.println("result="+result);//结果是:result=5
    }
}