参考にしていただければと思う。

Javaの配列に値を代入する

配列に値を代入するとは、指定された配列の要素に指定された値をコピーすることになる。

変数へ値を代入するのと同じように代入演算子と呼ばれる「＝」を用いる。また、値を代入する要素の場所はインデックスで指定する。

一次元配列に値を代入する

配列には次元がある。まず一番に解説したいのは簡単な一次元配列である。一次元配列は配列の要素を一組の「[ ]」の中のインデックスで指定する。このインデックスで指定された要素に「＝」を使って値を代入する。

その書き方の基本は簡単だ。

配列変数名[インデックス] = 値;

配列に値を代入する例を示す。要素を4つ持つ配列を作ると、インデックスは0から3になる。array[0]からarray[4]に1から5までの値を代入する。

インデックスは0から始まるので注意が必要だ。代入する時についうっかり4番目の要素なので、インデックスを範囲外の4に指定しまうことがある。これはエラーになる。

では、実際のプログラムを見てみよう。

サンプルプログラム

このサンプルプログラムは一次元配列に値を代入し、その値を表示している。また、範囲外のインデックスを指定してエラー（例外）を発生させている。

import java.util.Arrays;

public class SingleDimensionArrayAssignment {
    public static void main(String[] args) {
        int[] array;//[1]
        array = new int[4];//[2]
        array[0] = 1;//[3]
        array[1] = 2;//[4]
        array[2] = 3;//[5]
        array[3] = 4;//[6]
        System.out.println("[7] " + Arrays.toString(array));

        try {//[8]
            array[4] = 5;//[9]
        } catch (ArrayIndexOutOfBoundsException exception) {//[10]
            System.out.println("[11] ArrayIndexOutOfBoundsException occurs.");
        }
    }
}

実行結果

[7] [1, 2, 3, 4]
[11] ArrayIndexOutOfBoundsException occurs.

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

• [1] int型の配列変数arrayを宣言する。
• [2] 要素数4の配列arrayを作る。
• [3]-[6] 配列の各要素に1から4を代入する。
• [7] 配列arrayの全ての要素を表示する。
• [8]-[9] 配列arrayのインデックス4に5を代入する。
• [10]-[11] 例外が発生したことを表示する。

このプログラムでは意図的にエラーとなる値を[8]-[9]で代入しているため、エラーが発生した際の処理を[10]-[11]で記述している。この処理（try-catch）の書き方についてはこちらの解説記事を併せて参照頂きたい。

Javaの多次元配列に値を代入する

次に、多次元配列である。その中の二次元配列は、配列の要素を二組の「[ ][ ]」の中のそれぞれインデックスで指定する。このインデックスで指定された要素に「＝」を使って代入する。

その書き方の基本は簡単だ。

配列変数名[インデックス1] [インデックス2] = 値;

さらに、次元が三次元、四次元と増えると「[ ]」の数が次元に応じて増える。

配列変数名[インデックス1] [インデックス2]・・・[ インデックスn] = 値;

配列に値を代入する例を示す。4 x 5の要素を持つ配列を作ると、インデックスが0から始まるので最初の「インデックス1」は0から3になる。続く「インデックス2」は0から4になる。

この配列のarray[2][3]に100を代入する。

サンプルプログラム

このサンプルプログラムは、二次元配列に値を代入し代入された値を表示している。

import java.util.Arrays;

public class TwoDimensionArrayAssignment {
    public static void main(String[] args) {
        int[][] array;//[1]
        array = new int[4][5];//[2]
        array[2][0] = 0;//[3]
        array[2][1] = 0;//[4]
        array[2][2] = 0;//[5]
        array[2][3] = 100;//[6]
        array[2][4] = 0;//[7]
        System.out.println("[8] " + Arrays.toString(array[2]));
    }
}

実行結果

[7] [0, 0, 0, 100, 0]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

• [1] 配列変数arrayを宣言する。
• [2] 配列arrayを最初の要素数を4、次の要素数を5で生成する。
• [3]-[7] 配列array[2][0]から[2][4]に値を代入する。この時、array[2][3]にだけ100を代入し、それ以外は0を代入する。
• [8] 配列array[2]の要素をすべて表示する。

まとめ

このページではJava配列の代入方法についてお伝えしてきた。特に初心者の方には、参考にしていただければ幸いだ。

このページではリストと配列の変換方法についてお伝えした。

リストから配列に変換する方法

リスト（List）から配列に変換を行うためには、変換のために準備されたメソッドがあるので、その使い方を理解しておく必要がある。そのメソッドとはtoArrayである。Listインタフェースが実装されたクラスであればこのメソッドを使うことができる。ここでは、Listインタフェースが実装されたクラスのオブジェクトのことをリストと呼ぶ。

ArrayListクラスやLinkedArrayクラスなどは、Listインタフェースが実装された代表的なクラスである。

書き方の基本は簡単だ。

配列変数名[] = リスト.toArray();

メソッド

toArray()

では、実際のコードを見てみよう。

サンプルプログラム

このプログラムがtoArrayメソッドを使ったサンプルプログラムだ。Listインタフェースを実装したArrayListクラスのオブジェクトに要素を追加し、その後オブジェクトに追加された要素をすべて配列に変換している。

import java.util.ArrayList;
import java.util.List;

public class ListToArray {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();//[1]
        list.add("りんご");//[2]
        list.add("みかん");//[3]
        list.add("もも");//[4]
        Object[] objects = list.toArray();//[5]
        for (Object object : objects) {//[6]
            System.out.println("[7] 要素 :" + (String)object);
        }
    }
}

実行結果

[7] 要素 :りんご
[7] 要素 :みかん
[7] 要素 :もも

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] ArrayListクラスのオブジェクトlistを生成する。
• [2]-[4] 文字列「りんご」「みかん」「もも」をlistに追加する。
• [5] オブジェクトlistのtoArrayメソッドを呼び出して、リストを配列objectsに変換する。
• [6][7] 配列：objectsのすべての要素を表示する

配列をリストに変換する方法

配列からリスト（List）に変換を行うためにも、準備されたメソッドがある。この変換のためには、クラスメソッドjava.util.Arrays.asList()が準備されている。配列であれば、このメソッドを使うことができる。

書き方の基本は簡単だ。

リスト = Arrays.asList(配列変数名);

このメソッドの詳細も見ておこう。

メソッド

Arrays.asList(T... a)

メソッドの内容を次に示すが、注意点がある。それは、リストが固定長であることだ。つまり、配列と同じように追加できない。その代わり、書き込んだ値が配列にも反映される。

では、実際のコードを見てみよう。

サンプルプログラム

このプログラムがArrays.asList()メソッドを使ったサンプルプログラムだ。要素を初期値として代入した配列からリストに変換を行っている。

