由引用类型引发的概念的深入理解

package main

import (
  "fmt"
)

func main() {
  //这里是初始化声明赋值一个a
  //a := []int{3, 4, 5}
  a := make([]int, 3)
  a[0] = 3
  a[1] = 4
  a[2] = 5
  test(a)
  fmt.Println(a)
  test2(a)
  fmt.Println(a)

  b := map[string]string{
    "a": "b",
  }
  test3(b)
  fmt.Println(b)
  test4(b)
  fmt.Println(b)
}

func test(a []int) {
  a[2] = 6
}

func test2(a []int) {
  //a = append(a, 9)
  a = []int{8, 93, 3, 11}
  fmt.Println("test2 a", a)
}

func test3(b map[string]string) {
  b["xx"] = "xxxx"
}

func test4(b map[string]string) {
  b = map[string]string{
    "888": "999",
  }
}

第一次：[3 4 6]   这里是直接修改a的值，修改第二个值，打印是返回的值
test2 a [8 93 3 11]    这里是在test2函数里面修改a的值，打印出来的
第二次：[3 4 6]    这里是test2函数执行之后返回的结果，a本身没有变化，这里可以看出a本身不是引用的，但是a里面的值的变量是有引用的
第一次：map[a:b xx:xxxx] 这里是map类型b的样例，第一次是修改或者追加key和value，打印返回的值是修改成功的
第二次：map[a:b xx:xxxx]   这里是第二次去本身函数改变，返回的b本身是不修改的，这里也同样证明b本身不是引用的，b的值是有引用的

好了，那么来了，如何对引用类型修改本身，那其实很简单就是让他们传地址到函数中，在函数中修改，函数执行完了，变量在函数中变化之后会在函数外也体现出来

type slice struct {
  array unsafe.Pointer
  len   int
  cap   int
}

type hmap struct {
  // Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
  // Make sure this stays in sync with the compiler's definition.
  count     int // # live cells == size of map.  Must be first (used by len() builtin)
  flags     uint8
  B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
  noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
  hash0     uint32 // hash seed

  buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
  oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
  nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)

  extra *mapextra // optional fields
}

import org.junit.Test;

public class Application {
    @Test
    public void main() {
        String[] str = {"xxx", "bbb"};
        System.out.println("初始化数据："+str[1]);
        test(str);
        System.out.println("第一次："+str[1]);
        test2(str);
        System.out.println("第二次："+str[1]);
    }

    public void test(String[] str) {
        str[1] = "2";
    }

    public void test2(String[] str) {
        str = new String[]{"5", "6"};
    }
}

初始化数据：bbb 初始化是bbb
第一次：2   修改函数里面的值，返回的是修改的值
第二次：2   这里是本str本身进行修改，修改完了之后，函数外之后执行没有变化。