集合([ ]、slice、map、Array、Map)

• java([ ]、Array、Map)
  java 的集合类型有三类：

  • [] : 且称它为定长单值数组

  • Array ：可以理解是一个定长数组的管理器，它实现了不定长数组

    根据不同的算法有ArrayList、Set、TreeSet 等等

  • Map : 是一个键值对的集合类型，它的值可以是基本数据类型也可以是自定义数据类型

    它的实现也有很多 HashMap、TresMap、LinkedHashMap 等等

public class ArrayTest {
    private static final Logger LOG = LoggerFactory.getLogger(ArrayTest.class);


    @Test
    public void process01(){
        // 这里定义了长度为4的定长数组，当取或放>4个值后会抛异常
        String[] arrBase= new String[4];
        arrBase[0] = "hello";
        LOG.info("len {},{}",arrBase.length,arrBase[0]);

        // 这里定义了一个默认长度为4的不定长数组，当然是可以放入>4个值的
        List<Integer> lst = new ArrayList<Integer>(4){{
            add(0);
            add(22);
            add(-1);
        }};
        LOG.info("arr len {},{}",lst.size(),lst.toString());
    }

    @Test
    public void process02(){
        // 这里定义了一个键值对集合
        Map<String,Object> hashMap = new HashMap<String,Object>(2){{
            put("a",1);
            put("b",2);
        }};
        LOG.info("map len {},{}",hashMap.size(),hashMap.toString());
    }
}

• go([ ]、slice、map)

go的集合有三种形式，其中数组与切片数组看似相似，其实对于内存分配有很大差异，一般实际使用后者，同时需要说明的是map也可使用make关键字
做集合优化。

go 的集合类型有三类,目前均无多算法实现：
- 数组
- 切片数组(slice)
- 键值对集合(map)

func main() {
    // 这里定义了一个不定长数组(这种描述可能不准确)
    var arr []int8
    arr = append(arr, 100)
    arr = append(arr, -1)
    fmt.Println(arr)
    // 这里使用slice 定义了一个长度为3，容量为3的数组
    arr2 := make([]string, 3, 3)
    arr2 = append(arr2, "hello")
    arr2[2] = "youth"
    //arr2 = append(arr2, "youth")
    // arr2 = append(arr2, "good")
    // arr2 = append(arr2, "morning")
    fmt.Println(cap(arr2), len(arr2), arr2)
}

继承,实现,组合（extend&interface&abstract)

• java

java 有继承extend和实现interface 之分，一个类只能单继承或者多实现，但不管是被继承还是被实现，他们的类型还是有差异的
(访问类型也是有差异的)

public class ExtendIntfTest {


}

 interface EntityA{
    void doSth01();
    // private doSth02();
}
class EntityB{
    public void doSth01(){

    }
}

public abstract class EntityC {

    public void doSth01(){
        // TODO
    }

    public void doSth02(){
        // TODO
    }
}

• go

go更偏向于过程，只给出了组合作为继承的一种实现，而且是通过结构体嵌套实现的，不说了还是看代码吧:

package main

import (
    "fmt"
)

type Base struct {
}

func (b *Base) ShowA() {
    fmt.Println("showA")
}
func (b *Base) ShowB() {
    fmt.Println("showB")
}

type Derived struct {
    Base
}

func (d *Derived) ShowB() {
    fmt.Println("Derived showB")
}

func main() {
    // 当 Derived 的结构体中包含Base时也就相当于继承了Base 的 ShowA() 方法
    d := Derived{}
    d.ShowA()
    d.ShowB()
}

包引入及管理(import、dep、module、maven)