java学习培训期笔记和重要知识归纳3（运算符&随机数）

最新推荐文章于 2024-07-14 14:59:27 发布

Cuokoo

最新推荐文章于 2024-07-14 14:59:27 发布

阅读量124

点赞数 1

分类专栏： java学习笔记文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/weixin_45281412/article/details/124646833

版权

java学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、运算符

* 运算符:
* 算术运算符: + - * / % ++ --
* 逻辑运算符: & | ! ^ && ||
* 赋值运算符: += -= *= /= %=
* 比较运算符: > < ==(等于) !=(不等于) >= <=
* 三目运算符: ?:
* 位运算符: & | ~ ^ << >> >>>

1、算数运算符：

public class Demo_01 {
    public static void main(String[] args){
        /**
         *  算术运算符: + - * / % ++ --
         */
        // 1、不同的数据类型的元素之间进行运算，最终的值的数据类型和
        //    数据类型较大的保持一致
        //    运算? 整型 和 浮点型之间进行运算
        int a = 10;
        double b = 20;
        int c = 3;
        System.out.println(a / c);//3  两个整数之间进行运算得到的是整数
        System.out.println(b / c);//6.666666666666667
        System.out.println(b % c);//2.0

        // 2、取余的结果的符号只和第一个数的符号相关,并且和第一个数的符号保持一致
        System.out.println(10 % 4);//2
        System.out.println(-10 % 4);//-2
        System.out.println(10 % -4);//2
        System.out.println(-10 % -4);//-2

    // 3、+的用法
    // 作为运算符进行加法运算:
    //作为连接符将元素连接在一起:一般用在字符串和其他元素的连接中,最终形成一个新的字符串
        System.out.println("" + 5);//5
        System.out.println("6.66" + 520.0);//6.66520.0
        System.out.println("中" + '国');
        //将字符使用万国码进行转换,转换成对应的整数然后和整数进行相加
        System.out.println('哈' + 5);//21709

        System.out.println("1" + 1 + 1 + 1);//1111
        System.out.println(1 + 1 + "1" + 1);//211

        System.out.println(10 + " + " + 20 + " = " + 10 + 20);//10 + 20 = 1020
        //如果在字符串拼接的过程中需要进行算术运算就将运算的部分使用括号括起来
        System.out.println(10 + " + " + 20 + " = " + (10 + 20));//10 + 20 = 30


        //有一个整数:44567
        //将各个位置的数取出来
        //万:4 千:4 百:5 十:6 个:7
        //44567
        System.out.println("个:" + (44567 % 10));
        System.out.println("十:" + (44567 / 10 % 10));//44567 / 10 = 4456 % 10
        System.out.println("百:" + (44567 / 100 % 10));//44567 / 100 = 445 % 10
        System.out.println("千:" + (44567 / 1000 % 10));
        System.out.println("万:" + (44567 / 10000));
    }
}

要点：

* ++:自增
* --:自减
* 自增自减是在原来的数字的基础上进行加1的处理
*
* 以加号进行举例:
* i++:先进行输出或者运算,在输出和运算的时候,还使用的是原来的数字.
* 运算完成之后再在原来的基础上加1
* ++i:先进行加1的处理,然后拿加1之后的数字进行运算
*
* 加号放在前面就先加在计算,加号放在后面就先拿原数值进行计算,计算完成之后再加1
代码如下：

public class Demo_02 {
    public static void main(String[] args) {
        int n = 10;
        System.out.println(n++);//10
        System.out.println(n);//11

        int i = 10;
        int j = 5 + i++;
        System.out.println("j = " + j);//j = 15
        System.out.println("i = " + i);//i = 11

        j = j + ++i;//j = 15 + 12;
        System.out.println("j = " + j);//j = 27

        //先进行加1的处理,然后拿加1之后的数字进行运算或者输出
        int w = 10;
        System.out.println(++w);//11
        System.out.println(w);//11

        int p = 10;
        int q = 5 + ++p;
        System.out.println("q = " + q);//16
        System.out.println("p = " + p);//11

        q = q - p--;//q = 16 - 11;
        System.out.println("q = " + q);//q = 5
        System.out.println("p = " + p);//p = 10
    }
}

2、比较运算符：

