Go言語での効率的な配列操作テクニック

この記事はで読むことができます。

Go言語（Golang）は、その簡潔さと効率性で知られるプログラミング言語です。配列は多くのプログラミング言語に共通する基本的なデータ構造ですが、Go言語では配列とそれを拡張したスライスという概念があります。この記事では、初心者の方々向けに、Go言語での配列の基本から、より柔軟なスライスの操作テクニックまでを段階的に解説します。

目次非表示

1. 配列の基本
- 配列の宣言と初期化
- 配列の要素へのアクセス
2. 配列の制限と課題
3. スライスの導入
- スライスの宣言と初期化
4. スライスの基本操作
5. 効率的なスライス操作テクニック
まとめ

1. 配列の基本

配列は、同じ型の要素を一定数格納できるデータ構造です。Go言語では、配列のサイズは宣言時に決定され、後から変更することはできません。

配列の宣言と初期化

Go言語での配列の宣言と初期化には、いくつかの方法があります。以下に、代表的な例を示します。

1.サイズを指定して配列を宣言する方法

この方法では、配列のサイズを明示的に指定します。初期値を指定しない場合、各要素はその型のゼロ値で初期化されます。

// 5つの整数を格納できる配列を宣言
var numbers [5]int
fmt.Println(numbers)  // Output: [0 0 0 0 0]

2.初期値を指定して配列を宣言する方法

配列を宣言する際に、同時に初期値を指定することができます。この方法では、配列のサイズは指定された要素の数によって決まります。

// 初期値を指定して配列を宣言
fruits := [3]string{"apple", "banana", "orange"}
fmt.Println(fruits)  // Output: [apple banana orange]

3.サイズを自動で決定する配列の宣言

初期値を指定する際に、サイズを ... と記述することで、コンパイラが自動的にサイズを決定します。

// サイズを自動で決定する配列の宣言
scores := [...]int{98, 95, 92, 88, 85}
fmt.Println(scores)  // Output: [98 95 92 88 85]
fmt.Println(len(scores))  // Output: 5

配列の要素へのアクセス

配列の要素には、インデックスを使ってアクセスします。インデックスは0から始まります。以下の例では、配列の要素にアクセスし、値を変更する方法を示しています。

fruits := [3]string{"apple", "banana", "orange"}
fmt.Println(fruits[0])  // Output: apple

// 配列の要素を変更
fruits[1] = "grape"
fmt.Println(fruits)  // Output: [apple grape orange]

この例では、fruits 配列の最初の要素（インデックス0）にアクセスし、その後2番目の要素（インデックス1）の値を “banana” から “grape” に変更しています。

2. 配列の制限と課題

配列は使いやすいデータ構造ですが、いくつかの制限があります。これらの制限を理解することは、後述するスライスの利点を理解する上で重要です。

2.1 サイズが固定されている

配列は宣言時にサイズが固定されるため、動的にサイズを変更することができません。これは、要素数が変動するデータを扱う際に不便です。

numbers := [3]int{1, 2, 3}
// 以下のコードはコンパイルエラーになります
// numbers[3] = 4

2.2 関数に渡す際の非効率性

大きな配列を関数に渡す際、その配列全体のコピーが作成されます。これは、メモリ使用量とパフォーマンスの面で非効率的です。

func printArray(arr [1000000]int) {
    // この関数は引数として渡された配列全体のコピーを受け取ります
    fmt.Println(arr[0])
}

bigArray := [1000000]int{}
printArray(bigArray)  // 大量のメモリコピーが発生

2.3 型の厳格性

Go言語では、異なるサイズの配列は互いに別の型として扱われます。これにより、異なるサイズの配列間で直接の代入や比較ができません。

arr1 := [3]int{1, 2, 3}
arr2 := [4]int{1, 2, 3, 4}
// 以下のコードはコンパイルエラーになります
// arr1 = arr2

これらの制限を克服するために、Go言語ではスライスという概念が導入されています。

3. スライスの導入

スライスは、配列を基にした、より柔軟なデータ構造です。スライスは動的なサイズを持ち、参照型として扱われます。これにより、配列の制限を克服し、より柔軟なデータ操作が可能になります。

スライスの宣言と初期化

スライスの宣言と初期化には、いくつかの方法があります。以下に主な方法を示します。

1. 空のスライスを宣言する方法

この方法では、要素を持たない空のスライスを作成します。

