Go语言对比java快速入门

1 Hello World!

package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

2 数据类型

数据类型简单速览

数据类型	基本数据类型	复合数据类型	值传递	引用传递
int整数	Y	N	Y	N
float浮点	Y	N	Y	N
string字符串	Y	N	Y	N
bool布尔	Y	N	Y	N
array数组	N	Y	Y	N
slice切片	N	Y	N	Y
map集合	N	Y	N	Y
function函数	N	Y	Y	N
pointer指针	N	Y	Y	N
struct结构体	N	Y	Y	N
interface接口	N	Y	Y	N
channel管道	N	Y	Y	N

2.1 基本数据类型

基本使用

package main

import "fmt"

func main() {
	var flg bool = true
	fmt.Printf("flg的数据类型是%T,值是%t\n",flg,flg)
	var num int = 100
	fmt.Printf("num的数据类型是%T,值是%d\n",num,num)
	var userName string = "zhangsan"
	fmt.Printf("userName的数据类型是%T,值是%s\n",userName,userName)
}

2.1.1 bool布尔型

值传递验证，布尔型

package main

import "fmt"

func main() {
	var flg bool = true
	fmt.Println("before:",flg)
	change(flg)
	fmt.Println("after:",flg)
}

func change(flg bool) {
	flg = false
}

java中一样

public class TestByValueByReference {
	
	@Test
	public void test() {
		boolean flg = true;
		System.out.println("before:"+flg);
		change(flg);
		System.out.println("after:"+flg);
		
	}
	private void change(boolean flg) {
		flg = false;
	}

}

2.1.2 int，float等数字型

咱这是快速入门，不搞那些什么int64，int32啥的，有无符号啥的，先横向学，别纵向钻牛角给自己挖坑，最后忘了自己要学什么。

值传递验证，以int型为例

package main

import "fmt"

func main() {
	var num int = 100
	fmt.Println("before:",num)
	change(num)
	fmt.Println("after:",num)
}

func change(num int) {
	num = 1000
}

java中也一样，以int型为例

public class TestByValueByReference {
	
	@Test
	public void test() {
		int num = 100;
		System.out.println("before:"+num);
		change(num);
		System.out.println("after:"+num);
		
	}
	private void change(int num) {
		num = 1000;
	}

}

2.1.3 string字符串型

值传递验证，字符串
package main

import “fmt”

func main() {
var str string = “abc”
fmt.Println(“before:”,str)
change(str)
fmt.Println(“after:”,str)
}

func change(str string) {
str = “edf”
}

java中也一样，不过String在java中不属于基本数据类型

public class TestByValueByReference {
	
	@Test
	public void test() {
		String str = "abc";
		System.out.println("before:"+str);
		change(str);
		System.out.println("after:"+str);
		
	}
	private void change(String str) {
		str = "edf";
	}

}

2.2 复合数据类型

2.2.1 array数组

a) 数组基本使用

package main

import "fmt"

func main() {
    // 数组的创建及赋值
    var addr = [3]string{"北京", "天津", "南京"}
    // 数组值的修改
    addr[1] = "苏州"
    // 获取数组的容量和长度
    fmt.Printf("数组的长度是%d，容量是%d\n",len(addr),cap(addr))
    // 数组的遍历
    for i := 0; i < len(addr); i++ {
        fmt.Println(addr[i])
    }
    // 数组的遍历 range方式
    for i, v := range addr {
        fmt.Printf("[%d]---[%s]\n",i,v)
    }
}

b)值传递验证， 数组

package main

import "fmt"

func main() {
	var arr = [3]int{11,22,33}
	fmt.Println("before:",arr)
	change(arr)
	fmt.Println("after:",arr)
}

func change(arr [3]int) {
	arr[1] = 222
}

java 中数组也是引用传递

public class TestByValueByReference {
	
