Go言語の配列（スライス）結合について解説

package main
import "fmt"
func main() {
	// スライスのリテラル初期化
	numbers := []int{1, 2, 3, 4, 5} // 数字が格納されたスライス
	fmt.Println("初期化されたスライス:", numbers)
	// make関数を用いた初期化
	// 第一引数は型、第二引数は長さ、第三引数は容量
	dynamicSlice := make([]string, 3, 5)
	// 初期値は空文字列
	dynamicSlice[0] = "A"
	dynamicSlice[1] = "B"
	dynamicSlice[2] = "C"
	fmt.Println("make関数で初期化されたスライス:", dynamicSlice)
}

初期化されたスライス: [1 2 3 4 5]
make関数で初期化されたスライス: [A B C]

package main
import "fmt"
func main() {
	// 初期容量が2のスライスを作成
	slice := make([]int, 0, 2)
	fmt.Printf("初期状態: len=%d, cap=%d\n", len(slice), cap(slice))
	// 要素を順次追加し、容量の変化を確認
	for i := 1; i <= 5; i++ {
		slice = append(slice, i)
		fmt.Printf("追加後: len=%d, cap=%d\n", len(slice), cap(slice))
	}
}

初期状態: len=0, cap=2
追加後: len=1, cap=2
追加後: len=2, cap=2
追加後: len=3, cap=4
追加後: len=4, cap=4
追加後: len=5, cap=8

package main
import "fmt"
func main() {
	a := []int{1, 2, 3}    // 1つ目のスライス
	b := []int{4, 5, 6}    // 2つ目のスライス
	// append関数を用いてスライス結合
	joined := append(a, b...)
	fmt.Println("結合結果:", joined)
}

結合結果: [1 2 3 4 5 6]

package main
import "fmt"
func main() {
	a := []int{1, 2}    // 最初のスライス
	b := []int{3, 4}    // 2番目のスライス
	c := []int{5, 6}    // 3番目のスライス
	// 3つのスライスを連結
	combined := append(a, append(b, c...)...)
	fmt.Println("連結結果:", combined)
}

連結結果: [1 2 3 4 5 6]

package main
import "fmt"
func main() {
	slice1 := []int{1, 2}
	slice2 := []int{3, 4, 5}
	slice3 := []int{6, 7}
	// 合計要素数を計算
	totalLen := len(slice1) + len(slice2) + len(slice3)
	combined := make([]int, 0, totalLen)
	// 結合処理
	combined = append(combined, slice1...)
	combined = append(combined, slice2...)
	combined = append(combined, slice3...)
	fmt.Println("最適化された結合結果:", combined)
}

最適化された結合結果: [1 2 3 4 5 6 7]

package main
import "fmt"
func main() {
	// 例として3つの大きめのスライスを用意
	parts := [][]int{
		{1, 2, 3, 4, 5},
		{6, 7, 8, 9, 10},
		{11, 12, 13, 14, 15},
	}
	// 総要素数を計算
	totalLen := 0
	for _, part := range parts {
		totalLen += len(part)
	}
	// 事前容量確保
	finalSlice := make([]int, 0, totalLen)
	for _, part := range parts {
		finalSlice = append(finalSlice, part...)
	}
	fmt.Println("大規模データの結合結果:", finalSlice)
}

大規模データの結合結果: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]

package main
import "fmt"
// chunkSlice は指定されたチャンクサイズでスライスを分割する関数
func chunkSlice(data []int, chunkSize int) [][]int {
	var chunks [][]int
	for i := 0; i < len(data); i += chunkSize {
		end := i + chunkSize
		if end > len(data) {
			end = len(data)
		}
		chunks = append(chunks, data[i:end])
	}
	return chunks
}
func main() {
	// サンプルデータ(大きなスライス)
	data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
	// チャンクサイズを指定
	chunks := chunkSlice(data, 5)
	// 分割結果を表示
	fmt.Println("チャンク分割結果:")
	for idx, chunk := range chunks {
		fmt.Printf("チャンク%d: %v\n", idx+1, chunk)
	}
	// 各チャンクごとに部分結合し、最終的に全体を結合
	var finalResult []int
	for _, chunk := range chunks {
		finalResult = append(finalResult, chunk...)
	}
	fmt.Println("チャンクを結合した最終結果:", finalResult)
}

チャンク分割結果:
チャンク1: [1 2 3 4 5]
チャンク2: [6 7 8 9 10]
チャンク3: [11 12 13 14 15]
チャンクを結合した最終結果: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]

package main
import "fmt"
func main() {
	// 初期スライスの定義
	a := []int{1, 2, 3}
	b := []int{4, 5, 6}
	// 結合前の情報を表示
	fmt.Printf("スライスa: len=%d, cap=%d\n", len(a), cap(a))
	fmt.Printf("スライスb: len=%d, cap=%d\n", len(b), cap(b))
	// append関数で結合
	joined := append(a, b...)
	fmt.Printf("結合後のスライス: len=%d, cap=%d\n", len(joined), cap(joined))
}

スライスa: len=3, cap=3
スライスb: len=3, cap=3
結合後のスライス: len=6, cap=6～9  // capの値は再割り当てにより異なる場合がある

package main
import (
	"reflect"
	"testing"
)
func TestJoinSlices(t *testing.T) {
	a := []int{1, 2, 3}
	b := []int{4, 5, 6}
	result := append(a, b...)
	expected := []int{1, 2, 3, 4, 5, 6}
	if !reflect.DeepEqual(result, expected) {
		t.Errorf("期待値 %v と結果 %v が一致しません", expected, result)
	}
}