// 空のスライスを宣言
var numbers []int
fmt.Println(numbers)  // Output: []
fmt.Println(len(numbers))  // Output: 0

2. リテラルを使用して初期化する方法

配列と同様に、初期値を指定してスライスを作成できます。配列との違いは、サイズを指定しない点です。

// リテラルを使用して初期化
fruits := []string{"apple", "banana", "orange"}
fmt.Println(fruits)  // Output: [apple banana orange]
fmt.Println(len(fruits))  // Output: 3

3. make関数を使用して初期化する方法

make 関数を使用すると、指定した長さと容量でスライスを初期化できます。

// make関数を使用して初期化
scores := make([]int, 5)  // 長さ5のスライス
fmt.Println(scores)  // Output: [0 0 0 0 0]
fmt.Println(len(scores))  // Output: 5

// 長さと容量を別々に指定
numbers := make([]int, 3, 5)  // 長さ3、容量5のスライス
fmt.Println(numbers)  // Output: [0 0 0]
fmt.Println(len(numbers))  // Output: 3
fmt.Println(cap(numbers))  // Output: 5

4. スライスの基本操作

スライスは配列よりも柔軟に操作できます。以下に、スライスの基本的な操作方法を示します。

4.1 要素の追加

append 関数を使用して、スライスに要素を追加できます。これは、配列にはない重要な機能です。

// 初期スライス
fruits := []string{"apple", "banana"}
fmt.Println(fruits)  // Output: [apple banana]

// 1つの要素を追加
fruits = append(fruits, "orange")
fmt.Println(fruits)  // Output: [apple banana orange]

// 複数の要素を一度に追加
fruits = append(fruits, "grape", "mango")
fmt.Println(fruits)  // Output: [apple banana orange grape mango]

この例では、append 関数を使用して、まず “orange” を追加し、その後 “grape” と “mango” を同時に追加しています。append は新しいスライスを返すため、結果を元のスライス変数に代入する必要があります。

4.2 スライスのスライシング

スライスの一部を取り出すことを「スライシング」と呼びます。これにより、スライスの一部を簡単に抽出できます。

numbers := []int{0, 1, 2, 3, 4, 5}

// インデックス1から3まで（4は含まない）の要素を抽出
fmt.Println(numbers[1:4])  // Output: [1 2 3]

// 最初から3つの要素を抽出
fmt.Println(numbers[:3])   // Output: [0 1 2]

// インデックス3から最後までの要素を抽出
fmt.Println(numbers[3:])   // Output: [3 4 5]

// スライス全体をコピー
fmt.Println(numbers[:])    // Output: [0 1 2 3 4 5]

スライシングでは、[開始インデックス:終了インデックス] の形式を使用します。終了インデックスの要素は含まれないことに注意してください。

4.3 長さと容量

スライスには「長さ」と「容量」という2つの重要な属性があります。

長さ（length）：スライスに含まれる要素の数
容量（capacity）：スライスが参照する配列の要素数

以下の例で、長さと容量の概念を説明します。

// 長さ3、容量5のスライスを作成
numbers := make([]int, 3, 5)
fmt.Println(numbers)       // Output: [0 0 0]
fmt.Println(len(numbers))  // Output: 3
fmt.Println(cap(numbers))  // Output: 5

// スライスに要素を追加
numbers = append(numbers, 1, 2)
fmt.Println(numbers)       // Output: [0 0 0 1 2]
fmt.Println(len(numbers))  // Output: 5
fmt.Println(cap(numbers))  // Output: 5

// さらに要素を追加すると容量が自動的に増加
numbers = append(numbers, 3)
fmt.Println(numbers)       // Output: [0 0 0 1 2 3]
fmt.Println(len(numbers))  // Output: 6
fmt.Println(cap(numbers))  // Output: 10 (容量が自動的に増加)

この例では、初期状態で長さ3、容量5のスライスを作成しています。要素を追加していくと、長さが増加し、容量を超えた時点で自動的に新しい、より大きな配列が割り当てられます。

5. 効率的なスライス操作テクニック

スライスを効率的に操作するためのいくつかの重要なテクニックを紹介します。

5.1 事前に容量を確保する

要素を追加する際、スライスの容量が不足すると再割り当てが発生し、パフォーマンスに影響を与える可能性があります。事前に十分な容量を確保することで、この問題を回避できます。

