DevOps开发运维
成长之路

Java运算符







ArithmeticOperator.java

//演示算术运算符的使用
//
public class ArithmeticOperator {

    //编写一个main方法
    public static void main(String[] args){

        //除法使用
        System.out.println(10 / 4);//数学中结果为2.5,java中为2
        System.out.println(10.0 / 4);//java中结果为2.5
        double d = 10 / 4;
        System.out.println(d);// 结果为2.0

        // % 取模,取余
        // 在java中,%的本质是公式 a % b = a - a / b *b
        // -10 % 3 = -10 - (-10) / 3 * 3 = -10 - (-9) = -1
        // 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
        // -10 % -3 = -10 - (-10) / (-3) * (-3) = -10 + 9 = -1
        System.out.println(10 % 3);//1
        System.out.println(-10 % 3);//-1
        System.out.println(10 % -3);//1
        System.out.println(-10 % -3);//-1

        //++的使用
        //做为独立语句使用
        int i = 10;
        i++;//自增 等价于i = i + 1;=>i = 11
        ++i;//自增 等价于i = i + 1;=>i = 12
        System.out.println("i=" + i);//12

        //作为表达式使用
        //前++:++i先自增后赋值
        //后++:i++先赋值后自增
        //
        int j = 8;
        // int k = ++j;//等价于 j=j+1;k=j
        // System.out.println("k=" + k + "\n" + "j=" + j);//k=9 j=9
        int k = j++;//等价于k=j;j=j+1;		
        System.out.println("k=" + k + "\n" + "j=" + j);//k=8 j=9

    }
}

 


ArithmeticOperatorExercise01.java

//联系1
//
public class ArithmeticOperatorExercise01 {

    //编写一个main方法
    public static void main(String[] args){

        // int i = 1;//i ->1
        // i = i++;//规则使用临时变量:(1)temp=i;(2)i=i+1;(3)i=temp;
        // System.out.println(i);//1

        // int j = 1;//j ->1
        // j = ++j;//规则使用临时变量:(1)j=j+1;(2)temp=j;(3)j=temp;
        // System.out.println(j);//2

        //测试输出
        //
        int i1 = 10;
        int i2 =20;
        int i = i1++;
        //print后不加ln表示不换行
        System.out.print("i=" +i);//10
        System.out.println("i2=" +i2);//20
        i = --i2;
        System.out.print("i=" +i);//19
        System.out.println("i2=" +i2);//19

    }
}


ArithmeticOperatorExercise02.java

//课堂练习2
//
public class ArithmeticOperatorExercise02 {

    //编写一个main方法
    public static void main(String[] args){

        //1.需求:
        //假如还有59天放假,问:合xx个星期零xx天
        //2.思路分析
        //(1)使用int变量 days 保存天数,
        //(2)一个星期是7天,星期数weeks就是days / 7,零xx天leftDays就是days % 7
        //3.走代码
        int days = 59;
        int weeks = days / 7;
        int leftDays = days % 7;
        System.out.println("合" + weeks + "个星期零" 
            + leftDays + "天");
                 //合8个星期零3天
        //1.需求:
        //定义一个变量保存华氏温度,华氏温度转换为摄氏温度的公式为:5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
        //
        //2.思路分析
        //(1)先定义一个double huaShi 变量保存 华氏温度
        //(2)根据给出的公式,进行计算即可5/9*(华氏温度-100)
        //考虑数学公式和java语言的特性,此时写代码时5应改为5.0
        //(3)将得到的结果保存到double sheShi
        double huaShi = 234.5;
        double sheShi = 5.0 / 9 * (huaShi - 100);
        System.out.println("华氏温度=" + huaShi + "对应的摄氏温度=" + sheShi);
                //华氏温度=234.5对应的摄氏温度=74.72222222222223
    }
}


RelationalOperator.java

//
public class RelationalOperator {

    //编写一个main方法
    public static void main(String[] args){
        int a = 9;
        int b = 8;
        System.out.println(a > b);//true
        System.out.println(a >= b);//true
        System.out.println(a <= b);//false
        System.out.println(a < b);//false 
        System.out.println(a == b);//false 
        System.out.println(a != b);//true 
        boolean flag = a > b;
        System.out.println("flag = " + flag);//flag = true

    }
}


LogicOperator01.java

//演示逻辑运算符的使用
//
public class LogicOperator01 {

    //编写一个main方法
    public static void main(String[] args){
        
        //&& 短路与和 & 案例演示
        //
        int age  = 50;
        if(age > 20 && age < 90){
            System.out.println("ok100");//结果ok100
        }

        //& 逻辑与的使用
        if(age > 20 & age < 90){
            System.out.println("ok200");//结果ok200
        }		

        //区别
        int a = 4;
        int b =9;
        //对于&&短路与而言,如果第一个条件为false,后面的条件不再判断
        if(a < 1 && ++b < 50){
            System.out.println("ok300");
        }
        System.out.println("a=" + a + "b=" + b);//结果a=4 b=9
        //对于&逻辑与而言,如果第一个条件为false,后面的条件仍然判断		
        if(a < 1 & ++b < 50){
            System.out.println("ok300");
        }
        System.out.println("a=" + a + "b=" + b);//结果a=4 b=10
    }
}


