GO语言基础知识(三.运算符)

最新推荐文章于 2024-06-14 05:44:12 发布

凌波微步小段誉

最新推荐文章于 2024-06-14 05:44:12 发布

阅读量360

点赞数 10

分类专栏： Golang 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/qq1543002286/article/details/134908978

版权

Golang 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.运算符：

1.算术运算符:

算术运算符，也就是我们数学中的算术运算，包括加，减，乘，除，余

运算符	描述
+	加
-	减
*	乘
/	除
%	余

1）java中的算术运算符：

package org.example;

public class Main {
    public static void main(String[] args) {
        int num1 = 10, num2 = 12, num3 = 13, num4 = 14;
        //加法
        int sum = num1 + num2;
        System.out.println(sum);
        //减法
        int sub = num3 - num1;
        System.out.println(sub);
        //乘法
        int mul = num4 * num1;
        System.out.println(mul);
        //除法
        int division = num4 / num1;
        double division2 = (double) num4 / num1;
        System.out.println(division);
        System.out.println(division2);
        //求余数
        int complementation = num4 % num1;
        System.out.println(complementation);
    }
}

2）golang中的算术运算符：

package main

import "fmt"

func main() {
	var (
		num1 = 10
		num2 = 12
		num3 = 13
		num4 = 14
	)
	//加法
	sum := num1 + num2
	fmt.Println(sum)

	//减法
	sub := num3 - num1
	fmt.Println(sub)

	//乘法
	mul := num1 * num4
	fmt.Println(mul)

	// 除法
	division := num4 / num1
	fmt.Println(division)
	division2 := float64(num4) / float64(num1)
	fmt.Println(division2)

	// 求余
	complementation := num4 % num1
	fmt.Println(complementation)
}

2.关系运算符:

关系运算符是用于比较两个值之间关系的运算符。(关系运算符一般用于if判断中)

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False 。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False 。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False 。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False 。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False 。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False 。

1）java中的关系运算符：

package org.example;

public class Main {
    public static void main(String[] args) {
        int n1 = 9, n2 = 8;
        System.out.println(n1 == n2);
        System.out.println(n1 != n2);
        System.out.println(n1 > n2);
        System.out.println(n1 >= n2);
        System.out.println(n1 < n2);
        System.out.println(n1 <= n2);
        boolean flag = n1 > n2;
        System.out.println("flag=" + flag);
    }
}

2）golang中的关系运算符：

package main

import "fmt"

func main() {
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2) //false
	fmt.Println(n1 != n2) //true
	fmt.Println(n1 > n2)  //true
	fmt.Println(n1 >= n2) //true
	fmt.Println(n1 < n2)  //flase
	fmt.Println(n1 <= n2) //flase
	flag := n1 > n2
	fmt.Println("flag=", flag)
}

3.逻辑运算符:

逻辑运算符是用于组合和操作逻辑值（布尔值）的运算符

运算符	描述
&&	逻辑 AND 运算符。如果两边的操作数都是 True ，则为 True ，否则为 False 。
\|\|	逻辑 OR 运算符。如果两边的操作数有一个 True ，则为 True ，否则为 False 。
！	逻辑 NOT 运算符。如果条件为 True ，则为 False ，否则为 True 。

1）java中的逻辑运算符：

package org.example;

public class Main {
    public static void main(String[] args) {
        int n1 = 7, n2 = 8, n3 = 7;
        //逻辑且
        if (n1 > n2 && n1 >=n3) {
            System.out.println("n1 > n2 且 n1 >= n3");
        } else {
            System.out.println("不满足条件");
        }
        //逻辑或
        if (n1 > n2 || n1 >= n3) {
            System.out.println("n1 > n2 或 n1 >= n3");
        } else {
            System.out.println("不满足条件");
        }
        //逻辑非
        if (!(n1 > n2)) { //相当于 n2 >= n1
            System.out.println("!(n1 > n2)");
        } else {
            System.out.println("不满足条件");
        }
    }
}

2）golang中的逻辑运算符：

package main

import "fmt"

func main() {
	var n1 int = 7
	var n2 int = 8
	var n3 int = 7
	//逻辑且
	if n1 > n2 && n1 >= n3 {
		fmt.Println("n1 > n2 且 n1 >= n3")
	} else {
		fmt.Println("不满足条件")
	}
	//逻辑或
	if n1 > n2 || n1 >= n3 {
		fmt.Println("n1 > n2 或 n1 >= n3")
	} else {
		fmt.Println("不满足条件")
	}
	//逻辑非
	if !(n1 > n2) { //相当于 n2 >= n1
		fmt.Println("!(n1 > n2)")
	} else {
		fmt.Println("不满足条件")
	}
}