// 非効率的な方法
var numbers []int
for i := 0; i < 10000; i++ {
    numbers = append(numbers, i)
}

// 効率的な方法
numbers := make([]int, 0, 10000)
for i := 0; i < 10000; i++ {
    numbers = append(numbers, i)
}

この例では、2つの方法を比較しています。2つ目の方法では、事前に10000の容量を確保しているため、追加操作中に再割り当てが発生しません。これにより、パフォーマンスが向上します。

5.2 スライスのコピー

copy 関数を使用してスライスをコピーできます。これは、スライスの一部を安全に複製したい場合に便利です。

// ソーススライス
src := []int{1, 2, 3}

// デスティネーションスライスを作成
dst := make([]int, len(src))

// srcの内容をdstにコピー
copied := copy(dst, src)

fmt.Println(dst)     // Output: [1 2 3]
fmt.Println(copied)  // Output: 3 (コピーされた要素の数)

この例では、src スライスの内容を dst スライスにコピーしています。copy 関数は、コピーされた要素の数を返します。

5.3 スライスの要素を削除する

Go言語には、スライスから要素を直接削除する組み込み関数はありません。しかし、スライシングと append を組み合わせることで、効率的に要素を削除できます。

numbers := []int{1, 2, 3, 4, 5}
i := 2 // 削除したい要素のインデックス

// iの位置の要素を削除
numbers = append(numbers[:i], numbers[i+1:]...)
fmt.Println(numbers)  // Output: [1 2 4 5]

この方法では、削除したい要素の前後のスライスを append 関数で結合しています。これにより、指定したインデックスの要素を効率的に削除できます。

5.4 スライスのフィルタリング

特定の条件に基づいてスライスの要素をフィルタリングする場合、新しいスライスを作成し、条件に合う要素だけを追加する方法が効率的です。以下に、偶数のみをフィルタリングする例を示します。

numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// 偶数のみをフィルタリング
evenNumbers := make([]int, 0, len(numbers))
for _, num := range numbers {
    if num%2 == 0 {
        evenNumbers = append(evenNumbers, num)
    }
}
fmt.Println(evenNumbers)  // Output: [2 4 6 8 10]

この例では、以下のステップでフィルタリングを行っています。

元のスライスと同じ容量を持つ新しいスライスを作成します。
元のスライスの各要素に対して条件をチェックします。
条件に合う要素のみを新しいスライスに追加します。

この方法により、メモリ効率良くフィルタリングを行うことができます。

5.5 スライスの反転

スライスの要素を逆順にする場合、インデックスを使って効率的に操作できます。以下に、スライスを反転する例を示します。

numbers := []int{1, 2, 3, 4, 5}

for i := 0; i < len(numbers)/2; i++ {
    j := len(numbers) - 1 - i
    numbers[i], numbers[j] = numbers[j], numbers[i]
}

fmt.Println(numbers)  // Output: [5 4 3 2 1]

この反転アルゴリズムは以下のように動作します。

スライスの前半を反復処理します。
各要素に対して、対応する後半の要素と位置を交換します。
スライスの中央に達したら処理を終了します。

この方法は、追加のメモリ割り当てを必要とせず、効率的にスライスを反転できます。

5.6 スライスのソート

Go言語の標準ライブラリ sort パッケージを使用すると、スライスを簡単にソートできます。以下に、整数スライスと文字列スライスをソートする例を示します。

import (
    "fmt"
    "sort"
)

func main() {
    // 整数スライスのソート
    numbers := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3}
    sort.Ints(numbers)
    fmt.Println(numbers)  // Output: [1 1 2 3 3 4 5 5 6 9]

    // 文字列スライスのソート
    fruits := []string{"banana", "apple", "orange", "grape"}
    sort.Strings(fruits)
    fmt.Println(fruits)  // Output: [apple banana grape orange]
}

sort パッケージは、さまざまなデータ型に対応したソート関数を提供しています。カスタムのソート条件を使用したい場合は、sort.Slice 関数を使用できます。

type Person struct {
    Name string
    Age  int
}

people := []Person{
    {"Alice", 25},
    {"Bob", 30},
    {"Charlie", 20},
}

sort.Slice(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})

fmt.Println(people)
// Output: [{Charlie 20} {Alice 25} {Bob 30}]

この例では、Person 構造体のスライスを年齢順にソートしています。