import java.util.Arrays;
import java.util.List;

public class ArrayToList {
    public static void main(String[] args) {
        String[] strings = {"りんご", "もも", "みかん"};//[1]
        List list = Arrays.asList(strings);//[2]
        for (Object string : list) {//[3]
            System.out.println("[4] 要素 :" + (String) string);
        }
    }
}

実行結果

[4] 要素 :りんご
[4] 要素 :もも
[4] 要素 :みかん

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 文字列の配列stringsを宣言し、初期値を代入する。
• [2] Arrays.asListクラスメソッドを使って、配列をリストに変換する。
• [3]-[4] リストの要素をすべて表示する

変換したリストの注意点

前のセクションで配列をリストに変換した時の注意点として次の二つの点をあげた。

• リストが固定長であり、配列と同じように追加できない。
• 書き込んだ値が配列にも反映される。

この点を実際のコードから確認しておこう。リストに要素（「かき」）を次のように追加する。

List list = Arrays.asList(strings);

list.add("かき");

このコードが実行されると、例外が発生する。

Exception in thread "main" java.lang.UnsupportedOperationException
                at java.util.AbstractList.add(AbstractList.java:148)
                at java.util.AbstractList.add(AbstractList.java:108)
                at article.arrayconversion.ArrayToList.main(ArrayToList.java:10)

この例外を回避するためには、リストを追加可能な別のクラスに変換する必要がある。例えばArrayListクラスに変換することができる。

List<String> arrayList = new ArrayList<String>(list);

サンプルプログラム

このプログラムは、リストを追加可能な別のクラス（ArrayList）のオブジェクトに変換する方法を示している。また、リストの値を変更すると配列にその変更が反映されるが、ArrayListのオブジェクトには反映されないことを示している。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListToArrayList {
    public static void main(String[] args) {
        String[] strings = {"りんご", "もも", "みかん"};//[1]
        List<String> list = Arrays.asList(strings);//[2]
        List<String> arrayList = new ArrayList<String>(list);//[3]
        list.set(0, "いちご");//[4]
        arrayList.add("かき");//[5]
        for (String string : strings) {//[6]
            System.out.println("[7]" + (String) string);
        }
        System.out.println("");
        for (String string : arrayList) {//[8]
            System.out.println("[9]" + (String) string);
        }
    }
}

実行結果

[7]いちご
[7]もも
[7]みかん

[9]りんご
[9]もも
[9]みかん
[9]かき

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 文字列の配列stringsを宣言し、初期値を代入する。
• [2] Arrays.asListクラスメソッドを使って、配列をリストに変換する。
• [3] リストをArrayListクラスのオブジェクトに変換する。
• [4] リストの最初の要素を「いちご」に置換する。
• [5] オブジェクトarrayListに「かき」を追加する。
• [6]-[7] stringsの要素をすべて表示する
• [8]-[9] arrayListの要素をすべて表示する

まとめ

このページではJavaの配列とリストの変換についてまとめてお伝えをしてきた。

サンプルコードもつけているため、参考にしていただければ幸いだ。

このページではJavaのListと配列の違い、加えてListの使い方についてお伝えした。参考にしていただければと思う。

リスト（List）とは

Javaのリスト（List）とは、重複した要素を含むことができる順序の付けられたコレクションだ。

追加や削除が行われてもデータがきちんと整理されて、順番に並べられるという意味になる。

このため、ユーザーはインデックスによって要素を挿入したり要素にアクセスしたりする位置を自由に変更することができる。

また、リストはセット（Set）とは違い、重複する要素を持つことを許し、複数のnull要素を持つこともできる。

リスト（List）インターフェース

Javaでは、リストを扱うためにリストインターフェースが定義されている。この後、リストインターフェースをListと呼ぶことにする。このListは、Collection（コレクション）をルーツとしてそこから枝分かれしたインターフェースである。

Listと配列の違い

Listは、持っている特長が配列に非常によく似ている。しかし、違いもあるので実際のコードからひとつひとつ確かめてみよう。

生成

最初に、両方とも要素を入れるための入れ物を生成する。このときどちらも入れ物の中にどんな型の要素を入れるかを定義する。

この点は同じだが、配列だけは入れ物の大きさを決めなければならない。一度配列の大きさを決めると、それ以後変更できない。コードはこうなる。

String[] list = new String[3];//[1]

一方、Listは要素の大きさは可変である。

List<String> list = new ArrayList<String>();

追加・削除・検索

配列は固定の大きさなので、追加・削除・検索はできない。しかし、Listは可変であるので、要素をどんどん追加できるし、削除もできる。

Listの要素である文字列「ABC」を追加して、検索し削除するコードはこうなる。

list.add("ABC");
int index = list.indexOf("ABC");
list.remove(index);

取得・置換

配列もListもインデックスを指定して、要素を取得し置換することができる。indexが指す要素を取得しまた置換する配列のコードはこうなる。

value = list[index];
list[index] = "DEF";

同じ置換のListのコードはこうなる。

value = list.get(index);
list.set(index, "DEF");

では、このListで定義されたメソッドを見てみよう。

Listのメソッド

ここでは、Listを実際に実装したArrayListクラスのメソッド仕様について紹介する。

追加

追加するために、ふたつのメソッドが用意されている。ひとつは、リストの最後に要素を追加するためのメソッドとリストの途中に要素を追加するためのメソッドだ。

add(E e)

add(int index, E element)

取得

要素を取得するためのメソッドはひとつしかない。indexを指定して、要素を取得する。もしindexが範囲外なら，例外を発生させて教えてくれる。

get(int index)

置換

すでに存在する要素を、indexを指定して置き換える。もしindexが範囲外なら、例外を発生させて教えてくれる。

set(int index, E element)

削除

削除するためのメソッドはいくつかあるが、その基本となるメソッドだ。戻り値に削除された要素が返されるので、確実に削除されたかどうかがわかる。

remove(int index)

検索

検索するためのメソッドはふたつある。最初の要素から探すか、最後から探すかによってメソッドを使い分けられる。戻り値に見つかった要素のインデックスが返される。

indexOf(Object o)

lastIndexOf (Object o)

それでは実際にサンプルプログラムで確認してみよう。

追加，取得と置換を使ったサンプルプログラム

このプログラムは、くだものの名前を最初にふたつ追加した後、追加した要素の「りんご」と「みかん」の間に「もも」を挿入するというものだ。さらに、最初の要素を「ぶどう」に置換している。

Listを実装したListArrayクラスを使って書くとこうなる。

import java.util.List;
import java.util.ArrayList;

public class ListAdditionAndGet {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();//[1]
        list.add("りんご");//[2]
        list.add("みかん");//[3]
        list.add(1, "もも");//[4]
        list.set(0, "ぶどう");//[5]
        System.out.println("[6] 要素[0]:" + list.get(0));
        System.out.println("[7] 要素[1]:" + list.get(1));
        System.out.println("[8] 要素[2]:" + list.get(2));
    }
}

