1. 首页
  2. 文章

java与Go的交流

u012885276 · · 2344 次点击 · · 开始浏览    
这是一个创建于 的文章，其中的信息可能已经有所发展或是发生改变。
第一次，站长亲自招 Gopher 了>>>
  1. 语句结束没有分号
  2. import支持导入多个（中间没有逗号）
    语法：import ("xx" "xx" "xx")
  3. 导出(类似于public等可被访问)：首字母大写的变量及方法是被导出的
  4. 声明变量：
    语法： 变量名:=值    var 变量名,变量名,...... 类型
  5. 函数：
    函数可以没有参数或接受多个参数，函数可以返回任意数量的返回值；当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略；

    函数可以返回多个“结果参数”，而不仅仅是一个值。它们可以像变量那样命名和使用。

    如果命名了返回值参数，一个没有参数的 return 语句，会将当前的值作为返回值返回。

    语法：func 方法名(参数列表)（返回值列表）{
              return 
    }
    new 的用法不同：
    语法：new(类等名称)
    可以将函数赋予变量（与javascript相同）
    t:=func........
    （`:=` 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始。）

  6. Go 的基本类型有Basic types

    bool

string
    int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
    byte // uint8 的别名
    rune // int32 的别名
// 代表一个Unicode码
    float32 float64
    complex64 complex128

  7. 常量的定义与变量类似，只不过使用 const 关键字。

    常量可以是字符、字符串、布尔或数字类型的值。
    语法：const Pi = 3.14
    一个未指定类型的常量由上下文来决定其类型。

  8. 循环

    Go 只有一种循环结构——`for` 循环。

    基本的 for 循环除了没有了 `( )` 之外（甚至强制不能使用它们），看起来跟 Java 中做的一样，而 `{ }` 是必须的。
    基于此可以省略分号：java 的 while 在 Go 中叫做 `for`
    如果省略了循环条件，循环就不会结束，因此可以用更简洁地形式表达死循环

  9. if 语句除了没有了 `( )` 之外（甚至强制不能使用它们），看起来跟 Java 中的一样，而 `{ }` 是必须的。 

    跟 for 一样，`if` 语句可以在条件之前执行一个简单的语句。由这个语句定义的变量的作用域仅在 if 和else 范围之内

    例子：
    package main

    import ( "fmt"     "math" ) 

    func pow(x, n, lim float64) float64 {

        if v := math.Pow(x, n); v < lim {

            return v

        } else{

    //       v可使用
        }

        return lim

    }

    func main() {

        fmt.Println(   pow(3, 2, 10), pow(3, 3, 20),  ) 

    }


  10. 结构：
    type用于声明 struct为结构的关键字（与java类似）
    例子：
    type Vertex struct {     X int     Y int }
    结构体字段使用点号来访问。

  11. 指针：
    Go 有指针，但是没有指针运算。

    结构体字段可以通过&结构体指针来访问。通过指针间接的访问是透明的。

    例子：
    func main() {

        p := Vertex{1, 2}

        q := &p

        q.X = 1e9

        fmt.Println(p)

    }

  12. 结构体文法：

    结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。

    使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

    特殊的前缀 & 构造了指向结构体的指针。
    例子：
    type Vertex struct {

        X, Y int

    }

    var (

        p = Vertex{1, 2} // 类型为 Vertex

        q = &Vertex{1, 2} // 类型为 *Vertex

        r = Vertex{X: 1} // Y:0 被省略

        s = Vertex{} // X:0 和 Y:0

    )

    func main() {

        fmt.Println(p, q, r, s)

    }

  13. slice：
    slice 指向一个数组，并且包含了长度信息。 
    例子：
    package main
    import "fmt" 
    func main() { 
        p := []int{2, 3, 5, 7, 11, 13} //数组的声明方式
        fmt.Println("p ==", p) 
        for i := 0; i < len(p); i++ { 
            fmt.Printf("p[%d] == %d\n", 
                i, p[i]) //输出指定格式字符串
        } 
    }

    对 slice 进行截取

    slice 可以重新切片，创建一个新的 slice 值指向相同的数组。

    表达式

    s[lo:hi]

    表示从 lo 到 hi-1 的 slice 元素，含两端。因此

    s[lo:lo]

    是空的，而

    s[lo:lo+1]

    有一个元素。
    例子：
    package main


    import "fmt"

    func main() {

        p := []int{2, 3, 5, 7, 11, 13}

        fmt.Println("p ==", p)

        fmt.Println("p[1:4] ==", p[1:4])

        // 省略下标代表从 0 开始

        fmt.Println("p[:3] ==", p[:3])

        // 省略上标代表到 len(s) 结束

        fmt.Println("p[4:] ==", p[4:])

    }

    slice 的零值是 `nil`。

    一个 nil 的 slice 的长度和容量是 0。

  14. 迭代：
    for 循环的 range 格式可以对 slice 或者 map 进行迭代循环。

    可以将值赋值给 _ 来忽略序号和值。

    如果只需要索引值，去掉“, value”的部分即可。

    例子：
    package main
    import "fmt" 
    var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} 
    func main() { 
        for i, v := range pow { 
            fmt.Printf("2**%d = %d\n", i, v) 
        } 
    //只要索引
    for i := range pow { 
            fmt.Print(i) 
        }  
    }
  15. Map：

    map 映射键到值。

    map 在使用之前必须用 make 而不是 new 来创建；值为 nil 的 map 是空的，并且不能赋值。
    与java区别：

    声明方式：var声明 m变量名 map[stringkey的类型]Vertexvalue的类型 =make生成对象的方法(map[string]Vertex);                        

    例子：
    package main

    import "fmt"

    type Vertex struct {

        Lat, Long float64

    }

    var m map[string]Vertex

    func main() {

        m = make(map[string]Vertex)

        m["Bell Labs"] = Vertex{

            40.68433, -74.39967,

        }

        fmt.Println(m["Bell Labs"])

    }
    map 的文法跟结构体文法相似，不过必须有键名。
    如果顶级的类型只有类型名的话，可以在文法的元素中省略键名？应该是vale的类名。 
    例子：
    package main

    import "fmt"

    type Vertex struct {

        Lat, Long float64

    }

    var m = map[string]Vertex{

        "Bell Labs": Vertex{

            40.68433, -74.39967,

        },

        "Google": Vertex{

            37.42202, -122.08408,

        },

    }

    func main() {

        fmt.Println(m)

    }

    修改 map

    在 map m 中插入或修改一个元素：

    m[key] = elem

    获得元素：

    elem = m[key]

    删除元素：

    delete(m, key)

    通过双赋值检测某个键存在：

    elem, ok = m[key]

    如果 key 在 m 中，`ok` 为 true 。否则， ok 为 `false`，并且 elem 是 map 的元素类型的零值。

    同样的，当从 map 中读取某个不存在的键时，结果是 map 的元素类型的零值

  16. switch：

    你可能已经猜到 switch 可能的形式了。

    switch 的条件从上到下的执行，当匹配成功的时候停止。

    除非使用 fallthrough 语句作为结尾，否则 case 部分会自动终止。（加上fallthrough会执行之后的一个的内容）

    例子：
    package main
    import ( 
        "fmt" 
        "runtime" 
    ) 
    func main() { 
        fmt.Print("Go runs on ") 
            //runtime.GOOS获取当前运行的系统 
        switch os := runtime.GOOS; os { 
        case "darwin": 
            fmt.Println("OS X.") 
        case "linux": 
            fmt.Println("Linux.") 
        default: 
            // freebsd, openbsd, 
            // plan9, windows... 
            fmt.Printf("%s.", os) 
        } 
                }

    没有条件的 switch 同 `switch true` 一样。

    这一构造使得可以用更清晰的形式来编写长的 if-then-else 链。

  17. 方法：

    Go 没有类。然而，仍然可以在结构体类型上定义方法。

    方法接收者 出现在 func 关键字和方法名之间的参数中。

    示例：

    package main

    import (

        "fmt"

        "math"

    )

    type Vertex struct {

        X, Y float64

    }

    func (v *Vertex) Abs() float64 {

        return math.Sqrt(v.X*v.X + v.Y*v.Y)

    }

    func main() {

        v := &Vertex{3, 4}

        fmt.Println(v.Abs())

    }

    事实上，可以对包中的 任意 类型定义任意方法，而不仅仅是针对结构体。

    不能对来自其他包的类型或基础类型定义方法。

    方法可以与命名类型或命名类型的指针关联。

    刚刚看到的两个 Abs 方法。一个是在 *Vertex 指针类型上，而另一个在MyFloat 值类型上。 有两个原因需要使用指针接收者。首先避免在每个方法调用中拷贝值（如果值类型是大的结构体的话会更有效率）。其次，方法可以修改接收者指向的值。

    示例：
    package main

    import (

        "fmt"

        "math"

    )

    type Vertex struct {

        X, Y float64

    }

    func (v *Vertex) Scale(f float64) {

        v.X = v.X * f

        v.Y = v.Y * f

    }

    func (v *Vertex) Abs() float64 {

        return math.Sqrt(v.X*v.X + v.Y*v.Y)

    }

    func main() {

        v := &Vertex{3, 4}

        v.Scale(5)

        fmt.Println(v, v.Abs())

    }

    尝试修改 Abs 的定义，同时 Scale 方法使用 Vertex 代替 *Vertex 作为接收者。（这时是复制了

    Vertex 的值，并不会改变原有的Vertex 值）

    当 v 是 Vertex 的时候 Scale 方法没有任何作用。`Scale` 修改 `v`。当 v 是一个值（非指针），方法看到的是 Vertex 的副本，并且无法修改原始值。

    Abs 的工作方式是一样的。只不过，仅仅读取 `v`。所以读取的是原始值（通过指针）还是那个值的副本并没有关系。

  18. 接口定义：

    接口类型是由一组方法定义的集合。

    接口类型的值可以存放实现这些方法的任何值。
    示例：
    package main

    import (

        "fmt"

        "math"

    )

    type Abser interface {

        Abs() float64

    }

    func main() {

        var a Abser

        f := MyFloat(-math.Sqrt2)

        //v := Vertex{3, 4}

        a = f // a MyFloat 实现了 Abser

        //a = &v // a *Vertex 实现了 Abser

        //a = v // a Vertex, 没有实现 Abser

        fmt.Println(a.Abs())

    }

    type MyFloat float64

    func (f MyFloat) Abs() float64 {

        if f < 0 {

            return float64(-f)

        }

        return float64(f)

    }

    type Vertex struct {

        X, Y float64

    }

    func (v *Vertex) Abs() float64 {

        return math.Sqrt(v.X*v.X + v.Y*v.Y)

    }

    ？？？隐式接口

    类型通过实现那些方法来实现接口。

    没有显式声明的必要。

    隐式接口解藕了实现接口的包和定义接口的包：互不依赖。

    因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

    包 io 定义了 Reader 和 `Writer`；其实不一定要这么做

  19. 错误：
    type error interface {
    Error() string
}
              当用 fmt 包的多种不同的打印函数输出一个 error 时，会自动的调用该方法。
              示例：
              package main
    import (
        "fmt"
        "time"
    )
    type MyError struct {
        When time.Time
        What string
    }
    func (e *MyError) Error() string {
        return fmt.Sprintf("at %v, %s",
            e.When, e.What)
    }
    func run() error {
        return &MyError{
            time.Now(),
            "it didn't work",
        }
    }
    func main() {
        if err := run(); err != nil {
            fmt.Println(err)
        }
    }
  20. Web 服务器：

    包 http 通过任何实现了 http.Handler 的值来响应 HTTP 请求：

    package http
    type Handler interface {
    ServeHTTP(w ResponseWriter, r *Request)
}

    在这个例子中，类型 Hello 实现了 `http.Handler`。

    访问 http://localhost:4000/ 会看到来自程序的问候。
    示例：
    package main

    import (

        "fmt"

        "net/http"

    )

    type Hello struct{}

    func (h Hello) ServeHTTP(

        w http.ResponseWriter,

        r *http.Request) {

        fmt.Fprint(w, "Hello!")

    }

    func main() {

        var h Hello

        http.ListenAndServe("localhost:4000", h)

    }

  21. 处理文件：

    1、图片（1）

    Package image 定义了 Image 接口：

    package image
    type Image interface {
    ColorModel() color.Model
Bounds() Rectangle
At(x, y int) color.Color
    }

    （参阅文档了解全部信息。）

    同样，`color.Color` 和 color.Model 也是接口，但是通常因为直接使用预定义的实现 image.RGBAColor 和 image.RGBAColorModel 而被忽视了。

    示例：
    package main

    import (

        "fmt"

        "image"

    )

    func main() {

        m := image.NewRGBA(image.Rect(0, 0, 100, 100))

        fmt.Println(m.Bounds())

        fmt.Println(m.At(0, 0).RGBA())

    }

    1. 并发机制：

    线程 

    1、goroutine

    1. goroutine 是由 Go 运行时环境管理的轻量级线程。

      go f(x, y, z)

      开启一个新的 goroutine 执行

      f(x, y, z)

      f ， x ， y 和 z 是当前 goroutine 中定义的，但是在新的 goroutine 中运行 `f`。

      goroutine 在相同的地址空间中运行，因此访问共享内存必须进行同步。sync 提供了这种可能，不过在 Go 中并不经常用到，因为有其他的办法。（在接下来的内容中会涉及到。）

      package main

      import (

          "fmt"

          "time"

      )

      func say(s string) {

          for i := 0; i < 5; i++ {

              time.Sleep(100 * time.Millisecond)

              fmt.Println(s)

          }

      }

      func main() {

          go say("world")

          say("hello")

      }

    2、channel

    1. channel 是有类型的管道，可以用 channel 操作符 <- 对其发送或者接收值。

      ch <- v    // 将 v 送入 channel ch。