	@Test
	public void test() {
		// 数组的声明及初始化
//		int[] arr = new int[3];
//		arr[0] = 11;
//		arr[1] = 22;
//		arr[2] = 33;
//		int[] arr = new int[]{11,22,33};
		int[] arr = {11,22,33};
		System.out.println("before:"+print(arr));
		change(arr);
		System.out.println("after:"+print(arr));
		
	}
	// 打印数组内容
	private String print(int[] arr) {
		StringBuilder sb = new StringBuilder("[");
		for (int i = 0;i < arr.length; i++) {
			sb.append(arr[i]).append(" ");
		}
		return sb.append("]").toString();
	}
	// 改变数组的内容
	private void change(int[] arr) {
		arr[1] = 222;
	}

}

2.2.2 slice切片

切片是动态数组类似java的ArrayList
基本使用

a) 切片是两倍扩容

package main

import "fmt"

func main() {
    // 切片的创建
    var addr []string
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    // 切片中添加数据
    addr = append(addr, "张三")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    addr = append(addr, "李四")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    addr = append(addr, "王五")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    addr = append(addr, "赵六")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    addr = append(addr, "阿七")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    fmt.Printf("addr的数据类型是%T",addr)
}

b) 切片的遍历

package main

import "fmt"

func main() {
    // 切片的创建
    var addr []string
    // 切片中添加数据
    addr = append(addr, "张三")
    addr = append(addr, "李四")
    addr = append(addr, "王五")
    addr = append(addr, "赵六")
    addr = append(addr, "阿七")
    fmt.Printf("切片的长度是%d，容量是%d\n",len(addr),cap(addr))
    // 更改指定位置的数据
    addr[1] = "我是李四亲戚"
    // 切片遍历
    for i, v := range addr {
        fmt.Printf("[%d]->[%s]\n",i,v)
    }
}

c) 切片数据的截取

package main

import "fmt"

func main() {
    // 创建切片
    var nums = []int{11,22,33,44,55}
    fmt.Println(nums)
    // 获取第二到尾部的所有数据
    fmt.Println("-------获取第二到尾部的所有数据-------")
    new_nums := nums[1:]
    fmt.Println(new_nums)
    fmt.Println(nums)
    // 获取从开头到倒数第二个元素的所有数据
    fmt.Println("-------获取从开头到倒数第二个元素的所有数据-------")
    new_nums = nums[:3]
    fmt.Println(new_nums)
    // 获取从第二个到第四个元素的所有数据(前闭后开)
    fmt.Println("-------获取从第二个到第四个元素的所有数据(前闭后开)-------")
    new_nums = nums[1:4]
    fmt.Println(new_nums)

}

d) 引用传递验证，切片

package main

import "fmt"

func main() {
	// 创建切片
	var nums = []int{11,22,33}
	fmt.Println("before:",nums)
	change(nums)
	fmt.Println("after:",nums)
}

func change(nums []int) {
	nums[1] = 222
}

java中的ArrayList也是引用传递

public class TestByValueByReference {
	
	@Test
	public void test() {
		ArrayList<Integer> nums = new ArrayList<Integer>();
		nums.add(11);
		nums.add(22);
		nums.add(33);
		System.out.println("before:" + nums);
		change(nums);
		System.out.println("after:" + nums);
	}
	private void change(ArrayList<Integer> nums) {
		nums.set(1, 222);
	}

}

2.2.3 Map集合

a) map的基本使用

package main

import "fmt"

func main() {
	// map的创建
	var map1 map[string]string
	map1 = make(map[string]string)
	// 往map中添加数据
	map1["1"] = "aa"
	map1["2"] = "bb"
	map1["3"] = "cc"
	map1["4"] = "dd"
	map1["5"] = "ee"
	map1["6"] = "ff"
	// 往map中删除数据
	delete(map1,"6")
	fmt.Println(map1)
	// map的遍历
	for key, value := range map1 {
		fmt.Printf("[%s]->[%s]\n",key,value)
	}
}

如果想要按照key值进行顺序遍历

package main

import (
	"fmt"
	"sort"
)