同じことを可能な限り配列で書くとこうなる。

public class ArrayAdditionAndGet {
    public static void main(String[] args) {
        String[] list = new String[3];//[1]
        list[0] = "ぶどう";//[2]
        list[1] = "もも";//[3]
        list[2] = "みかん";//[4]
        System.out.println("[6] 要素[0]:" + list[0]);
        System.out.println("[7] 要素[1]:" + list[1]);
        System.out.println("[8] 要素[2]:" + list[2]);
    }
}

実行結果

[6] 要素[0]:ぶどう
[7] 要素[1]:もも
[8] 要素[2]:みかん

サンプルプログラムの説明

それでは簡単にListArrayを使ったプログラムの解説をしてゆこう。

• [1] ArrayListクラスのオブジェクト，listを生成する。
• [2] listに文字列：「りんご」を追加する。
• [3] listに文字列：「みかん」を追加する。
• [4] listのindex:1に文字列：「もも」を追加する。
• [5] listのindex:0を文字列：「ぶどう」に置換する。
• [6] listのindex:0から取得した要素を表示する。
• [7] listのindex:1から取得した要素を表示する。
• [8] listのindex:2から取得した要素を表示する。

検索，削除と例外を使ったサンプルプログラム

このプログラムは、果物の名前を最初に３つ追加した後、最後に追加した「みかん」を検索し、そのインデックスで「みかん」を削除する。

削除した要素を取得して、例外が発生することも確認している。

import java.util.List;
import java.util.ArrayList;

public class ListIndexOfAndRemove {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();//[1]
        list.add("りんご");//[2]
        list.add("もも");//[3]
        list.add("みかん");//[4]
        int index = list.indexOf("みかん");//[5]
        System.out.println("[6] index = " + index);
        list.remove(index);//[7]
        System.out.println("[8] 要素[0]:" + list.get(0));
        System.out.println("[9] 要素[1]:" + list.get(1));
        try {//[10]
            System.out.println("[11] 要素[2]:" + list.get(2));
        } catch (IndexOutOfBoundsException indexOutOfBoundsException ) {//[12]
            System.out.println("[13] 要素[2]:例外発生");
        }

    }
}

実行結果

[6] index = 2
[8] 要素[0]:りんご
[9] 要素[1]:もも
[13] 要素[2]:例外発生

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1]-[4] 前のサンプルに同じ。
• [5] listの中の「みかん」を検索し，そのインデックスをindexに代入する。
• [6] indexを表示する。
• [7] listのindexにある要素を削除する。
• [8] listのindex:0から取得した要素を表示する。
• [9] listのindex:1から取得した要素を表示する。
• [10] 例外処理の開始tryを宣言する。
• [11] listのindex:2から取得した要素を表示する。
• [12] 例外処理のcatchを宣言する。
• [13] 例外が発生したことを表示する。

まとめ

このページではJavaのListと配列の違いについて、またListの使い方についてまとめてきた。

サンプルコードを含めて参考にしていただければ幸いだ。

このページではJavaの配列のコピー方法をまとめてご紹介した。

Javaの配列をコピーする方法

配列の要素をデータ処理する場合、元のデータを残してデータを並べ替えたり、あるグループのデータだけを取り出したりする場合がある。

このような時、元のデータをそのまま取っておくなら、新たな配列を作ってコピーする必要がある。

配列をコピーする方法はいくつかある。

forループを使ってコピーのためのコードを最初から書いてもよいが、Javaのクラスライブラリを使えばもっとスマートに配列をコピーできる。

はじめに、forループを使って配列をコピーする方法をみてみよう。

forループを使った配列コピーのサンプルプログラム

このプログラムは、配列numbersを作った後に新たに配列newNumbersを作り、forループを使って元の配列の値を3個コピーしている。

public class CopyOfArrayByLoop {
    public static void main(String[] args) {
        int[] numbers = {12,24,36};//[1]

        int[] newNumbers = new int[3];//[2]
        for (int index = 0; index < numbers.length; index++) {//[3]
            newNumbers[index] = numbers[index];//[4]
        }
        for (int index = 0; index < numbers.length; index++) {//[5]
            System.out.println("[6] newNumbers[" +index + "] = " + newNumbers[index]);
        }
    }
}

実行結果

[6] newNumbers[0] = 12
[6] newNumbers[1] = 24
[6] newNumbers[2] = 36

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] int型で3個の要素数を持つ配列参照変数numbersを宣言し、初期値を代入する
• [2] int型で3個の要素数を持つ配列参照変数newNumbersを作る。
• [3]-[4] forループによりnewNumbersの先頭からnumbersの3つの値を代入する。
• [5] 配列の全ての値をひとつずつ表示する。

では、次に配列をコピーするために使えるJavaのクラスライブラリの使い方を紹介しよう。

Java 標準クラスライブラリを使用する

Java標準のライブラリの中にあるパッケージjava.langにSystemクラスがある。そのSystemクラスに配列をコピーするarraycopyクラスメソッドがある。このメソッドを使うとふたつの配列の間で要素をコピーすることができる。

コピー先の配列を準備して、そこにコピー元の配列をコピーする。このような方法ために、このクラスメソッドが使える。コピー元とコピー先の配列のコピー開始位置やコピーする要素の数を指定することができる。

System.arraycopy (
    コピー元配列変数名, コピー元の開始位置,
    コピー先配列変数名, コピー先の開始位置,
    コピーする要素の数
)

書き方の基本はこれだ。

このクラスライブラリは、途中で何かの不具合が見つかると例外が発生して、コピーが中断する。このとき，既にコピーされた要素はそのままなので注意が必要である。

System.arraycopyを使ったサンプルプログラム

それでは実際にサンプルプログラムを確認してみよう。

このサンプルプログラムは、最初にコピー先の配列を準備しておいて、そこにコピー元の配列の要素をコピーする。

ここでは，配列の要素がプリミティブ型の場合と参照型の場合のサンプルプログラムを用意した。

配列要素がプリミティブ型

import java.util.Arrays;

public class CopyOfArrayByLibrary {
    public static void main(String[] args) {
        int[] array = {12,24,36};//[1]
        int[] newArray = new int[3];//[2]
        System.arraycopy(array,0,newArray,0,array.length);//[3]
        System.out.println("[4] " + Arrays.toString(newArray));
    }
}

実行結果

[4] [12, 24, 36]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] int型の配列参照変数arrayを宣言し、3個の初期値を代入する。
• [2] int型で3個の要素数を持つ配列参照変数newArrayを作る。
• [3] arraycopyクラスメソッドを使って、配列arrayの要素を配列newArrayにコピーする。
• [4]配列newArrayの値を表示する。