v := <-ch  // 从 ch 接收，并且赋值给 v。

      （“箭头”就是数据流的方向。）

      和 map 与 slice 一样，channel 使用前必须创建：

      ch := make(chan int)

      默认情况下，在另一端准备好之前，发送和接收都会阻塞。这使得 goroutine 可以在没有明确的锁或竞态变量的情况下进行同步。
      package main

      import "fmt"

      func sum(a []int, c chan int) {

          sum := 0

          for _, v := range a {

              sum += v

          }

          c <- sum // 将和送入 c

      }

      func main() {

          a := []int{7, 2, 8, -9, 4, 0}

          c := make(chan int)

          go sum(a[:len(a)/2], c)

          go sum(a[len(a)/2:], c)

          x, y := <-c, <-c // 从 c 中获取

          fmt.Println(x, y, x+y)

      }

      3、缓冲 channel

    channel 可以是 _带缓冲的_。为 make 提供第二个参数作为缓冲长度来初始化一个缓冲 channel：

    ch := make(chan int, 100)

    向缓冲 channel 发送数据的时候，只有在缓冲区满的时候才会阻塞。当缓冲区清空的时候接受阻塞。

    修改例子使得缓冲区被填满，然后看看会发生什么。
    package main

    import "fmt"

    func main() {

        c := make(chan int, 2)

        c <- 1

        c <- 2

        fmt.Println(<-c)

        fmt.Println(<-c)

    }

  23. 控制线程范围

    1、range 和 close

    发送者可以 close 一个 channel 来表示再没有值会被发送了。接收者可以通过赋值语句的第二参数来测试 channel 是否被关闭：当没有值可以接收并且 channel 已经被关闭，那么经过

    v, ok := <-ch

    之后 ok 会被设置为 `false`。

    循环 `for i := range c` 会不断从 channel 接收值，直到它被关闭。

    注意： 只有发送者才能关闭 channel，而不是接收者。向一个已经关闭的 channel 发送数据会引起 panic。 还要注意： channel 与文件不同；通常情况下无需关闭它们。只有在需要告诉接收者没有更多的数据的时候才有必要进行关闭，例如中断一个 `range`。
    package main

    import (

        "fmt"

    )

    func fibonacci(n int, c chan int) {

        x, y := 0, 1

        for i := 0; i < n; i++ {

            c <- x

            x, y = y, x+y

        }

        close(c)

    }

    func main() {

        c := make(chan int, 10)

        go fibonacci(cap(c), c)

        for i := range c {

            fmt.Println(i)

        }

    }

    2、select

    select 语句使得一个 goroutine 在多个通讯操作上等待。

    select 会阻塞，直到条件分支中的某个可以继续执行，这时就会执行那个条件分支。当多个都准备好的时候，会随机选择一个。

    package main

    import "fmt"

    func fibonacci(c, quit chan int) {

        x, y := 0, 1

        for {

            select {

            case c <- x:

                x, y = y, x+y

            case <-quit:

                fmt.Println("quit")

                return

            }

        }

    }

    func main() {

        c := make(chan int)

        quit := make(chan int)

        go func() {

            for i := 0; i < 10; i++ {

                fmt.Println(<-c)

            }

            quit <- 0

        }()

        fibonacci(c, quit)

    }

    3、默认select

    当 select 中的其他条件分支都没有准备好的时候，`default` 分支会被执行。

    为了非阻塞的发送或者接收，可使用 default 分支：

    select {
case i := <-c:
    // 使用 i
default:
    // 从 c 读取会阻塞
    }


    