func main() {
	// map的创建
	var map1 map[string]string
	map1 = make(map[string]string)
	// 往map中添加数据
	map1["1"] = "aa"
	map1["2"] = "bb"
	map1["3"] = "cc"
	map1["4"] = "dd"
	map1["5"] = "ee"
	map1["6"] = "ff"
	fmt.Println(map1)
	// map的遍历
	//for key, value := range map1 {
	//	fmt.Printf("[%s]->[%s]\n",key,value)
	//}

	// 顺序遍历map
	// 创建一个切片存储key
	keys := make([]string, 0, len(map1))
	for key, _ := range map1 {
		keys = append(keys, key)
	}
	fmt.Println(keys)
	sort.Strings(keys)
	fmt.Println(keys)
	for _,key := range keys {
		fmt.Printf("[%s]->[%s]\n",key,map1[key])
	}

}

b) 引用传递验证，map

package main

import "fmt"

func main() {
	// map的创建并初始化
	map2 := map[string]string {
		"1":"aa",
		"2":"bb",
		"3":"cc",
	}
	fmt.Println("before:",map2)
	change(map2)
	fmt.Println("after:",map2)
}

func change(map2 map[string]string) {
	map2["2"] = "bbbbbb"
}

java中map也是引用传递

public class TestByValueByReference {
	
	@Test
	public void test() {
		HashMap<String,String> map2 = new HashMap<String, String>();
		map2.put("1","aa");
		map2.put("2","bb");
		map2.put("3","cc");
		System.out.println("before:" + map2);
		change(map2);
		System.out.println("after:" + map2);
	}
	private void change(HashMap<String, String> map2) {
		map2.put("2", "bbbbbb");
	}

}

2.2.4 function函数

a) 函数的基本定义及使用

// 定义一个加法函数
// x, y 是参数
// result 是返回值
func add(x int, y int) (result int){
	return x + y
} 

func main() {
	result := add(100,200)
	fmt.Println(result)
}

b) 可变参数

package main

import "fmt"

// 可变参数
// args在此处是int类型的slice
func add(args ...int) (result int){
	// result用来存放结果
	result = 0
	for _, v := range args {
		// _表示下标不用接收，v接收传过来的一个个参数
		result += v
	} 
	return result
} 

func main() {
	result := add(100,200,300)
	fmt.Println(result)
}

java中的可变参数

public class Main {

	public static void main(String[] args) {
		int result = add(100,200,300);
		System.out.println(result);
	}
	
	// args在此处是int类型的数组
	static int add(int... args) {
		int result = 0;
//		for (int i = 0; i < args.length; i++) {
//			result += args[i];
//		}
		for (int v : args) {
			result += v;
		}
		return result;
	}
	
}

c) 多个返回值

package main

import "fmt"

// 多返回值
// add方法返回的参数有多个，result表示运算的结果，args_count表示传过来的参数的个数
func add(args ...int) (result int, args_count int){
	// result用来存放结果
	result = 0
	args_count = len(args)
	for _, v := range args {
		// _表示下标不用接收，v接收传过来的一个个参数
		result += v
	} 
	return result, args_count
} 

func main() {
	result,args_count := add(100,200,300)
	// _可以丢弃不要的结果
	result2,_ := add(11,22,33)
	fmt.Println("运算结果是：", result, "传过去的参数个数为", args_count)
	fmt.Println("运算结果是：", result2)
}

java语言好像没有多个返回值之说
d） 匿名函数
匿名函数的定义并直接调用

// 匿名函数
func main() {
	// 匿名函数的定义并直接调用
	func () {
		fmt.Println("匿名函数被调用")
	}()
}

// 匿名函数
func main() {
	// 匿名函数的定义,通过给赋值给一个变量名可以多次调用
	var f = func () {
		fmt.Println("匿名函数被调用")
	}
	f()
	f()
}

e) 函数作为参数（回调函数）

package main

import "fmt"

// 定义一个加法函数
func add(x int, y int)int{
	return x + y
}

// 定义一个减法函数
func sub(x int, y int)int{
	return x - y
}

// 定义一个运算函数，
// x, y 是参与运算的数字
// oper是传过来的运算函数
func operation(x, y int, oper func(int,int)int)(int) {
	res := oper(x,y)
	return res
}