配列要素が参照型

import java.util.Arrays;

public class CopyOfReferenceTypeArrayByLibrary {
    public static void main(String[] args) {
        String[] array = {"ab","cd","ef"};//[1]
        String[] newArray = new String[3];//[2]
        System.arraycopy(array,0,newArray,0,array.length);//[3]
        System.out.println("[4] " + Arrays.toString(newArray));
    }
}

実行結果

[4] [ab, cd, ef]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 文字列型の配列arrayを宣言し、3個の初期値を代入する。
• [2] 文字列型で3個の要素数を持つ配列参照変数newArrayを作る。
• [3] arraycopyクラスメソッドを使って、配列arrayの要素を配列newArrayにコピーする。
• [4] 配列newArrayの要素を表示する。

配列の浅い（Shallow）と深い（Deep）コピー

配列のコピーには、Shallow コピーとDeepコピーがある。

Shallowコピーは、配列の入れ物はひとつで、新たに宣言した配列参照変数に配列の場所を指す配列参照変数の値だけをコピー、つまり代入する。このコピーでは、入れ物はひとつなので配列の要素の値を変更すると、コピー元もコピー先も両方とも値が変化する。

一方、Deepコピーは新たな配列参照変数を宣言し、配列の入れ物も新たに作って、配列の要素のほうをコピーする。

このコピーでは入れ物は別なので、配列の要素を変更しても他方の要素の値が変更されることはない。

では、実際のプログラムを見てみよう。

Shallowコピーのサンプルプログラム

このプログラムは、配列のShallowコピーを行う。コピー先の値を変更した時、コピー先の要素の値も変化することが確認できる。

import java.util.Arrays;

public class ShallowCopy {
    public static void main(String[] args) {
        int[] array = {12,24,36};//[1]
        int[] newArray = array;//[2]
        System.out.println("[3] 元の配列 = " + Arrays.toString(array));
        System.out.println("[4] Shallowコピー = " + Arrays.toString(newArray));
        newArray[1] = 999;//[5]
        System.out.println("[6] 元の配列 = " + Arrays.toString(array));
        System.out.println("[7] Shallowコピー = " + Arrays.toString(newArray));
    }
}

実行結果

[3] 元の配列 = [12, 24, 36]
[4] Shallowコピー = [12, 24, 36]
[6] 元の配列 = [12, 999, 36]
[7] Shallowコピー = [12, 999, 36]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

• [1] int型で3個の要素数を持つ配列参照変数arrayを宣言し、初期値を代入する
• [2] int型で配列参照変数newArrayを作り，参照変数arrayの値を初期値として代入する。
• [3]-[4] arrayとnewArray配列の全ての値をひとつずつ表示する。
• [5] 配列newArrayの2番目の要素に999を代入する。
• [6]-[7] arrayとnewArray配列の全ての値をひとつずつ表示する。

Deepコピーのサンプルプログラム

このプログラムは、配列のDeepコピーを行う。コピー先の値を変更した時、コピー先の要素の値は変更されないことが確認できる。

import java.util.Arrays;

public class DeepCopy {
    public static void main(String[] args) {
        int[] array = {12,24,36};//[1]
        int[] newArray = new int[3];//[2]
        System.arraycopy(array,0,newArray,0,array.length);//[3]
        System.out.println("[4] 元の配列 = " + Arrays.toString(array));
        System.out.println("[5] Deepコピー = " + Arrays.toString(newArray));
        newArray[1] = 999;//[6]
        System.out.println("[7] 元の配列 = " + Arrays.toString(array));
        System.out.println("[8] Deepコピー = " + Arrays.toString(newArray));
    }
}

実行結果

[4] 元の配列 = [12, 24, 36]
[5] Deepコピー = [12, 24, 36]
[7] 元の配列 = [12, 24, 36]
[8] Deepコピー = [12, 999, 36]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしていこう。

• [1] int型で3個の要素数を持つ配列参照変数arrayを宣言し、初期値を代入する
• [2] int型で3個の要素数を持つ配列参照変数newArrayを作る。
• [3] arrayからnewArrayに配列の要素をすべてコピーする。
• [4]-[5] arrayとnewArray配列の全ての値をひとつずつ表示する。
• [6] 配列newArrayの2番目の要素に999を代入する。
• [7]-[8] arrayとnewArray配列の全ての値をひとつずつ表示する。

まとめ

このページではJavaの配列のコピー方法についてまとめてきた。はじめは混乱するかもしれないが、重要な考え方だ。

参考にしていただければと思う。

このページではbyte配列についてまとめてご紹介していこう。

Javaのbyte配列とは？

byte配列とは、要素がbyte型の配列のことである。Javaのbyte型はいくつかあるプリミティブ型のひとつである。他のshort型やint型などとビットの数を比べるとbyte型はビットの数が8個で最も小さい。

例えば，6つの要素を持つbyte配列変数を定義すると次のようになる。最初にbyte配列変数を定義する。

byte[] array;

そして，配列の要素を入れるための入れ物を準備する。

array = new byte[6];

このふたつの行をひとつに書くことも出来る。

byte[] array = new byte[6];

これで，6つのbyte型の要素を持つ配列を作ることができた。

byte配列を使って実際にどんなことができるのかというと，例えば色々な型の情報をひとつのまとまったメモリに連続して書き込むときにbyte配列を使うことができる。byte配列であれば，書き込んだり読み込んだりするメモリの位置を自由に設定することができる。

byte配列を扱うためには，ライブラリのjava.nioパッケージにあるByteBufferクラスを使うと便利である。例えば，6つの要素を作って，最初に2バイトのshort型の数値を入れ，続く4バイトにint型の値を入れるとする。

この場合，byte配列を内部に持つByteBufferクラスのオブジェクトを作る。そして，putShortメソッドと，putIntメソッドに配列の位置を指定して書き込む。

ByteBuffer byteBuffer = ByteBuffer.wrap(array);
byteBuffer.putShort(0, putShortValue);
byteBuffer.putInt(2, putIntValue);

読み出すときは，getShortメソッドと，getIntメソッドに配列の位置を指定して読み出す。

int getShortValue = byteBuffer.getShort(0);
int getIntValue = byteBuffer.getInt(2);

では，実際にサンプルプログラムで確かめてみよう。

サンプルプログラム

このプログラムは，前のセクションで説明したコードを実際に動かすように組み込んだものである。書き込んだデータがそのまま読み出されている。

import java.nio.ByteBuffer;

