Javaプログラミング学習サイト ゆるゆるプログラミング

2019/09/03 公開

・配列値の反転

配列に格納されている値の順番を逆にする反転処理を行うプログラムを紹介します。

例えば、以下のように配列に値が入っているとき

 5, 7, 8, 1, 3, 2

配列の値を反転すると

 2, 3, 1, 8, 7, 5

となります。これが配列の反転処理です。

ここから、以下の配列を例に反転処理を説明していきます。

配列の反転処理 元データ1

反転処理は、配列の先頭と最後の値の入れ替えから始まり、先頭の次の値と最後の1つ前の値を入れ替え、その処理を配列の中心に向かって入れ替えを行っていきます。入れ替える回数は、配列要素数を2で割り小数以下を切り捨てた値です。

この例は、要素数が6なので、入れ替え回数は6÷2=3回となります。

配列の反転処理 値の交換1 配列の反転処理 値の交換2 配列の反転処理 値の交換3

このように配列の中心に向かっての値の入れ替えで、配列の値を反転することができます。

次の例は、要素数が7の配列です。入れ替え回数は7÷2=3.5の小数以下を切り捨てた3回となります。

配列の反転処理 元データ2

要素数奇数の場合は、真ん中の値は入れ替えの対象になりません。

以下は、配列の反転処理を行うソースコード例です。

ArrayReverse1.java ← クリックしてダウンロードページに移動
001:    public class ArrayReverse1 {
002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( int[] values )
004:    	{
005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;
008:    
009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字
015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			int w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}
024:    	}
025:    
026:    	// メイン
027:    	public static void main( String[] args ) {
028:    		// 数値群
029:    		int[] values = { 5,7,8,1,3,2 };
030:    
031:    		// 配列の値を反転
032:    		array_reverse( values );
033:    
034:    		// 結果を確認
035:    		for ( int i = 0; i < values.length; ++ i ) {
036:    			System.out.println( values[ i ]  );
037:    		}
038:    	}
039:    }

ArrayReverse1の出力結果(配列値の反転)

2
3
1
8
7
5

ここからは、配列の反転処理のメソッドについて解説します。

002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( int[] values )
004:    	{

配列を反転するメソッドarray_reverseを定義しています。引数int型配列valuesを渡します。

このメソッドでは、配列valuesの値を変更します。新しい配列を作成しません。

005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;

値を入れ替える回数をint型変数countに代入しています。回数は、配列valuesの要素数values.lengthを2で割った値です。これは整数割り算なので小数以下の値は、切り捨てになります。

countが0のとき、処理をする必要がないのでreturn文メソッドを抜けます。

009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字

入れ替えに使うint型変数sをeを宣言しています。

変数sには、配列の先頭の添え字 0を代入しています。

変数eには、配列の最後の添え字 values.length-1を代入しています。

015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			int w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}

for文でcount回のループを作成しています。そのループの中で、values[ s ]とvalues[ e ]の値を入れ替えています。また、変数sをインクリメント変数eをデクリメントし、入れ替えたい対象の添え字配列の中心に近づけています。

以上が配列の反転方法についての説明です。

ここから、byte型short型float型double型配列を反転するJavaソースコードを紹介します。

以下は、byte型配列反転のJavaソースコードです。

ArrayReverse_byte.java ← クリックしてダウンロードページに移動
001:    public class ArrayReverse_Byte {
002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( byte[] values )
004:    	{
005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;
008:    
009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字
015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			byte w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}
024:    	}
025:    
026:    	// メイン
027:    	public static void main( String[] args ) {
028:    		// 数値群
029:    		byte[] values = { 5,7,8,1,3,2 };
030:    
031:    		// 配列の値を反転
032:    		array_reverse( values );
033:    
034:    		// 結果を確認
035:    		for ( int i = 0; i < values.length; ++ i ) {
036:    			System.out.println( values[ i ]  );
037:    		}
038:    	}
039:    }

以下は、short型配列反転のJavaソースコードです。

ArrayReverse_short.java ← クリックしてダウンロードページに移動
001:    public class ArrayReverse_Short {
002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( short[] values )
004:    	{
005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;
008:    
009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字
015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			short w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}
024:    	}
025:    
026:    	// メイン
027:    	public static void main( String[] args ) {
028:    		// 数値群
029:    		short[] values = { 5,7,8,1,3,2 };
030:    
031:    		// 配列の値を反転
032:    		array_reverse( values );
033:    
034:    		// 結果を確認
035:    		for ( int i = 0; i < values.length; ++ i ) {
036:    			System.out.println( values[ i ]  );
037:    		}
038:    	}
039:    }

以下は、float型配列反転のJavaソースコードです。

ArrayReverse_float.java ← クリックしてダウンロードページに移動
001:    public class ArrayReverse_Float {
002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( float[] values )
004:    	{
005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;
008:    
009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字
015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			float w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}
024:    	}
025:    
026:    	// メイン
027:    	public static void main( String[] args ) {
028:    		// 数値群
029:    		float[] values = { 5.0f,7.0f,8.0f,1.0f,3.0f,2.0f };
030:    
031:    		// 配列の値を反転
032:    		array_reverse( values );
033:    
034:    		// 結果を確認
035:    		for ( int i = 0; i < values.length; ++ i ) {
036:    			System.out.println( values[ i ]  );
037:    		}
038:    	}
039:    }

以下は、double型配列反転のJavaソースコードです。

ArrayReverse_double.java ← クリックしてダウンロードページに移動
001:    public class ArrayReverse_Double {
002:    	// 配列を反転するメソッド
003:    	private static void array_reverse( double[] values )
004:    	{
005:    		// 処理回数
006:    		int count = values.length / 2;
007:    		if ( 1 > count ) return;
008:    
009:    		// 交換位置
010:    		int s, e;
011:    
012:    		// 反転処理
013:    		s = 0;			// 先頭の添え字
014:    		e = values.length - 1;	// 最後の添え字
015:    		for ( int i = 0; i < count; ++ i ) {
016:    			// 交換処理
017:    			double w = values[ s ];
018:    			values[ s ] = values[ e ];
019:    			values[ e ] = w;
020:    
021:    			++ s;
022:    			-- e;
023:    		}
024:    	}
025:    
026:    	// メイン
027:    	public static void main( String[] args ) {
028:    		// 数値群
029:    		double[] values = { 5.0,7.0,8.0,1.0,3.0,2.0 };
030:    
031:    		// 配列の値を反転
032:    		array_reverse( values );
033:    
034:    		// 結果を確認
035:    		for ( int i = 0; i < values.length; ++ i ) {
036:    			System.out.println( values[ i ]  );
037:    		}
038:    	}
039:    }

■関連コンテンツ

Javaの配列 同じ型の変数をまとめた配列について解説
for文 繰り返し処理に使用するfor文について解説
変数値の交換 2つの変数値を交換する方法を解説
Javaで扱う変数について解説-画像

Javaの変数

変数は、プログラムの中で値を入れておく入れ物のようなものです。

■新着情報

2022.07.07 外部プログラムの実行 exeファイル実行
2022.07.06 完全数 6=1+2+3

■広告

 

 

 

 

 

スッキリわかるJava入門第3版 [ 中山清喬 ]

価格:2,860円
(2021/6/18 14:32時点)
感想(6件)

 

 

 

 

Topへ