package main

import (

    "fmt"

    "time"

)

func main() {

    tick := time.Tick(100 * time.Millisecond)

    boom := time.After(500 * time.Millisecond)

    for {

        select {

        case <-tick:

            fmt.Println("tick.")

        case <-boom:

            fmt.Println("BOOM!")

            return

        default:

            fmt.Println(" .")

            time.Sleep(50 * time.Millisecond)

        }

    }

}

使用并发 (1/2)

1、练习：Web 爬虫

在这个练习中，将会使用 Go 的并发特性来并行执行 web 爬虫。

修改 Crawl 函数来并行的抓取 URLs，并且保证不重复。
package main

import (

    "fmt"

)

type Fetcher interface {

    // Fetch 返回 URL 的 body 内容，并且将在这个页面上找到的 URL 放到一个 slice 中。

    Fetch(url string) (body string, urls []string, err error)

}

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。

func Crawl(url string, depth int, fetcher Fetcher) {

    // TODO: 并行的抓取 URL。

    // TODO: 不重复抓取页面。

        // 下面并没有实现上面两种情况：

    if depth <= 0 {

        return

    }

    body, urls, err := fetcher.Fetch(url)

    if err != nil {

        fmt.Println(err)

        return

    }

    fmt.Printf("found: %s %q\n", url, body)

    for _, u := range urls {

        Crawl(u, depth-1, fetcher)

    }

    return

}