* 比较运算符: > < ==(等于) !=(不等于) >= <=
*
* 比较运算符的最终结果都是boolean类型的值
*
* ==比较基本数据类型的时候比较的是值
* ==比较引用数据类型的时候比较的是地址
* String类型在使用equals进行比较的时候,首先比较内容再比较地址,两个都相同表示想通过
* Object是所有类的父类或者祖父类，所有的类直接或者间接来源于Object
* 在Object中有equals和hashcode的方法的模板,所有的类如果想要进行区分
* 就必须去重新写equals和hashcode
*
* equals底层的实现其实也是==

public class Demo_03 {
    public static void main(String[] args) {
        System.out.println(100 > 200);
        System.out.println(3 == 2);

        System.out.println(1 != 10 % 3.0);//false

        //基本数据类型的比较使用==
        //字符串.equals(字符串)
        //比较两个字符串的内容是否相同
        //但是不忽略大小写
        System.out.println("hello".equals("Hello"));//false

        //比较两个字符串的类型是否相同，忽略大小写
        System.out.println("hello".equalsIgnoreCase("HELLO"));//true
    }
}

3、赋值运算符：

/**
 * 三目运算符:
 * ?:
 * 语法:
 *      条件表达式 ？ 值1 : 值2;
 *  如果条件表达式的结果值为true,就选择值1
 *  如果条件表达式的结果值为false,就选择值2
 */
public class Demo_06 {
    public static void main(String[] args) {
        System.out.println(5 == 3 ? "5和3相等" : "5和3不相等");

        //在输出语句中写三目运算的时候,值的数据类型可以不相同
        //因为无论什么样的数据类型元素都可以输出
        System.out.println(5 < 3 ? "5" : 3);

        //如果使用变量来接收三目运算的值,那么值得数据类型必须小于或者等于
        //变量的数据类型
        double m = 5 > 3 ? 5.0 : 3;
        System.out.println("m = " + m);

        int n = 17 > 25 ? (17 > 30 ? 17 : 30) : (25 > 30 ? 25 : 30);
        System.out.println("n = " + n);
    }
}

4、逻辑运算符：

* 逻辑运算符: 最终的结果也是boolean类型
* &:与两个表达式的值都是true的时候结果为true,有一个是false,结果就是false
* |:或两个表达式只要有一个true,结果就是true
* !:非取反，结果为true,相反取false
* ^:异或两个结果相同取false,结果不同就取true
*
* 短路的情况并不会影响程序的最终的结果,影响的是程序的过程
* 在开发的过程中我们经常使用的条件判断都是短路的情况
* &&:短路与
* 如果说正常的与符号,会将程序从头到尾一次进行计算
* 如果是短路与,那么当一个表达式的结果为false的时候,程序就不再往后执行了
*
* ||:短路或
* 如果判断有一个结果是正确的,那么就直接得出结果,不再往后计算

public class Demo_07 {
    public static void main(String[] args) {
        boolean f1 = true;
        boolean f2 = true;
        boolean f3 = false;
        boolean f4 = false;

        //&:一假即假
        System.out.println(f1 & f3);
        System.out.println(f1 & f2);
        System.out.println(100 > 200 & 200 == 300);

        //|:一真即真
        System.out.println(f4 | f1);
        System.out.println(f1 | f2);

        //!:取反
        System.out.println(!f1);//false
        System.out.println(!(20 < 30 | 30 > 40));

        //^:同假异真
        System.out.println(f1 ^ f3);
        System.out.println(f3 ^ f4);

        System.out.println(20 > 30 && 10 < 20);

        int a = 3;
        int b = 2;
        //              3     1
        boolean bb1 = (a++) > (--b)|| (--a) < 0 || (++a) > (b++);
        System.out.println(bb1+"\t"+a+"\t"+b);

        a = 3;
        b = 2;
        //              3     1        3      1            3     2
        boolean b10 = (a++)>(--b) && (--a)%(b++) == 1 && (a--)<(b--);

        //false	3	2
        System.out.println(b10+"\t"+a +"\t"+b);
    }
}

5、位运算符：

