文章目录

一、前言
二、数据类型总览
- 1、基本数据类型
- - 1）数值型-整数类型
  - - 1> 有符号整数类型：
    - 2> 无符号整数类型：
    - 3> 其他整数类型：
    - 4> PS:Go的整数类型，默认声明为int类型：
    - 5> 变量占用的字节数
  - 2、数值型-浮点类型
  - - 1> 浮点类型种类
    - 2> PS:Go的浮点类型，默认声明为float64类型：
  - 3、字符类型
  - 4、布尔类型
  - 5、字符串类型
- 2、复杂数据类型
三、类型转换
- 1、基本数据类型之间的转换
- - 1）强制转换
  - - 1> 强转报错：数据溢出
    - 2> 数据溢出自动判断
  - 2）其他基本类型转string
  - - 1> fmt.Sprintf
    - 2> strconv
  - 3）string转其他基本类型
四、总结
- 对比着看Java的基本数据类型

一、前言

在这里插入图片描述

Go系列文章：

GO开篇：手握Java走进Golang的世界
2 Go开发环境搭建、Hello World程序运行
3 Go编程规约和API包
4 Go的变量、常量、运算符

Go专栏传送链接：https://blog.csdn.net/saintmm/category_12326997.html

二、数据类型总览

在这里插入图片描述

1、基本数据类型

基本数据类型大体来看有四种：数值型、字符型、布尔型、字符串。数值型又分为整数类型和浮点类型。

1）数值型-整数类型

用于存放整数值的，比如10,1002,-6712等等。

按数据范围进一步细分，整数类型又分：int8、int16、int32、int64。所谓的8/16/32/64只是用于表示数据临界范围

1> 有符号整数类型：

在这里插入图片描述

2> 无符号整数类型：

在这里插入图片描述

3> 其他整数类型：

在这里插入图片描述

4> PS:Go的整数类型，默认声明为int类型：

在这里插入图片描述

Printf函数的作用是格式化，把age的类型填充到%T位置上。

5> 变量占用的字节数

使用unsafe包下的Sizeof()方法；

package main

import "fmt"
import "unsafe"
// 基础数据类型
func main() {

	age := 18
	fmt.Printf("age的类型是： %T", age)
	fmt.Println();
	fmt.Println("------------------")
	fmt.Println(unsafe.Sizeof(age))
}

在这里插入图片描述

2、数值型-浮点类型

浮点类型用于存放小数，比如：3.14、0.33、-1.19等等。

1> 浮点类型种类

浮点类型有两种：32位float 和 64位float。
在这里插入图片描述

其底层存储空间和操作系统无关。

由于浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只是存了一个大概，很可能会出现精度的损失。

package main

import (
	"fmt"
	"unsafe"
)

// 基础数据类型
func main() {
	float()
}

func float() {
	// 定义浮点类型数据
	var num1 float32 = 3.14
	fmt.Println(num1)

	//浮点数可以用十进制表示形式，也可以用科学计数法表示形式  E 大写小写都可以的
	var num2 float32 = 314E-2
	fmt.Println(num2)

	//浮点数可能会有精度的损失，所以通常情况下，建议使用：float64
	var num3 float32 = 234.000000916
	fmt.Println(num3)
	var num4 float64 = 234.000000916
	fmt.Println(num4)
}

控制台输出如下：
在这里插入图片描述

2> PS:Go的浮点类型，默认声明为float64类型：

// golang中默认的浮点类型为：float64
num5 := 3.17
fmt.Printf("num5对应的默认的类型为：%T",num5)

在这里插入图片描述

当我们在IDEA声明一个float64数据类型的变量时，IDEA编译器会提示：

在这里插入图片描述

3、字符类型

Go中没有专门的字符类型；

如果要存储单个字符（字母、数字、标点等符号），底层对应的是ASCII码值，一般使用byte来保存；
Go中字符使用UTF-8编码，底层对应的是Unicode码值（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案），中文的码值可能会导致byte类型溢出，建议使用int 或 rune存在中文字符。