public class ByteArray {
    public static void main(String[] args) {
        short putShortValue = 1212; //[1]
        int putIntValue = 1234567890; //[2]
        byte[] array;//[3]
        array = new byte[6];//[4]
        // byte[] array = new byte[6];//[5]

        ByteBuffer byteBuffer = ByteBuffer.wrap(array);//[6]
        byteBuffer.putShort(0, putShortValue);//[7]
        byteBuffer.putInt(2, putIntValue);//[8]

        int getShortValue = byteBuffer.getShort(0);//[9]
        int getIntValue = byteBuffer.getInt(2);//[10]
        System.out.println("[11] getShortValue = " + getShortValue);
        System.out.println("[12] getIntValue = " + getIntValue);
    }
}

実行結果

[11] getShortValue = 1212
[12] getIntValue = 1234567890

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1]-[5] short型とint型の変数と配列変数を準備する。
• [6]-[8] short型とint型の変数の値をbyte配列に書き込む。
• [9]-[12] byte配列に書き込んだ値を読み出して表示する。

まとめ

このページではbyte配列についてお伝えしてきた。参考にしていただければ幸いだ。

結論から言うと、配列名.lengthで獲得できるが、サンプルプログラムを含めて確認しよう。

Java配列の要素数の取得方法

配列の要素数とは，配列という入れ物の中に入れることができる要素の数のことである。要素の数は，ゼロを含む正の整数である。この数は，配列を作る時に決まり，それ以後変更することは出来ない。

要素数は「new」演算子によって配列を作るときに指定する。

指定の仕方は簡単だ。

配列変数名 = new 型[要素数]

生成した配列の数を求めるには，配列のメンバのひとつであるlengthフィールドを利用する。lengthはメソッドではない。

書き方の基本は簡単だ。

要素数 = 配列名. length

では，実際のプログラムからその使い方をみてみよう。

Java配列のlengthを使ったサンプルプログラム

このプログラムは、配列のlengthを使って、３つの数値の合計を求めている。

import java.util.ArrayList;

public class LengthOfArray {
    public static void main(String[] args) {
        int[] numbers = new int[3];//[1]
        numbers[0] = 80;//[2]
        numbers[1] = 72;//[3]
        numbers[2] = 64;//[4]
        int sum = 0;
        for (int index = 0; index < numbers.length; index ++){//[5]
            sum += numbers[index];//[6]
        }
        System.out.println("[7] sum = " + sum);
    }
}

実行結果

[7] sum = 216
[8] numbers.length = 3

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数numbersを宣言し、要素数を3で生成する。
• [2] numbers[0]に80を代入する。
• [3] numbers[1]に72を代入する。
• [4] numbers[2]に64を代入する。
• [5]-[6] forループを使って、代入された値の合計を求める
• [7] 合計を表示する。
• [8] 要素数を表示する。

まとめ

このページでは配列の要素数についてお伝えした。lengthを使えば取得できることを覚えておきたい。

このページではJavaの二次元配列の使い方についてお伝えする。

Javaの二次元配列

二次元配列では、通常の一次元配列に次元がもうひとつ加わる。一次元が直線ならば、二次元は平面である。縦方向の並びに横方向の並びが加わる。

次元というとわかりにくいかもしれないが、部屋番号くらいで考えると二次元行列はわかりやすいだろう。

平屋であったら部屋番号だけでわかる。これが通常の行列だ。

何階もあるマンションであれば4Fの2部屋目という形で、「4F」「2部屋目」というように場所を特定するための要素が二つになる。これが二次元配列になる。

二次元の配列変数から値を取り出すためには、縦方向と横方向のふたつのインデックスで引き出す。

二次元配列を扱うための準備

二次元の配列を使うためには、その準備として配列を宣言し配列を生成する必要がある。これは、通常の配列と同じである。

宣言

二次元配列変数の宣言は、配列の型と次元がふたつあることを宣言する。変数の型の後に[]をふたつ書けば二次元配列になる。

その書き方の基本は簡単だ。

型　配列変数名[][];

int型の二次元配列の例を示す。

int[][] arrayOfIntTwoDimensions;

オブジェクトの配列変数も同じ書き方になる。

Object[][] arrayOfObjects;

二次元配列を宣言しても、それは配列の入れ物がどこにあるかを示す変数を定義しただけだ。次に、配列を生成することが必要である。

生成

配列の生成は、配列の大きさに応じて配列の要素を入れるための入れ物を確保することである。生成を行うためにはnew演算子を使い、配列の大きさを指定して、次のように書く。

配列変数名 = new 型[配列の要素数][配列の要素数];

例えば、次のコードは最初の配列の要素数が4個、2番目の配列の要素数が5個の配列を生成するint型の二次元配列の例を示す。

int[][] arrayOfIntTwoDimensions = new int[4][5];

オブジェクトの参照型の配列変数も同じ書き方になる。

Object[][] arrayOfObjectTwoDimensions = new Object[4][5];

では、どのようにこれらの配列にアクセスするのか見てみよう。

二次元配列へのアクセス

配列変数にアクセスするには、アクセスしたい要素の入っている配列のインデックスを指定して要素へアクセスする。この時、インデックスは0から始まることに注意しよう。

書き方の基本は簡単だ。

要素の値 = 配列変数[インデックス][インデックス];

int型の配列から値を読み出す例を見てみよう。先に例として挙げたint型の配列の要素にアクセスする場合はこうなる。

value = array[2][3];

この場合に二次元配列arrayのどの要素にアクセスしているかというと最初の配列のインデックスが2なので、1を加えた3番目の配列になる。また、2番目の配列のインデックスrが3なので、1を加えた4番目の配列になる。それで、次の図で説明すると要素の位置は上から3番目の左から4番目の配列の要素となる。

実際のプログラムで、配列の宣言からアクセスまでを見てみよう。

サンプルプログラム

このサンプルプログラムは、二次元配列のarray[2][3]とその前後の要素に値を代入し、それをまた読み出し表示する。それぞれの配列に代入した値が、同じインデックスでそのまま表示されていることが確認できる。

public class CreationAndAccess {
    public static void main(String[] args) {
        int[][] array;//[1]
        array = new int[4][5];//[2]
        array[2][2] = 22;//[3]
        array[2][3] = 23;//[4]
        array[2][4] = 24;//[5]
        int value = array[2][2];//[6]
        System.out.println("[7] array[2][2]=" + value);
        value = array[2][3];//[8]
        System.out.println("[9] array[2][3]=" + value);
        value = array[2][4];//[10]
        System.out.println("[11] array[2][4]=" + value);
    }
}

実行結果

[7] array[2][2]=22
[9] array[2][3]=23
[11] array[2][4]=24

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数arrayを定義する。
• [2] 配列arrayを最初の要素数を4、次の要素数を5で生成する。
• [3] array[2][3]に23を代入する。
• [4] array[2][4]に24を代入する。
• [5] array[2][5]に25を代入する。
• [6]-[11] 配列arrayに代入した位置の要素を表示する。