* 位运算符:
* &:按位与
* |:按位或
* ~:按位取反
* ^:按位异或
* <<:左移运算符
* >>:有符号右移运算符
* >>>:无符号右移运算符
*
* m >> n:将m这个数转换成二进制,然后向右移动n位
* 如果是正数:则前面补n个0
* 如果是负数:则前面补n个1
* m << n 将m转换成2进制,然后向左移动n位,不分正负,则后面补n个0
* m >>> n 将m转换成2进制,然后向右移动n位,不分正负,前面补n个0

public class Demo_08 {
    public static void main(String[] args) {
        //与运算有一个为0结果就为0
        //如果两个都是1,结果为1
        int a = 2;// 0 0 1 0
        int b = 3;// 0 0 1 1
        //           0 0 1 0
        System.out.println(a & b);//2

        //或运算有一个为1结果就是1
        //如果两个都是0,结果为0
        int c = 5;//0 1 0 1
        int d = 7;//0 1 1 1
        //          0 1 1 1
        System.out.println(c | d);//7

        //按照位置进行取反
        int m = 7;//0 1 1 1
        //          1 0 0 0
        System.out.println(~7);//-8

        //相同为0,不同为1
        int k = 4;//0 1 0 0
        int u = 3;//0 0 1 1
        //          0 1 1 1
        System.out.println(k ^ u);//7         0 1 1 1


        //0 1 0 1
        //0 0 0 1
        //有符号右移
        System.out.println(5 >> 2);

        //无符号左移
        System.out.println(3 << 2);//12

        //无符号右移
        System.out.println(4 >>> 2);//1


        //负数
        // 原码 反码 补码
        // 正数: 原码=反码=补码
        // 负数: 先将对应的整数转换成2进制之后,对2进制进行取反,然后对结果加1
        //-5转换成2进制
        //1、将十进制转换成2进制,不管符号
        //0 0 0 0  0 1 0 1

        //2、对转换过的2进制进行逐位取反
        //1 1 1 1  1 0 1 0

        //3、对取反之后的二进制加1,结果就是十进制的负数转换成2进制的结果
        //1 1 1 1  1 0 1 1

        //m >> n:将m这个数转换成二进制,然后向右移动n位
        //       如果是负数:则前面补n个1
        System.out.println(-5 >> 2);//-2

        //1111 1011      -5
        //1  1111 101    向右移动一位

        //移位之后的二进制数
        //11 1111 10     向右移动两位


        //把负数的2进制转换成10进制
        //1、首先对二进制数进行减1的处理
        //11111101

        //2、对减1之后的二进制进行取反
        //00000010

        //3、将2进制转换成10进制
        //-2

        //代码格式化:ctrl + alt + l
    }
}

博主在这里想到了一个java笔试题目：

int a=2*8怎样运算效率最快

用位运算 int a=2<<3;
a就是2乘以8 最后结果是16 这是最省内存最有效率的方法

二、随机数：

/**
 * Random:随机数 伪随机数
 * 是使用算法生成的随机数,可以根据算法知道下一个数是什么
 * Math.random()
 */
public class Demo_09 {
    public static void main(String[] args) {
        //1、默认生成0 - 1之间的随机小数,包含0但是不包含1
        double a = Math.random();
        System.out.println("a = " + a);

        //2、生成0 - 100之间的小数
        double b = Math.random() * 100;
        System.out.println("b = " + b);

        //3、生成0 - 100之间的整数
        //将一个小数扩大100倍然后再取整
        int c = (int)(Math.random() * 100);
        System.out.println("c = " + c);

        //4、生成200 - 300之间的整数
        //(1)首先分析从什么值开始  200
        //(2)考虑这个值在什么时候结束 300
        //(3)中间的范围一个多少个值? 100
        //200 + 0 = 200
        //200 + 100 = 300
        int d = 200 + (int)(Math.random() * 100);
        System.out.println("d = " + d);
        for(;;){
            //Math.random() * 100:0 - 100之间的小数,不包含100
            //(int)(Math.random() * 100):这里取不到整数100
            //200 + (int)(Math.random() * 100): 200 - 299
            int e = 200 + (int)(Math.random() * 101);
            if(e == 300){
                System.out.println("e = " + e);
                break;
            }else{
                System.out.println("e = " + e);
            }
        }
    }
}