因此在 Go 语言中，字符可以被分成两种类型处理：

对占 1 个字节的英文类字符，可以使用byte（或者unit8）；
对占 1 ~ 4 个字节的其他字符，可以使用rune（或者int32），如中文、特殊符号等。

ASCII码表：

在这里插入图片描述

字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出：

在这里插入图片描述

想显示对应的字符，必须采用格式化输出：

var c4 byte = 'A'
fmt.Printf("c4对应的具体的字符为：%c",c4)

测试代码：

func char() {
	// 定义字符类型的数据
	var c1 byte = 'a'
	// 字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
	// 输出97
	fmt.Println(c1)

	var c2 byte = '('
	// 字母，数字，标点等字符，底层是按照ASCII进行存储。
	// 输出 40
	fmt.Println(c2 + 20)

	var c3 int = '中'
	// 汉字字符，底层对应的是Unicode码值，中字对应的码值为20013，byte类型溢出，可以用int存储
	fmt.Println(c3)

	var c4 byte = 'A'
	// 想显示对应的字符，必须采用格式化输出
	fmt.Printf("c4对应的具体的字符为：%c",c4)

}

4、布尔类型

布尔类型也叫bool类型，bool类型数据只允许取值true和false；

占1个字节
用于逻辑运算，大量使用于程序流程控制。

package main

import (
	"fmt"
)

// 基础数据类型
func main() {
	boolean()
}
func boolean() {
	var b1 bool = true
	fmt.Println(b1)
	b2 := false
	fmt.Println(b2)
	b3 := 5 < 9
	fmt.Println(b3)
}

控制台输出：
在这里插入图片描述

5、字符串类型

字符串是一串固定长度的字符连接起来的字符序列；

字符串是不可变的，指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
如果字符串中没有特殊字符，字符串的表示形式用双引号“”
如果字符串中有特殊字符，字符串的表示形式用反引号 ``
字符串拼接可以直接使用加号+

测试代码：

package main

import (
	"fmt"
	"unsafe"
)

// 基础数据类型
func main() {
	typeString()
}

func typeString() {
	// 1.定义一个字符串
	var s1 string = "Hello world!"
	fmt.Println(s1)
	// 2. 字符串是不可变的, 指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
	s2 := "abc"
	//s2[0] = 'q']
	// 这里会改变字符串s2的引用
	//s2 = "def"
	fmt.Println(s2)

	// 3.字符串的表示形式：
	//（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
	s3 := "123ads"
	fmt.Println(s3)
	//（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
	s4 := `
					package main
					import "fmt"
					func main() {
						//
					}`
	fmt.Println(s4)

	// 4.字符串拼接
	s5 := "123" + "321asd"
	fmt.Println(s5)

}

控制台输出：
在这里插入图片描述

2、复杂数据类型

复杂数据类型见后面的文章

三、类型转换

1、基本数据类型之间的转换

1）强制转换

Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换（强制转换）。

语法：表达式 T(v) 将值 v 转换为类型 T；

T : 是数据类型
v : 是需要转换的变量
强转后，变量v的类型不会发生改变

例如：将int转为float32

// 1. 进行类型转换：
var n1 int = 100
fmt.Println(n1)
var n2 float32 = float32(n1)
fmt.Println(n2)

// n1的类型还是int，只是将n1的值100转为了float32赋值给n2而已。
fmt.Printf("%T",n1)

1> 强转报错：数据溢出

<1> 编译通过，执行时会数据溢出

// 2. 强转报错：超过数据范围
var n3 int64 = 888888
var n4 int8 = int8(n3)
// 将int64转为int8，编译不会出错，但是会数据溢出
fmt.Println(n4)

2> 数据溢出自动判断

常量 + 一个变量，如果常量不超过相应类型的数据边界，可以编译通过；超过则编译不通过；

// 3. 数据溢出判断
var n5 int64 = 12
// 编译通过，但是结果可能会溢出
var n6 int8 = int8(n5) + 127
// 编译不会通过
var n7 int8 = int8(n5) + 128
fmt.Println(n7)
fmt.Println(n6)