二次元配列の初期化

配列に初期値を代入する方法として、次のようにひとつひとつ値を代入することもできる。前のセクションのサンプルプログラムでは、この方法で初期値が代入されていた。しかし、大きな配列全てについて次のように書くのは大変なことだ。

int array[][];
array = new int[2][3];
array[0][0] = 0;
array[0][1] = 1;
array[0][2] = 2;
array[1][0] = 3;
array[1][1] = 4;
array[1][2] = 5;

これをまとめて書くことができる。

int array[][] = {{0,1,2}, {3,4,5}};

かなり簡単になる。さらに、ループを使ってまとめて表示するために配列の長さを知る必要がある。

書き方の基本は簡単だ。

1番目の配列の長さ = 配列変数.length;

2番目の配列の長さ = 配列変数[インデックス].length;

実際のプログラムを見てみよう。

サンプルプログラム

このサンプルプログラムは、二次元配列を定義すると同時に初期値を代入する。その後、代入された値を、forループを使って表示している。

public class ArrayInitializer {
    public static void main(String[] args) {
        int array[][] = {{0,1,2}, {3,4,5}};//[1]
        for (int dimension1 = 0; dimension1 < array.length; dimension1++) {//[2]
            for (int dimension2 = 0; dimension2 < array[dimension1].length; dimension2++) {//[3]
                int value = array[dimension1][dimension2];//[4]
                System.out.println("[5] value[" + dimension1 + "][" + dimension2 + "]=" + value);
            }
            System.out.println("[6]");
        }
    }
}

実行結果

[5] value[0][0]=0
[5] value[0][1]=1
[5] value[0][2]=2
[6]
[5] value[1][0]=3
[5] value[1][1]=4
[5] value[1][2]=5
[6]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数arrayを定義し、初期値で初期化する。
• [2]-[6] 配列arrayの全ての要素を表示する。

多次元配列参考ページ

次のページも参考にしていただければと思う。

まとめ

このページではJavaの二次元配列の書き方・使い方についてお伝えした。Javaでプログラムを組んでいく上で、必ず使う文法だ。マスターしていただければと思う。

より複雑にエクセルのような２次元的な配列を作ったり、それ以上の多次元配列を作ることもできる。

このページではJavaの多次元配列についてお伝えしていこう。

Javaの多次元配列

多次元配列とは？

通常配列と言えば、1次元の配列を表している。同じ型の変数が一列に並んでいるようなものである。一列に並んだ配列変数の値をインデックス（先頭からの位置）で引き出すことができた。

2次元配列とは、次元がもうひとつ加わる。

1次元が直線ならば、2次元は平面である。縦方向の並びに横方向の並びが加わる。2次元の配列変数から値を取り出すためには、縦方向と横方向のふたつのインデックスで引き出す。

3次元はどうだろうか。次元がもうひとつ加わる。縦と横に高さが加わる。4次元になったら、どう考えたら良いだろうか。もっと多次元になったらどうか。3次元以上の多次元を現実世界に当てはめるのは難しい。

直感的に理解できる図にしたらこのようになる。配列が次の次元の配列を指している。この関係が次元の数だけある。そして、最後の次元の配列に値が入る。

多次元配列を扱うための準備

多次元配列を使うためには、その準備として配列を宣言し配列を生成する必要がある。これは、通常の配列と同じである。

宣言

多次元配列変数の宣言は、配列の型と次元がいくつあるかを宣言する。変数の型の後に[]をふたつ書けば2次元配列になる。3つ書けば3次元である。

その書き方の基本は簡単だ。

型　配列変数名[][]・・・;

int型の2次元配列の例を示す。

int[][] arrayOfIntTwoDimensions;

オブジェクトの配列変数も同じ書き方になる。

Object[][] arrayOfObjects;

2次元配列を宣言しても、それは配列の入れ物がどこにあるかを示す変数を定義しただけだ。次に、配列を生成することが必要である。

生成

配列の生成は、配列の大きさに応じて配列の要素を入れるための入れ物を確保することである。生成を行うためにはnew演算子を使い、配列の大きさを指定して、次のように書く。

配列変数名 = new 型[配列の要素数][配列の要素数]・・・;

例えば、次のコードは最初の配列の要素数が4個、2番目の配列の要素数が5個の配列を生成するint型の2次元配列の例を示す。さらに、要素数が6個の次元が加わった3次元の配列の例も示す。

arrayOfIntTwoDimensions = new int[4][5];

arrayOfIntThreeDimensions = new int[4][5][6];

オブジェクトの参照型の配列変数も同じ書き方になる。

Object[][] arrayOfObjectTwoDimensions = new Object[4][5];

Object[][] arrayOfObjectThreeDimensions = new Object[4][5][6];

では、どのようにこれらの配列にアクセスするのか見てみよう。

多次元配列へのアクセス

配列変数にアクセスするには、アクセスしたい要素の入っている配列のインデックスを指定して要素へアクセスする。この時、インデックスは0から始まることに注意しよう。

書き方の基本は簡単だ。

要素の値 = 配列変数[インデックス][インデックス]・・・;

int型の配列から値をとってくる例を見てみよう。先に例として挙げたint型の配列の場合はこうなる。

value = arrayOfIntTwoDimensions[2][3];

value = arrayOfIntTwoDimensions[2][3][4];

実際のプログラムで、配列の宣言からアクセスまでを見てみよう。

多次元配列のサンプルプログラム

このサンプルプログラムは、2次元配列をインデックスの合計の値で初期化し、その値を表示している。

public class TwoDimensions {
    public static void main(String[] args) {
        int[][] arrayOfInts;//[1]
        arrayOfInts = new int[3][4];//[2]
        for (int dimension1 = 0; dimension1 < arrayOfInts.length; dimension1++) {//[3]
            for (int dimension2 = 0; dimension2 < arrayOfInts[dimension1].length; dimension2++) {//4]
                arrayOfInts[dimension1][dimension2] = dimension1 + dimension2;//[5]
            }
        }
        for (int dimension1 = 0; dimension1 < arrayOfInts.length; dimension1++) {//[6]
            for (int dimension2 = 0; dimension2 < arrayOfInts[dimension1].length; dimension2++) {//[7]
                int value = arrayOfInts[dimension1][dimension2];//[8]
                System.out.println("[9] value[" + dimension1 + "][" + dimension2 + "]=" + value);
            }
            System.out.println("[10]");
        }
    }
}

実行結果

[9] value[0][0]=0
[9] value[0][1]=1
[9] value[0][2]=2
[9] value[0][3]=3
[10]
[9] value[1][0]=1
[9] value[1][1]=2
[9] value[1][2]=3
[9] value[1][3]=4
[10]
[9] value[2][0]=2
[9] value[2][1]=3
[9] value[2][2]=4
[9] value[2][3]=5
[10]

