GO语言基础知识（二.基本数据类型，类型转化）

凌波微步小段誉

于 2023-12-03 20:59:53 发布

阅读量933

点赞数 25

分类专栏： Golang 文章标签： golang go java

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

版权

Golang 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.整形

1.java中的整形

java中整形包括byte，short，int，long

byte：1字节，范围为-128到127。
short：2字节，范围为-32,768到32,767。
int：4字节，范围为-2,147,483,648到2,147,483,647。
long：8字节，范围为-9,223,372,036,854,775,808到9,223,372,036,854,775,807。

java中定义这几种类型：

package org.example;

public class Main {
    public static void main(String[] args) {
       byte num1 = 1;
       short num2 = 2;
       int num3 = 3;
       long num4 = 4;
    }
}

2.golang中的整形

golang中的整形大体分为int类型和uint类型

int类型和uint的类型区别在于：

int类型为有符号整形

int包括：int8，int16，int32，int64

int8：1 字节，范围为 -128 到 127。
int16：2 字节，范围为 -32,768 到 32,767。
int32：4 字节，范围为 -2,147,483,648 到 2,147,483,647。
int64：8 字节，范围为 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。
int：根据操作系统平台，为 32 位或 64 位。

uint类型为无符号整形，只能表示正数不能表示负数

unit包括：uint8，unit16，uint32，uint64

uint8：1 字节，范围为 0 到 255。
uint16：2 字节，范围为 0 到 65,535。
uint32：4 字节，范围为 0 到 4,294,967,295。
uint64：8 字节，范围为 0 到 18,446,744,073,709,551,615。
uint：根据操作系统平台，为 32 位或 64 位。

golang中定义这几种类型：

package main

import "fmt"

func main() {
	var (
		num1 int8   = 1
		num2 int16  = 2
		num3 int32  = -1
		num4 int64  = -2
		num5 uint8  = 3
		num6 uint16 = 4
		num7 uint32 = 5
		num8 uint64 = 6
	)
	fmt.Printf("数据类型为%T,值为%v\n", num1, num1)
	fmt.Printf("数据类型为%T,值为%v\n", num2, num2)
	fmt.Printf("数据类型为%T,值为%v\n", num3, num3)
	fmt.Printf("数据类型为%T,值为%v\n", num4, num4)
	fmt.Printf("数据类型为%T,值为%v\n", num5, num5)
	fmt.Printf("数据类型为%T,值为%v\n", num6, num6)
	fmt.Printf("数据类型为%T,值为%v\n", num7, num7)
	fmt.Printf("数据类型为%T,值为%v\n", num8, num8)
}

3.整形间类型转化：

1.）java中整形间的互相转化

在java中类型转化可以采用强转的方式来进行转化，例如：

package org.example;

public class Main {
    public static void main(String[] args) {
       byte num1 = 1;
       short num2 = 2;
       int num3 = 3;
       long num4 = 4;
       int num5 = (int) num1;
       int num6 = (int) num2;
       int num7 = (int) num3;
       int num8 = (int) num4;
       System.out.println(num5);
       System.out.println(num6);
       System.out.println(num7);
       System.out.println(num8);
    }
}

注意：类型转化通常由小的转化为大的值，从大的值转化成小的值可能会造成数据溢出或精度丢失的问题

2.）golang中整形间的互相转化

golang中的类型转化与java的类型转化比较类似，但是golang不像java拥有包装类可以自动拆装箱

下面是golang中的转化方法

package main

import "fmt"

func main() {
	var num int8 = 2
	num1 := int16(num)
	num2 := uint8(num)
	fmt.Printf("数据类型为%T,值为%v\n", num, num)
	fmt.Printf("数据类型为%T,值为%v\n", num1, num1)
	fmt.Printf("数据类型为%T,值为%v\n", num2, num2)
}

注意：int和uint转化的时候切记负数转化成uint会出问题

二.浮点型

1.java中的浮点型

java中的浮点型包括float和double

float：4 字节，范围为约 ±3.40282347E+38F（有效位数为 6-7 位）。
double：8 字节，范围为约 ±1.79769313486231570E+308（有效位数为 15 位）。

java中定义浮点型：

package org.example;

public class Main {
    public static void main(String[] args) {
        float num = 1.1f;
        double num1 = 1.2;
        System.out.println(num);
        System.out.println(num1);
    }
}

2.golang中的浮点型

Go语言提供了两种浮点类型：float32和float64，分别对应单精度浮点数和双精度浮点数。

float32类型的变量可以存储大约6个小数位的精度，而float64类型的变量可以存储大约15个小数位的精度。通常情况下，我们使用float64类型来进行浮点数计算，因为它提供了更高的精度。

float32：4 字节，范围为约 ±1.18E-38 到 ±3.4E+38（有效位数为 7 位）。
float64：8 字节，范围为约 ±2.23E-308 到 ±1.8E+308（有效位数为 15 位）。