LogicOperator02.java

//演示逻辑运算符 | 和 || 使用
//
public class LogicOperator02 {

    //编写一个main方法
    public static void main(String[] args){
        
        // ||短路或 和 |逻辑或 案例演示
        // 规则都为:两个条件中只要有一个成立,结果为true,否则为fasle
        int age = 50;
        if(age > 20 || age < 30){
            System.out.println("ok100");//结果输出ok100
        }

        //&逻辑与使用
        if(age > 20 | age < 30){
            System.out.println("ok200");//结果输出ok200
        }

        //区别
        //(1)||短路或:如果第一个条件为true,则第二个条件不会判断,最终结果为true,效率高
        //(2)|逻辑或:如果第一个条件为true,则第二个条件都会判断,效率低
        int a = 4;
        int b = 9;
        if(a > 1 || ++b > 4){
            System.out.println("ok300");//输出ok300
        }
        System.out.println("a=" + a + "b=" + b);//a=4 b=9
        if(a > 1 | ++b > 4){
            System.out.println("ok300");//输出ok300
        }
        System.out.println("a=" + a + "b=" + b);//a=4 b=10
    }
}


InverseOperator.java

//! 和 ^ 案例演示
//
public class InverseOperator {

    //编写一个main方法 
    public static void main(String[] args){
        
        //! 操作是取反 true->false,false->true
        System.out.println(60 > 20);//true
        System.out.println(!(60 > 20));//false

        //a^b:叫逻辑异或,当a和b不同时,则结果为true,否则为false
        boolean b = (10 > 1) ^ (3 < 5);//false
        System.out.println("b=" + b);//b=false
        
    }
}





AssignOperator.java

//演示赋值运算符的使用
//
public class AssignOperator {

    //编写一个main方法
    public static void main(String[] args){

        int n1 = 10;
        n1 += 4; //n1 = n1 +4
        System.out.println(n1);//14
        n1 /= 3; //n1 = n1 / 3
        System.out.println(n1);//4

        //复合赋值运算符会进行类型转换
        byte b =3;
        b += 2;//b = byte(b + 2),直接写成b = b + 2是错误的因为b + 2的精度为int
        b++;//b = (byte)(b + 1)
        System.out.println(b);//6
    }
}

 

TernaryOperator.java

//三元运算符使用
public class TernaryOperator {

    //编写一个main方法
    public static void main(String[] args){
        int a = 10;
        int b = 99;
        //解读
        //1.a > b 为false
        //2.返回 b--,先返回 b的值,然后再 b-1
        //3.返回的结果是99
        int result = a > b ? a++ : b--;
        System.out.println("result=" + result);//result=99
        System.out.println("a=" + a);//10
        System.out.println("b=" + b);//98

    }
}


TernaryOperatorDetail.java

//三元运算符细节
public class TernaryOperatorDetail {

    //编写一个main方法
    public static void main(String[] args){
        //表达式1和表达式2要为可以赋给接收变量的类型(或可以自动转换或强制转换)
        int a = 3;
        int b = 8;
        int c = a > b ? (int)1.1 : (int)3.4;//满足
        double d = a > b ? a : b + 3;//满足int -> double
        System.out.println(c);//3
        System.out.println(d);//11.0
    }
}

TernaryOperatorExercise.java

public class TernaryOperatorExercise {

    //编写一个main方法
    public static void main(String[] args) {
        //案例:实现三个数的最大值
        int n1 = 553;
        int n2 = 33;
        int n3 = 123;
        //思路
        //1.先得到n1和n2中最大数,保存到max1
        //2.然后再求出max1和n3的最大数,保存到max2中
        int max1 = n1 > n2 ? n1 : n2;
        int max2 = max1 > n3 ? max1 : n3;
        System.out.println("最大的数是" + max2);//最大的数是553

        //使用一条语句实现,推荐使用上面方法,后面会有更好的方法
        int max = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3;
        System.out.println("最大的数是" + max);//最大的数是553
        
    }
}

input.java

import java.util.Scanner;//把java.util下的Scanner类导入

public class input {