多次元配列サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数arrayOfIntsを定義する。
• [2] 配列arrayOfIntsを最初の要素数を2、次の要素数を3で生成する。
• [3]-[5] 配列arrayOfInts[dimension1][dimension2]の全ての要素に、その配列のインデックスに応じてその合計dimension1 + dimension2を代入する。
• [6]-[10] 配列arrayOfIntsの全ての要素を表示する。

配列の初期化

配列に初期値を代入する方法として、次のようにひとつひとつ値を代入することができる。前のセクションのサンプルプログラムでは、forループで値を代入していたので、それほど大変そうに見えない。しかし、次のように書くのは大変なことだ。

int array[][];
array = new int[2][3]; 
array[0][0] = 0;
array[0][1] = 1;
array[0][2] = 2;
array[1][0] = 3;
array[1][1] = 4;
array[1][2] = 5;

これをまとめて書くことができる。

int array[][] = {{0,1,2}, {3,4,5}};

かなり簡単になる。

多次元配列の初期値設定サンプルプログラム

このサンプルプログラムは、2次元配列を定義すると同時に、初期値を代入する。その後、代入された値を表示している。

public class ArrayInitializer {
    public static void main(String[] args) {
        int arrayOfInts[][] = {{0,1,2}, {3,4,5}};//[1]
        for (int dimension1 = 0; dimension1 < arrayOfInts.length; dimension1++) {//[2]
            for (int dimension2 = 0; dimension2 < arrayOfInts[dimension1].length; dimension2++) {//[3]
                int value = arrayOfInts[dimension1][dimension2];//[4]
                System.out.println("[5] value[" + dimension1 + "][" + dimension2 + "]=" + value);
            }
            System.out.println("[6]");
        }
    }
}

実行結果

[5] value[0][0]=0
[5] value[0][1]=1
[5] value[0][2]=2
[6]
[5] value[1][0]=3
[5] value[1][1]=4
[5] value[1][2]=5
[6]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数arrayOfIntsを定義し、初期化する。
• [2]-[6] 配列arrayOfIntsの全ての要素を表示する。

配列を別々に生成

多次元配列の配列を生成するとき、配列の要素の数を最初から決めて生成しなくてもよい。その場の必要に応じて、配列を生成することが出来る。

このことをサンプルプログラムで見てみよう。

サンプルプログラム

このサンプルプログラムは、2次元配列の最初の要素数は3だが、その次の要素数は異なる数で生成している。その後、代入された値を表示している。

public class ArrayCreation {
    public static void main(String[] args) {
        int arrayOfInts[][];//[1]
        arrayOfInts = new int[3][];//[2]
        for (int dimension1 = 0; dimension1 < arrayOfInts.length; dimension1++) {//[3]
            arrayOfInts[dimension1] = new int[dimension1 + 1];//[4]
            for (int dimension2 = 0; dimension2 < arrayOfInts[dimension1].length; dimension2++) {//[5]
                arrayOfInts[dimension1][dimension2] = dimension2;//[6]
            }
        }
        for (int dimension1 = 0; dimension1 < arrayOfInts.length; dimension1++) {//[7]
            for (int dimension2 = 0; dimension2 < arrayOfInts[dimension1].length; dimension2++) {//[8]
                int value = arrayOfInts[dimension1][dimension2];//[9]
                System.out.println("[10] value[" + dimension1 + "][" + dimension2 + "]=" + value);
            }
            System.out.println("[11]");
        }
    }
}

実行結果