在这里插入图片描述

即使 n5 变量你声明为负数，依旧编译不通过；

在这里插入图片描述

2）其他基本类型转string

其他基本类型转string有两种方式：

fmt.Sprintf("%参数", 表达式) ，推荐使用；
使用strconv包的函数；

1> fmt.Sprintf

在这里插入图片描述

从https://pkg.go.dev/fmt@go1.20.5#Sprintf文档中可以看到各种参数占位符；

在这里插入图片描述

（1）int 转 string：

var n1 int = 6
var s1 string = fmt.Sprintf("%d",n1)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)

（2）float32转 string：

var n2 float32 = 6.78
var s2 string = fmt.Sprintf("%f",n2)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)

（3）bool 转 string：

var n3 bool = false
var s3 string = fmt.Sprintf("%t",n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)

（4）byte 转 string：

var n4 byte = 'd'
var s4 string = fmt.Sprintf("%c",n4)
fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)

控制台输出：
在这里插入图片描述

2> strconv

API文档：https://pkg.go.dev/strconv@go1.20.5#FormatBool

在这里插入图片描述

var n1 int = 6
// 参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
var s1 string = strconv.FormatInt(int64(n1),10)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
var n2 float64 = 6.78

// 第二个参数：'f'表示格式化为（-ddd.dddd，不带指数形式）  第三个参数：9 保留小数点后面9位  第四个参数：表示这个小数是float64类型
var s2 string = strconv.FormatFloat(n2,'f',9,64)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)

var n3 bool = true
var s3 string = strconv.FormatBool(n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)

控制台输出：
在这里插入图片描述

3）string转其他基本类型

string转其他基本类型的方式为使用strconv包的函数，比如：strconv.ParseInt，strconv.ParseFloat

API文档：https://pkg.go.dev/strconv@go1.20.5#ParseBool

在这里插入图片描述

// string --> bool
var s1 string = "true"
var b bool
// ParseBool函数的返回值有两个：(value bool, err error) ，value是我们得到的布尔类型的数据，err表示出现的错误
// 如果只关注布尔类型的数据，err可以用_标识符接收、直接忽略掉。
b , _ = strconv.ParseBool(s1)
fmt.Printf("b的类型是：%T,b=%v \n",b,b)

// string --> int64
var s2 string = "19"
var num1 int64
num1,_ = strconv.ParseInt(s2,10,64)
fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)

// string --> float32/float64
var s3 string = "3.14"
var f1 float64
f1,_ = strconv.ParseFloat(s3,64)
fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)

控制台输出：
在这里插入图片描述

PS：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果为：对应类型的默认值

var s4 string = "golang"
var b1 bool
b1 , _ = strconv.ParseBool(s4)
fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)

var s5 string = "golang"
var num2 int64
num2,_ = strconv.ParseInt(s5,10,64)
fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)

控制台输出：
在这里插入图片描述

四、总结

基本数据类型的默认值（在Go中数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值(默认值又叫零值)）为：
在这里插入图片描述

对比着看Java的基本数据类型

java的基本数据类型有8种：byte、short、int、long、float、double、boolean、char；

Go的基本类型有五种：

布尔型：关键字【bool】： true false
整数类型：又细分为有符号整数类型和无符号整数类型；
- 有符号整数类型（第一位代表正负）：int、int8、int16、int32、int64
- 无符号整数类型：uint、uint8、uint16、uint32、uint64
浮点类型：float32、float64
字符串：string
字符类型：byte（等同uint8，类似于一个别名），用于存放占 1 字节的 ASCII 字符，如英文字符，返回字符原始字节。
- rune（等同int32，只是一个别名），用于存放多字节字符，如占 3 字节的中文字符，返回字符 Unicode 码点值

Java和Go基本数据类型的映射为：

Java	Go
byte（有符号型，字节数据类型）	byte（无符号型，等同uint8，类似一个别名）
short	int16
int	int32
long	int64
float	float32
double	float64
boolean	bool
char（无符号型，字符数据类型）	uint16