func main() {

    Crawl("http://golang.org/", 4, fetcher)

}

// fakeFetcher 是返回若干结果的 Fetcher。

type fakeFetcher map[string]*fakeResult

type fakeResult struct {

    body string

    urls []string

}

func (f *fakeFetcher) Fetch(url string) (string, []string, error) {

    if res, ok := (*f)[url]; ok {

        return res.body, res.urls, nil

    }

    return "", nil, fmt.Errorf("not found: %s", url)

}

// fetcher 是填充后的 fakeFetcher。

var fetcher = &fakeFetcher{

    "http://golang.org/": &fakeResult{

        "The Go Programming Language",

        []string{

            "http://golang.org/pkg/",

            "http://golang.org/cmd/",

        },

    },

    "http://golang.org/pkg/": &fakeResult{

        "Packages",

        []string{

            "http://golang.org/",

            "http://golang.org/cmd/",

            "http://golang.org/pkg/fmt/",

            "http://golang.org/pkg/os/",

        },

    },

    "http://golang.org/pkg/fmt/": &fakeResult{

        "Package fmt",

        []string{

            "http://golang.org/",

            "http://golang.org/pkg/",

        },

    },

    "http://golang.org/pkg/os/": &fakeResult{

        "Package os",

        []string{

            "http://golang.org/",

            "http://golang.org/pkg/",

        },

    },

}