4.赋值运算符:

赋值运算是将一个值或表达式赋给一个变量或存储位置的操作

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值

1）java中的赋值运算符：

package org.example;

public class Main {
    public static void main(String[] args) {
        int n1 = 1, n2 = 2, n3 = 3, n4 = 4, n5 = 5;
        n1 += 5;// n1 = n1 + 5;
        n2 -= 1;// n2 = n2 -1;
        n3 *= 3;// n3 = n3 * 3;
        n4 /= 2;// n4 = n4 / 2;
        n5 %= 2;// n5 = n5 % 2;
        System.out.println(n1);
        System.out.println(n2);
        System.out.println(n3);
        System.out.println(n4);
        System.out.println(n5);
    }
}

2）golang中赋值位运算符：

package main

import "fmt"

func main() {
	var (
		n1 = 1
		n2 = 2
		n3 = 3
		n4 = 4
		n5 = 5
	)
	n1 += 5 // n1 = n1 + 5;
	n2 -= 1 // n2 = n2 -1;
	n3 *= 3 // n3 = n3 * 3;
	n4 /= 2 // n4 = n4 / 2;
	n5 %= 2 // n5 = n5 % 2;
	fmt.Println(n1, n2, n3, n4, n5)
}

5.位运算符(了解):

位运算符对整数在内存中的二进制位进行操作。了解即可，不常用，但是看到要明白什么意思才行。

运算符	描述
&	参与运算的两数各对应的二进位相与。（两位均为 1 才为 1 ）
\|	参与运算的两数各对应的二进位相或。（两位有一个为 1 就为 1 ）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为 1 。（两位不一样则为 1 ）
<<	左移 n 位就是乘以 2 的 n 次方。 “a<<b” 是把 a 的各二进位全部左移 b 位，高位丢弃，低位补 0 。
>>	右移 n 位就是除以 2 的 n 次方。 “a>>b” 是把 a 的各二进位全部右移 b 位。

1）java中的位运算符：

package org.example;

public class Main {
    public static void main(String[] args) {
        int a = 5;
        // 十进制转二进制
        String binaryStringA = Integer.toBinaryString(a);
        System.out.println(binaryStringA);

        int b = 2;
        String binaryStringB = Integer.toBinaryString(b);
        System.out.println(binaryStringB);
        /*
            101
             10
            a & b两者为1才为1
            所以a & b = 0
         */
        System.out.println("a&b=" + (a & b));
        /*
            101
             10
            a | b 其中一个为1则为1
            所以 a | b = 111 ===> 十进制位 7
         */
        System.out.println("a|b==" + (a | b));
        /*
            101
             10
            a ^ b 两者不同则为1
            a ^ b = 111 ===>  十进制为7
         */
        System.out.println("a^b=" + (a ^ b));
        /*
            101
            a >> b 右移2位 101 ===> 1 十进制为1
         */
        System.out.println("5>>2=" + (a >> b));
        /*
            101
            a << b 左移2位 10100 ===> 十进制为20
         */
        System.out.println("5<<2=" + (a << b));
        /*
            101
            5 << 1 左移1位 1010 ===> 10
         */
        System.out.println("5<<1=" + (5 << 1));
        /*
            101
            5 >> 1 右移1位 10 ===> 2
         */
        System.out.println("5>>1=" + (5 >> 1));
        /*
            111
            7 >> 2 右移2位 1 ===> 1
         */
        System.out.println("7>>2=" + (7 >> 2));
    }
}

2）golang中的位运算符：

package main

import "fmt"

func main() {
	/* & 两位均为 1 才为 1
	   | 两位有一个为 1 就为 1
	   ^ 相异或 两位不一样则为 1
	   << 左移 n 位就是乘以 2 的 n 次方。 “a<<b”是把 a 的各二进位全部左移 b 位，
	   高位丢弃，低位补 0。
	   >> 右移 n 位就是除以 2 的 n 次方。
	*/
	var a int = 5              // 101
	var b int = 2              // 010
	fmt.Println("a&b=", a&b)   // 000 值 0
	fmt.Println("a|b=", a|b)   // 111 值 7
	fmt.Println("a^b=", a^b)   // 111 值 7
	fmt.Println("5>>2=", a>>b) // 5 右移 2 位 1
	fmt.Println("5<<2=", a<<b) // 5 左移 2 位 10100
	fmt.Println("5<<1=", 5<<1) // 1010
	fmt.Println("5>>1=", 5>>1) // 10
	fmt.Println("7>>2=", 7>>2) // 1
}