[[10] value[0][0]=0
[11]
[10] value[1][0]=0
[10] value[1][1]=1
[11]
[10] value[2][0]=0
[10] value[2][1]=1
[10] value[2][2]=2
[11]

サンプルプログラムの説明

それでは簡単にプログラムの解説をしてゆこう。

• [1] 配列変数arrayOfIntsを定義する。
• [2] 配列arrayOfIntsを最初の要素数を3で生成する。
• [3]-[4] 配列arrayOfInts[dimension1][]の要素数をdimension1+1の数で生成する。
• [5]-[6] 配列のインデックスdimension2の値を代入する。
• [7]-[11] 配列arrayOfIntsの全ての要素を表示する。

まとめ

このページではJavaの多次元配列についてまとめてお伝えした。

多次元配列なしにプログラムを組むのはなかなか大変だ。はじめは難しいかもしれないが、使い方をマスターしてしまおう。

このページではJava配列の初期化についてお伝えする。

Javaの配列の初期化

配列の初期値

配列は、宣言して生成した時点で何かしらの初期値が配列の各要素に代入されている。

プリミティブ型であれば何かしらの値（ex. intならば「0」）が初期値として設定されており、これは単一の変数を宣言したときと同じだ。

また、オブジェクト型の場合は各要素にnullが設定されている。

このように、単一の変数を宣言した時同様に、配列を生成すると何かしらの初期値が設定されており、このような初期値を「暗黙の初期値」と呼ぶが、一般的にこの「暗黙の初期値」を利用する事は望ましくないとされている。

暗黙の初期値を避けるべき理由

なぜならば、プログラム言語によって初期値は異なるため、一見しただけではどのような値が入っているのかが分かりにくいからだ。

例えば、javaでint型の変数を宣言すれば「0」が入っているようだが、Ｃ言語と呼ばれるプログラム言語は「不定」といって何が入っているのかはわからない。

そのような事情から、プログラム製作者の認識が統一できず、プログラム自体が思わぬ動作をしてしまうこともある。

その為、暗黙の初期値は使用しないというのが慣例となっている。

単一の変数では、暗黙の初期値を参照する処理はコンパイルエラーとすることが出来るが、配列の場合はコンパイルエラーとならない。その為、意識的に初期化をしなければプログラムの重大な欠陥を見過ごしてしまうこともある。

配列を使用する際には、生成直後に必ず初期化処理を行う癖をつけよう。

初期値の設定方法

初期化の具体的な方法は、各要素への値の代入だ。

color[0] = "赤";

これまでもお伝えしてきたもので、特に変わったものでもない。配列の宣言と同時に初期値を設定することも可能だ。

String  color[] = {"赤","青","黄"} ;

この場合、3つの初期値を設定しているので、配列の長さは「３」となる。

数値型の場合は

int number[] = {1,2,3,4,5} ;

という書き方ができる。

オブジェクト型の配列の場合、各要素の初期値にnew演算子を使用した初期化式を利用する事もできる。

Date date[] = {new Date(),new Date(), new Date()} ;

書き方について補足をすれば、最後の要素の後に、「,」が余分に付いていても構わない。

どのようなときに使うかというと

String  message[] = {
    "登録しました。",
    "名前が入力されていません。",
    "住所が入力されていません。",
} ;

というように、並べて書き足すような場合だ。

最後の要素を意識せずに「,」を書くことが出来るので、つまらないコンパイルエラーに悩まされずに済む。

意外に便利な記述方法なのだが、現時点ではよくわからずとも構わない。使っていくうちにわかるだろう。

まとめ

このページではJava配列の初期化についてお伝えした。言葉は難しく聞こえるが、配列の初期値を入れましょうね、というだけの話だとまずは思っておけばいいだろう。

このページではJavaの配列の基本的な使い方についてお伝えしよう。

Javaの配列の基本的な使い方

使い方の前に

配列のイメージが湧いていない方はまず下記のページを確認してほしい。

配列を使うには宣言が必要だが、それは下記で詳しくお伝えしている。

基本的な使い方

配列の番号に応じて要素は取り出せる。

array[数字];

次のような形だ。

int ary[] = new int[5];
ary[0] = 4;
ary[1] = 2;
ary[2] = 1;
ary[3] = 5;
ary[4] = 3;

System.out.println("インデックス0の値は" + ary[0] + "です");

入力するときは、

配列名[添字] = 値;

出力するときは、

配列名[添字] 

を使えばいい。

例えば、上記のコードだと「インデックス0の値は4です」と表示される。

配列は「0」からはじまる。なので一つ目の要素はarray[0]などとなる。1ではないので気をつけよう。

配列への入力

上のようにひとつひとつ入れてもいいが、手間がかかりすぎるだろう。

次のようにすることもできる。

int[] ary = {4,2,1,5,3};

このように入力すると一括での利用も可能だ。

繰り返し処理との組み合わせ

配列を使った処理の代表的なものが繰り返し処理だ。以下の記述を見てほしい

int num[] = new int[100]; //①
for(int index = 0 ; index < num.length; index ++){ //②
        num[index] = index ; //③
}

まず、①ではint型の1長さ100の配列を生成している。

②は配列に対する繰り返し処理だが、

num.length  

という記述で、配列の長さを取得する事が出来る。つまり、②のfor文は配列の長さ文だけ処理を繰り返すという事を意味している。

配列は変数が列になっているが、[]で数値を指定することで、その番号の要素を参照したり、値を代入したりすることが出来る。③は代入する場合の記述だ。

なお、再度のお伝えとなるが、配列の一番最初の要素は「０」（ゼロ）番から始まる。数え方として０，１，２となるので注意してもらいたい。

同じように、配列の長さ分処理を繰り返す処理として、以下のよう記述方法がある

int num[] = new int[100];
for( int element : num){ // ①
         System.out.println(element);
}

①の「int element : num」という記述は「numという配列の最初の要素から順に、int型変数のelementに代入する」という意味だ。

この記述方法は、PHPやperlなどで用いられるforeachと同じようなものだ。

Java1.6から採用された記述方法のため、それ以前から動いているプログラムでは見かけることはないが、最近のソースコードとしてはポピュラーな記述だ。

メソッドへの渡し方と参照型

ここからは少々難易度が高くなるので、ここまで理解しておけばまずは十分だ。

興味がある方だけ読んでみていただければと思う。

配列は変数の塊ということで、単一の変数とは少々扱いが異なる。まずは以下のソースコードを見てもらいたい 

int num[] = new int[10];
for(int index = 0 ; index < num.length; index ++){
  num[index] = index ;
}

change1(num);
for( int element : num){
  System.out.println(element);
}
System.out.println("****************");

change2(num);
for( int element : num){
System.out.println(element);
}
System.out.println("****************");
}

public void change1(int num[]){
  int work = 0;
  for(int idx = 0 ; idx < num.length/2; idx ++){
    work = num[idx] ;
    num[idx] = num[num.length - idx - 1];
    num[num.length - idx - 1] = work;
    }
}

public void change2(int num[]){
  int num2[] = new int[num.length] ;
  for(int idx = 0 ; idx < num.length; idx ++){
    num2[num.length - idx - 1] = num[idx];
  }
  num = num2 ;
}

change1()およびchange2()は、どちらも配列の数値の順番を逆転させている。

しかし、実際に実行してみるとわかるが、change1()は逆転させることが出来ているが、change2()は全く変わらない。どこに違いがあるのだろうか。

change1()は、変数numの各要素の値を直接書き換えている。

これに対し、change2()はnum2という新たな配列を用意してそこに逆順で値を代入し、最終的にnumにnum2を代入している。

入れ替えに失敗？

結果としてchaneg2()は配列の入れ替えに失敗しているが、これは何を意味しているのか。

配列変数は「参照型」と呼ばれるもので、実際の値を保持している訳では無い。

new演算子は、コンピューター上のメモリのどこかに変数の値を格納するための領域を確保する。

例えば、new int[10]は、int変数の値を格納するための4バイトの領域を10個、メモリ上のどこかに確保する。

そしてその格納した「場所」をnew演算子は返却する。

つまり

int  number[] = new int[10] ;

と記述したとき、左側の変数numberには、メモリ上のどこかに確保された4×10バイトのメモリの場所が格納される。

実際、System.out.println(number)を使用してnumber変数を表示してみると、何やら暗号のような文字列が表示される。これがメモリの場所を意味している値と考えれば良い。

この「メモリの場所」を扱う変数を「参照型」という。

先のプログラムの例では、chaneg1()chaneg2()メソッドに対し配列の値を格納している「場所」を渡している。

change1()メソッドでは、その「場所」に格納されている値を変更しているのに対し、change2()メソッドでは、num変数にnum2を代入しているため、change2()メソッド内の変数numが保持している「場所」を書き換えただけで、呼び出し元のnumには影響が無い。

少しわかりにくいかも知れないが、変数の中身を書き換えるのと、変数そのものを別のものに替えるのとの違いだと思えば良いだろう。

他の参照型の例

配列の他、オブジェクト型の変数も参照型だ。例えば

public void change3(String str){
	str = "メッセージ";
}

というメソッドを呼び出しても、呼び出し側の変数に変化が無いのは試してみるとすぐにわかるだろう。

配列はひとかたまりでオブジェクト型と考えることも可能だ。

ただ、注意してもらいたいのは、change1()のように引数で受け取った配列変数の中身を書き換える処理は決して良い記述方法では無いという点だ。

多くの場合、プログラムの作り方を工夫すれば、このような記述をせずに済むはずだ。

また、chang3()メソッドのように、引数として宣言された変数に対し、メソッド内で代入するような記述は極力避けるべきであろう。

構文上禁止されている訳では無いが、一般的には嫌われる記述と理解しておこう。

まとめ

このページではJava配列の基本的な使い方についてお伝えをしてきた。

まずは基本的な使い方を覚えて、繰り返し文と組み合わせられるところまで理解しておこう。