2、练习：等价二叉树

1. 实现 Walk 函数。

2. 测试 Walk 函数。

函数 tree.New(k) 构造了一个随机结构的二叉树，保存了值 `k`，`2k`，`3k`，...，`10k`。 创建一个新的 channel ch 并且对其进行步进：

go Walk(tree.New(1), ch)

然后从 channel 中读取并且打印 10 个值。应当是值 1，2，3，...，10。

3. 用 Walk 实现 Same 函数来检测是否 t1 和 t2 存储了相同的值。

4. 测试 Same 函数。

`Same(tree.New(1), tree.New(1))` 应当返回 true，而 `Same(tree.New(1), tree.New(2))` 应当返回 false。

package main

import "code.google.com/p/go-tour/tree"

// Walk 步进 tree t 将所有的值从 tree 发送到 channel ch。

func Walk(t *tree.Tree, ch chan int)

// Same 检测树 t1 和 t2 是否含有相同的值。

func Same(t1, t2 *tree.Tree) bool

func main() {

}

有疑问加站长微信联系（非本文作者）

本文来自：CSDN博客

感谢作者：u012885276

查看原文：java与Go的交流

入群交流（和以上内容无关）：加入Go大咖交流群，或添加微信：liuxiaoyan-s 备注：入群；或加QQ群：692541889

2344 次点击  
加入收藏 微博
赞
收入我的专栏
上一篇：golang在windows平台使用zmq
下一篇：(1)Go lang --认识和安装
  • http
  • channel
  • 函数
  • 变量
    0 回复
    暂无回复
    添加一条新回复 （您需要 登录 后才能回复 没有账号 ？）
    • 请尽量让自己的回复能够对别人有帮助
    • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
    • 支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
    • 图片支持拖拽、截图粘贴等方式上传

    用户登录

    Go今日面试题

     今日阅读排行

      加载中

     一周阅读排行

      加载中

      关注我

    • 扫码关注领全套学习资料 关注微信公众号
    • 加入 QQ 群：
      • 192706294（已满）
      • 731990104（已满）
      • 798786647（已满）
      • 729884609（已满）
      • 977810755（已满）
      • 815126783（已满）
      • 812540095（已满）
      • 1006366459（已满）
      • 692541889

    • 关注微信公众号
    • 加入微信群：liuxiaoyan-s，备注入群
    • 也欢迎加入知识星球 Go粉丝们（免费）