golang中定义浮点型：

package main

import "fmt"

func main() {
	var num float32 = 1.323
	var num1 float64 = 1.414
	fmt.Printf("数据类型为%T,值为%v\n", num, num)
	fmt.Printf("数据类型为%T,值为%v\n", num1, num1)
}

注意：在进行金额相关的计算的时候java推荐使用BigDecimal，golang推荐使用decimal

package org.example;

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal num = new BigDecimal("1.321");
        System.out.println(num);
    }
}

golang使用decimal需要引入decimal包：

执行语句：go get github.com/shopspring/decimal

package main

import (
	"fmt"
	"github.com/shopspring/decimal"
)

func main() {
	var num, _ = decimal.NewFromString("1.312")
	fmt.Printf("数据类型为%T,值为%v\n", num, num)
}

三.布尔型

1.java中的布尔型

java中的布尔型为boolean，值为true，false，一般用于判断是否

package org.example;

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        boolean flag = true;
        System.out.println(flag);
    }
}

2.golang中的布尔型

golang的布尔型为bool，值为true，false，一般用于判断是否

package main

import "fmt"

func main() {
	var flag bool = true
	fmt.Printf("数据类型为%T,值为%v\n", flag, flag)
}

四.字符型 / 字符串类型

1.java中的字符型

java的字符型为char类型：

char：2 字节，表示一个 Unicode 字符，范围为 0 到 65,535。

在java中字符串大多数使用String类型来定义字符串，很少会使用char类型

package org.example;

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        char t = 't';
        System.out.println(t);
        String study = "study";
        System.out.println(study);
    }
}

java中拼接两个字符串可以直接使用+号来拼接

package org.example;

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        String name = "xiao" + "Duan" + "Yu";
        System.out.println(name);
    }
}

java中两个String类型拼接采用StringBuffer和StringBuilder

StringBuffer线程安全，StringBuilder线程不安全，但是StringBuilder性能更好

package org.example;

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        String name = "xiao" + "Duan" + "Yu";
        System.out.println(name);
        StringBuilder sb = new StringBuilder();
        sb.append(name);
        sb.append("study");
        sb.append("JAVA");
        System.out.println(sb);

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(name);
        stringBuffer.append("study");
        stringBuffer.append("JAVA");
        System.out.println(stringBuffer);
    }
}

2.golang中的字符串类型

golang中字符串类型为string

string：表示一个字符串，由一系列的字节组成。

golang中定义一个string类型

package main

import "fmt"

func main() {
	var name string = "xiaoduanyu"
	fmt.Printf("数据类型为%T,值为%v\n", name, name)
}

golang中string类型的采用操作

package main

import (
	"fmt"
	"strings"
)

func main() {
	var name string = "xiao duan yu"
	fmt.Printf("数据类型为%T,值为%v\n", name, name)
	//分割
	name2 := strings.Split(name, " ")
	//string数组拼接
	name3 := strings.Join(name2, "*")
	fmt.Printf("数据类型为%T,值为%v\n", name2, name2)
	fmt.Printf("数据类型为%T,值为%v\n", name3, name3)
	//是否包含
	var flag = strings.Contains(name, "xiao")
	fmt.Printf("数据类型为%T,值为%v\n", flag, flag)
	//长度
	var length = len(name)
	fmt.Printf("数据类型为%T,值为%v\n", length, length)
	//字符串出现的位置
	index := strings.Index(name, "a")
	fmt.Printf("数据类型为%T,值为%v\n", index, index)
	//前缀判断
	prefix := strings.HasPrefix(name, "xi")
	fmt.Printf("数据类型为%T,值为%v\n", prefix, prefix)
	//后缀判断
	suffix := strings.HasSuffix(name, "u")
	fmt.Printf("数据类型为%T,值为%v\n", suffix, suffix)
}

3.golang中byte 和 rune 类型

go语言中的字符类型有

1. uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。

2. rune 类型，代表一个 UTF-8 字符

byte类型，也就是uint8类型，定义byte类型使用单引号和java一致

package main

import "fmt"

func main() {
	a := 'a'
	fmt.Printf("数据类型为%T,值为%v\n", a, a)
	// 直接输出会输出对应的ascll值
	fmt.Println(a)
	fmt.Printf("数据类型为%T,值为%v,对应字符为%c", a, a, a)
}

rune，也就是int32 类型专门用来处理 Unicode编码值，让基于 Unicode 的文本处理更为方便

package main

import "fmt"

func main() {
	name := "xiaoduanyu"
	// byte一般用于英文
	for i := 0; i < len(name); i++ {
		fmt.Printf("值为%c,对应ascll码值为%v\n", name[i], name[i])
	}

	// rune一般用于中文
	for _, r := range name {
		fmt.Printf("值为%c,对应的值为%v\n", r, r)
	}
}