// 函数作为参数
func main() {
	// 传个加法函数过去
	res := operation(100,200,add)
	fmt.Println(res)
	
	// 传个减法函数过去
	res = operation(100,200,sub)
	fmt.Println(res)
	
	// 传个匿名函数过去，作乘法运算
	res = operation(100,200,func (x int, y int)int{
		result := x * y
		return result
	})
	fmt.Println(res)

}

java8及以上版本中有类似的函数式编程，可以对照着学习

package per.blacksnow;

//定义一个加法函数
class Add implements Operation{
	@Override
	public int oper(int x, int y) {
		return x + y;
	}
}

//定义一个减法函数
class Sub implements Operation {
	@Override
	public int oper(int x, int y) {
		return x - y;
	}
}

@FunctionalInterface
interface Operation {
	int oper(int x, int y);
}


public class Main {

	// 定义一个运算函数，
	// x, y 是参与运算的数字
	// operation是传过来的运算函数
	public static int operation(int x, int y, Operation operation) {
		int res = operation.oper(x, y);
		return res;
	}
	
	public static void main(String[] args) {
		// 传个加法函数过去
		Add add = new Add();
		int res = operation(100,200,add);
		System.out.println(res);
		
		// 传个减法函数过去
		Sub sub = new Sub();
		res = operation(100,200,sub);
		System.out.println(res);
		
		// 传个匿名函数过去，作乘法运算
		res = operation(100,200,(x, y)->{
			int result = x * y;
			return result;
		});
		System.out.println(res);
	}
}

f) 函数作为返回值，可以形成闭包结构

package main

import "fmt"

func main() {

	f1 := increment()
	fmt.Println(f1())
	fmt.Println(f1())
	fmt.Println(f1())
	fmt.Println(f1())
	fmt.Println(f1())

	fmt.Println("==")
	f2 := increment()
	fmt.Println(f2())
	fmt.Println(f2())	
	
	fmt.Println("==")
	fmt.Println(f1())
}

// 定义一个外层函数increment
func increment()func ()int{
	// 外层函数中有个局部变量i
	i := 0
	// 定义一个匿名的内层函数, 为了方便return，将其赋值给一个变量f
	f := func ()int {
		// 对外层的局部变量进行运算
		i++
		return i
	}
	return f
}

2.2.5 pointer指针

2.2.6 struct结构体

值传递验证，结构体

package main

import "fmt"

func main() {
	stu := Student{name:"zhangsan", age:18}
	fmt.Println("before:",stu)
	change(stu)
	fmt.Println("after:",stu)
}

type Student struct {
	name string
	age int
}

func change(stu Student) {
	stu.age = 28
}

java中的类，类似于struct结构体，不过它是引用传递

public class TestByValueByReference {
	
	@Test
	public void test() {
		
		Student stu = new Student("zhangsan", 18);
		System.out.println("before:" + stu);
		change(stu);
		System.out.println("after:" + stu);
	}
	private void change(Student stu) {
		stu.age = 28;
	}

}

class Student {
	String name;
	int age;
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "{"+this.name+" " + this.age +"}";
	}
}

2.2.7 interface接口

1 接口的基本使用

package main

import "fmt"

// 接口定义
type USB interface {
	start()
	end()
}

// 定义一个结构体鼠标，当作接口的实现
type Mouse struct {
	name string
}

// 定义方法USB接口中定义的方法start()，指定方法的调用者为Mouse
func (mouse Mouse) start() {
	fmt.Println(mouse.name + "开始工作")
}

// 定义方法USB接口中定义的方法end()，指定方法的调用者为Mouse
func (mouse Mouse) end() {
	fmt.Println(mouse.name + "结束工作")
}

// 定义模板函数work
func work(usb USB) {
	usb.start()
	usb.end()
}

func main() {
	mouse := Mouse{name:"小米鼠标"}
	mouse.start()
	mouse.end()
	fmt.Println("===========")
	work(mouse)
}

2.2.8 channel管道