    //编写一个main方法
    public static void main(String[] args) {
        //演示接收用户的输入
        //具体步骤
        //Scanner类表示简单的文本扫描器,在java.util包里
        //1.引入Scanner类所在的包
        //2.创建Scanner对象,new 创建一个对象,体会
        Scanner myScanner = new Scanner(System.in);
        //3.接收用户输入,使用相关的方法
        System.out.println("请输入名字");
        //当程序执行到next方法时,会等待用户输入
        String name = myScanner.next();//接收用户输入字符串
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();//接收用户输入int		
        System.out.println("请输入薪水");
        double sal = myScanner.nextDouble();//接收用户输入double
        System.out.println("人的信息如下:");
        System.out.println("名字=" + name + " 年龄=" + age + " 薪水=" + sal);
    }
}


BinaryTest.java

//演示四种进制
public class BinaryTest {
    //编写一个main方法
    public static void main(String[] args) {
        
        //n1 二进制,0b或0B开头
        int n1 = 0b1010;
        //n2 10进制
        int n2 = 1010;
        //n3 8进制,0开头
        int n3 = 01010;
        //n4 16进制,0x或0X开头
        int n4 = 0x10101;
        System.out.println("n1=" + n1);//10
        System.out.println("n2=" + n2);//1010
        System.out.println("n3=" + n3);//520
        System.out.println("n4=" + n4);//65793
    }
}

/*
0b110001100=1*2^2+1*2^3+1*2^7+1*2^8=4+8+128+256=396
02456=6*8^0+5*8^1+4*8^2+2*8^3=6+40+256+1024=1326
0xA45=5*16^0+4*16^1+10*16^2=5+64+2560=2629
 */

 

/*
0b110001100 = 1*2^2+1*2^3+1*2^7+1*2^8=4+8+128+256=396
02456 = 6*8^0+5*8^1+4*8^2+2*8^3=6+40+256+1024=1326
0xA45 = 5*16^0+4*16^1+10*16^2=5+64+2560=2629
*/

 


BitOperator.java

//位运算
//
public class BitOperator {
    //编写一个main方法
    public static void main(String[] srgs) {
        //推导过程
        //1.得到2的原码            00000000 00000000 00000000 00000010
        //  得到2的补码,和原码一样  00000000 00000000 00000000 00000010
        //2.得到3的原码             00000000 00000000 00000000 00000011
        //  得到3的补码,和原码一样 00000000 00000000 00000000 00000011
        //3.按位与&;
        //00000000 00000000 00000000 00000010
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000010 运算结果得到为补码
        //运算结果的原码是00000000 00000000 00000000 00000010
        //结果就是2
        System.out.println(2&3);//2
        //推导的过程
        //1.得到-2的原码   10000000 00000000 00000000 00000010
        //2.得到-2的反码   11111111 11111111 11111111 11111101
        //3.得到-2的补码   11111111 11111111 11111111 11111110
        //4.按位取反~-2操作        00000000 00000000 00000000 00000001 运算结果得到为补码
        //5.运算结果的原码是00000000 00000000 00000000 00000001
        //结果就是1
        System.out.println(~-2);//1
        //推导过程
        //1.得到2的原码             00000000 00000000 00000000 00000010
        //2.得到2的补码,和原码一样 00000000 00000000 00000000 00000010
        //3.~2操作                  11111111 11111111 11111111 11111101 运算结果得到为补码
        //4.运算结果的反码是        11111111 11111111 11111111 11111100  
        //5.运算结果的原码是        10000000 00000000 00000000 00000011
        //结果就是-3
        System.out.println(~2);//-3
        //推导过程
        //1.得到2的原码 00000000 00000000 00000000 00000010
        //  得到2的补码 00000000 00000000 00000000 00000010
        //2.得到3的原码 00000000 00000000 00000000 00000011
        //  得到3的补码 00000000 00000000 00000000 00000011
        //3.2|3操作 
        //00000000 00000000 00000000 00000010
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000011 运算结果为补码
        //运算结果的原码是00000000 00000000 00000000 00000011
        //结果就是3
        System.out.println(2|3);//3
        //推导过程
        //1.得到2的原码 00000000 00000000 00000000 00000010
        //  得到2的补码 00000000 00000000 00000000 00000010
        //2.得到3的原码 00000000 00000000 00000000 00000011
        //  得到3的补码 00000000 00000000 00000000 00000011
        //3.2^3操作
        //00000000 00000000 00000000 00000010
        //00000000 00000000 00000000 00000011
        //00000000 00000000 00000000 00000001运算结果为补码
        //运算结果的原码是00000000 00000000 00000000 00000001
        //结果就是1
        System.out.println(2^3);//1
    }
}

BitOperator02.java

//位运算
//
public class BitOperator02 {
    //编写一个main方法
    public static void main(String[] srgs) {

        System.out.println(1 >> 2);//0
        System.out.println(1 << 2);//4
        System.out.println(4 << 3);//4*2*2*2=32
        System.out.println(15 >> 2);//15*2*2=3

    }
}

 

赞(1)

评论 抢沙发

评论前必须登录!

 

LNMP社群 不仅仅是技术

关于我们网站地图