Author: switch over

A big outdoor sports lover & A IT engineer.

3.配列

2005-02-22 /

3章　配列
1.配列とは
　例えば100個のデータが合った場合、これを変数a1,a1,a3・・・a100と設定したのでは大変だから、メモリー上に100個の連続した領域を確保し、何件ものデータを総括的に扱うことのできる方法を配列という。
　配列の添え字は、0からはじまるプログラム言語と、1から始まるプログラムがある。Javaは0からはじまる。COBOLは1。Javaは、配列を入れるための変数を宣言し配列の領域を確保し、確保した領域を宣言した変数に入れるという操作をしなければならない。領域を確保する際はどのくらいの大きさの配列かを指定しなければならないが、配列を入れるための変数を宣言する際にはどのくらいの大きさかは宣言しなくても構わない。
2.配列の宣言と初期化
Javaでは、配列を使用する場合に配列の最後を越えてアクセスしていないかどうかをチェックしています。つまり10個の要素しかない配列の11番目にアクセスすることはできない。（例外をスローする）
import  java.io.*;

class Test{
    public static void main(String args[ ]){
         int a[ ] ；
         a = new int [10];

         // 要素数が10の配列の11番目にアクセスしようとした　
　　　　// 添え字が0から始まるので、11番目は10になる
　　　　System.out.println(a[10]);
     }
}
C:\java>javac Test.java                                       ←　コンパイルは正常　

C:\java>java Test
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException at Test.main(Test.java:9)
                                                                       ↑　実行時にエラーが出る
C:\java>
配列の領域を確保するのと同時に、初期化を行うこともできる。
　　int raikyaku[ ] = { 1,2,3,4,5 } ;

この場合、配列の大きさは、初期化の際の要素数になる。つまり、上記の例では要素数が５つの配列になる。
実際の配列領域を入れるための変数があるという事は、配列領域を別の変数に代入することもできる。
import java.io.*;　

class Test{
     public static void main (String args[ ]){
          int a[ ] = {  1,2,3,4,5 } ;
          int b[ ] ;

          b = a ;

          System.out.println(b[3]);

          a[3] = 100;

          System.out.println(b[3]);
    }
}
C:\java>javac Test.java

C:\java>java Test
4
100

C:\java>
Javaでは変数を用いて配列の領域確保を行うことができる。すなわち、動的に配列のサイズを変化させることができる。
import java.io.*;

class Test{
    public static void main(String args[ ]) {
         int i = 200;
         int a[ ] = new int [i];
    }
}
3.配列の使用法　
　配列は添え字を用いることで、その要素の読み書きをする。添え字は変数であっても構わない。
　「int型」の要素数１０個の配列を作り、これに１から１０の数字を代入する例
//　添え字に変数を使わない例
import  java.io.*;

class Test{
      public static void main (String args[ ]) {
           int a[ ] = new int [10];

           a[0] = 1;
           a[0] = 2;
           a[0] = 3;
           a[0] = 4;
           a[0] = 5;
           a[0] = 6;
           a[0] = 7;
           a[0] = 8;
           a[0] = 9;
           a[0] = 10;
     }
}
// 添え字に変数を使った例
import  java.io.*;　
　
class Test{　
　   public static void main(String args[ ]){
　       int a[ ] = new int [10];
　      int i;         // 添え字
　
　　　for( i = 0 ; i < 10 ; i++ )
　          a[i] = i+1;
　 }
}
　　
[配列の変数.length]とすることで、配列の大きさを取得できる。
import  java.io.*;　
　
class Test{　
　   public static void main(String args[ ]) {
　       int a[ ] = new int [10];
　      int i;         // 添え字
　
　　　for( i = 0 ; i < a.length ; i++ )
　          a[i] = i+1;
　 }
}
　　
配列のコピー
import  java.io.*;　
　
class Test{　
　   public static void main(String args[ ]){
　       int a[ ] = { 5,4,3,2,1 };
　       int b[ ] = { 1,2,3,4,5 };

  　      // 配列の表示
　　　 showArray(a);
　　　 showArray(b);

  　      // 配列のコピー
  　      // 配列aの10番目からa.length個(すべて)を配列bの0番目へとコピーする
　　　 System.arraycopy(a, 0, b, 0, a.length);　
　
  　      // 配列の表示　
　　　 showArray(a);
　　　 showArray(b);
　  }
　
  　// 配列を表示するメソッド　
　   public static void showArray(  int a[ ] ){
    for( int i = 0 ; i < a.length ; i++ )　
　       System.out.print(i+":"+a[i]+"\t");
　  System.out.println("");
　  }
}
　　
C:\java>javac Test.java

C:\java>java Test
0:5     1:4     2:3     3:2      4:1  ←コピー前のa
0:1     1:2     2:3     3:4      4:5  ←コピー前のb
0:5     1:4     2:3     3:2      4:1  ←コピー前のa
0:5     1:4     2:3     3:2      4:1  ←コピー前のb(コピーされている)

C:\java>
5.２次元配列と多次元配列
　2次元配列とは、配列の配列である。イメージ的には表。1次元配列と同様に、配列を入れるための変数を宣言し、配列領域を確保して変数に代入するとういう手続きが必要になる。
　　int a[ ][ ];                           // 2次元配列をいれるための変数
　　a = new int[3][4];                // 3行4列の2次元配列領域を確保

　　a[0][0] = 10;
　　a[0][1] = 20;
　　a[1][2] = 30;
　　a[2][3] = 40;
　　int a[ ][ ] = new int[3][4];     // 変数宣言と領域確保を同時にしてもよい

　　a[0][0] = 10;
　　a[0][1] = 20;
　　a[1][2] = 30;
　　a[2][3] = 40;
　
10 20 ? ? 　
? ? 30 ?
? ? ? 40
    int a[ ][ ] = { { 0, 1, 2, 3 } , { 4, 5, 6, 7 } , { 8, 9, 10, 11 }  };
    int b[ ][ ] = { { 0            } , { 4, 5,       } , { 8, 9, 10, 11 }  };
    int c[ ][ ] = { { 0, 1, 2, 3 } , { 4, 5, 6, 7 } , {                  }  };
　
配列a（3行4列） 　 配列b（3行） 　 配列ｃ（3行） 　
0 1 2 3 0 X X X 0 1 2 3 X　＝　存在しない領域
4 5 6 7 4 5 X X 4 5 6 7
8 9 10 11 8 9 10 11 X X X X
　

2.制御文

2005-02-21 / / 0 Comments
2章　制御文
1.順次構造
　制御文とは､プログラムの流れを制御するもの。他の多くの言語と同様､上から下にプログラムは実行される。この流れを「順次構造」という。しかし、ある処理を繰り返したり、条件によって異なる処理をさせたい場合は、順次構造以外の流れが必要になる。
　
2.単一分岐
分岐の条件が一つだけの場合を単一分岐という。
変数nが0なら処理1を、
0以外なら処理2を実行する

        |
　   ／＼　
　／n=0 ＼___no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

  if(n==0) {
              　処理1;
  }
  else{
                処理2;
  }

 nがm以上なら処理1を、
未満なら処理2を実行する

        | 
　   ／＼　
　／n≧m ＼___no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

  if(n>=m) {
              　処理1;
  }
  else{
                処理2;
  }

 左記に同じ、
こういう書き方もある

        | 
　   ／＼　
　／ n:0 ＼___<___
　＼      ／        |
  　 ＼／≧        |
        | yes        |
 _______| _____  ______| _______
 |   処理1 _| |   処理2 _|
        |              |
        |←――― l
        |

 
 
 
 
 
 
 

 charの内容が'A'であれば処理1を実行し、それ以外ならば何もしない
        | 
　   ／＼　
  ／ch='A'＼__no__
　＼      ／        |
  　 ＼／           |
        | yes        |
 _______| _____        |
 |   処理1 _|       |
        |              |
        |←――― l
        |

  if(ch=='A') {
              　処理1;
  }
  else{
                処理2;
  }
どの処理の例もすべて、処理後合流していることが重要。多重分岐など含めて必ず合流しなくてはならない。　
import   java.io.*;　

class Test {
     public static void main (String args[ ]) {
          int n;
          n = readNumber( );
          if ( 10 <= N && n < 20 )
              System.out.println("10代");
     }

     // キーボードから数字を入力するメソッド
     public static int readNumber ( ) {
           byte b [ ] = new byte[100];

           try {
                   System.in.read(b);
                   return integer.parselnt((new String(b)).trim());
           } catch (Exception e) {
                  return 0;
           }
      }
}
「10代以上」という条件と「20代未満」という条件を「&&」で区切ることで、その両方を満たす場合に限り以下の文が実行される。
さらに、複数の条件のうちどれか一つでもみたされていれば実行させたい場合は、「&&」の代わりに、「 || 」で区切る。
また、条件が満たされない場合の処理がなければ、「else」文を省略することもできる。
 
3.多重分岐
多重分岐とは、単一分岐を組み合わせたもので､単一分岐の処理の中にまたは条件分岐を含むためのものである。

　　　 |
　   ／＼　
  ／条件1＼___yes
　＼      ／        |
  　 ＼／         ／＼　
　　　 |no   　／条件2 ＼__yes___
　　　 |　　　  ＼       ／          |
　　　 |            ＼／             |
 _______|______  ______| no___   ______|______ 
 |   処理1 _| |   処理2 _|  |___処理3_|
        |              |                 |
        |←――― l ―――――l       
        |

Javaでの表記
    
    
    
    
if(条件1) {
                 if(条件2) {
                               処理3;
             {
             else{
                               処理2;
             }
}
else {
              処理1;
}		 　
下記の例はキーボードから数字を入力し､その数字が負数なら「負数」、0なら「0」、整数なら「整数」と表示する。2例とも同じ結果。
import  java.io.*;

class Test {
       public static void main (String args[]) {
            int n;
            n = readNumber() ;
            if  ( n < 0 ) {
                  System.out.println("負数") ;
            }
            else {
                    if ( n = = 0 ) {
                                System.out.println("0") ;
                    }
                    else {
                           System.out.println("正数") ;
                    }
             }
        }

       // キーボードから数字を入力するメソッド
       public static int readNumber ( ) {
             byte b [] = new byte [100];

             try {
                    System.in.read ( b ) ;
                    return Integer.parselnt ( ( new Stirng ( b ) ).trim ( ) ) ;
             } catch( Exception e) {
                         return 0 ;
             }
       }
}

 import java.io.*;

class Test {
      public static void main(String args[]) {
            int n ;
            n = readNumber ( ) ;
            if  ( n < 0 ) {
                System.out.println("負数") ;
            }
           else if  ( n == 0 ) {
                System.out.println ( "0") ;          
            }
            else {
                   System.out.printin("正数") ;
            }
      }

      // キーボードから数字を入力するメソッド
　　 public static int readNumber ( ) {
               byte b [] = new byte[100] ;

      try {
             System.in.read (b) ;
             return Integer.parselnt ( ( new String ( b ) ).trim( ) ) ;
      } catch ( Exception e) {
             return 0
            }
      }
}

 
　
4.ケース構造
　 3つ以上の異なった処理の中から、条件にあった処理を行うことを多方向分岐という。
例）char の内容が'A'だったらwに65を、'B'ならば66をそれ以外なら0を代入する。
        |
　   ／＼　
　／char  ＼
　＼      ／
  　 ＼／
    　  | "A"       __________________
        |――――|     65 → w  |―――l
   　   | "B"      ___________________          |
        |――――|     66 → w  |―――|
     　 | default  ___________________          |
        |――――|     0 → w    |―――|
    　                                             |
    　  l―――――――――――――l
    　  |		 switch(chara) {
     case'A' : w=65 : break ;
     case'B' : w=66 : break ;
     default :  w=0 :  break ;
}
        |
　   ／＼　
　／char  ＼
　＼      ／
  　 ＼／
    　  | "A"       __________________
        |――――|     65 → w  |―――l
        |            |―――――――――l
    　  | "B"    ↓___________________         
        |――――|     66 → w   |―――l
        |             |―――――――――l
     　 | default ↓__________________          
        |――――|     0 → w    |―――l
    　                                             |
    　  l―――――――――――――l
    　  |		 switch(chara) {
     case'A' : w=65 :
     case'B' : w=66 :
     default :  w=0 :
}
　
5.反復構造(while)
　while文は､前判定型であり、繰り返し処理に入る前に繰り返し条件をチェックする。したがって条件によっては繰り返し処理を1度も実行しない場合もある。
  1から100までの合計を求めてみる。
import java.io.*;

class  Test {
    public static void main (String args[ ]) {
        int n. t;

        n = 1;
        t = 0;

        while (n <= 100) {
             t = t + 1;
             n = n + 1;
        }
        System.out.println("1から100までの合計は"+t+"です") ;
    }
}
   　    　　
while文ではwhileの後の括弧の中に条件式を記述し、その条件式が真になる間処理が繰り返される。もちろん、複数の条件式を「&&」「||」でつなげることもできる。　
　
6.反復構造(do)　
　do～while文は、後判定型であり、繰り返し処理を行った後に繰り返し条件をチェックする。
例）１～100までの合計を求めてみる。　
import java.io.*;

class Test {
      public static void main(String args[ ]) {
              int n. t;
 
              n = 1;
              t = 0;
 
              do { 
                      t = t + n;
                n = n + 1;
              } while(n <= 100);
              System.out.println("1から100までの合計は"+t+"です") ;
      }
} 
 　
　
7.反復構造(for)　
　for文は、前判定型であり、繰り返し処理に入る前に繰り返しチェックする。
for文は、while文に初期設定と、変化式を組み合わせたものです。これまでの例と同様に1～100までの合計を求めてみる。 
import java.io.*;

class Test {
     public static void main (String args[])
          int n. t;

          n =  1;                                                   // 初期設定
          t = 0;                                                　  // 初期設定

          while(n <=100) {
                t = t + n;
                n = t + 1;      // 変化式
　　　　}
         System.out.println("1～100までの合計は"+t+""です") ;
     }
}
　for文ではこれらを一緒に組み込む事ができる。
import java.io.*;　

class Test{
      public static void main(String args[]) {
             int n.t;

             for( n = 1.t = 0 : n <= 100 : n = n + 1) {
                    t = t + n;
             }
             System.out.println("1～100までの合計は"+t+"です") ;
       }
}
すなわち　
　　　　　　　for ( 初期設定 ; 条件式 ; 変化式 )
                            　繰り返し処理
import java.io.*;

class Test {
      public static void main (String args[]) {
           int n. t;

           n = 1 ;
           t = 0 ;

          for( ; n <=100 : n = n + 1) {
               t = t + n :
          System.out.println("1～100までの合計は"+t+"です") ;
     }
}

 import java.io.*;

class Test {
     public static void main(String args[]) {
           int n. t;

           n = 1;                                                       // 初期設定
           t = 0 ;                                                       // 初期設定

　　　　  for ( : n <= 100 ; n = n + 1)
                    t = t + n ;

           System.out.println("1～100までの合計は"+t+"です") ;
     }
}

　
8.補助制御文　
　実際のプログラムでは、反復処理中に処理から抜け出した方がプログラムがすっきり書ける場合も少なくない。
　break 「while」「for」 などの反復処理中に使用すると、強制的に反復処理を抜ける。
　continue 反復構造中に使用すると、反復処理が終了した事になる。条件が真ならば再度反復処理。
　return 関数から抜ける。
●　キーボードから月（1～12）を入力し、その月の日数を表示するプログラム
import java.io.*;

class Test {
     public static void main (String args[]) {
          int month;
          System.out.print("月（1～12）を入力してください　:　") ;
          month = readNumber( ) ;

          swtich (month) {
          case 1;
          case 3;
          case 5;
          case 7;
          case 8;
          case 10;
          case 12;
                System.out.println(month+"月は31日です") ;
                break ;
          case 2;
                System.out.println(month+"月は28日か29日です") ;
                break ;
          case 4;
          case 6;
          case 9;
          case 11;
                System.out.println(month+"月は30日です") ;
                break ;
          default ;
                System.out.println("1～12を入力してください") ;
          }
     }

     // キーボードから数字を入力するメソッド
     public static int readNumber( ) {
           byte b[] = new byte[100];

           try {
                   System.in.read(b) ;
                   return Integer.parselnt((new String(b)) . trim( )) ;
           } catch (Exception e) {
                   return 0 ;
           }
      }
}
　
11.多重ループの抜け方　
class Test{
     public static void main (String args[]) {
          boolean bContinue = true;
          for(  int i = 0 ; i < 10 && bContinue : i++ ) {
                 for( int  j = 0 : j < 10 && bContinue : i++ ) {
                      System.out.println("i =" + i + " j=" + j ) ;
                      if ( i == 5 && j == 5 ) {
                          bContinue = false ;
                          break ;
                      }
                 }
           }
      }
}　
上記の例では処理が少ないからこれでもスッキリして見えるが、処理が複雑になると、上述のようにひとつめのfor文の条件にフラグ判定をいれるのではなく、入れ子になっているfor文が終わった場所にif文で更に条件分岐が必要になる場合もある。
class Test{ｃ　
     public static void main (String args[]) {
          boolean bContinue = true;
          for ( int i = 0 ; i < 10 && bContinue ; i++  ) {
                for ( int j = 0 ; j < 10 ; j++ ) {
                      System.out.println("i=" + i + " j=" + j ) ;
                      if ( i == 5 && j == 5 ) {
                          bContinue = false;
                          break ;
                      }
                }
                if ( !bContinue )
                    break ;
           }
      }
}
これでもまだ余分な処理が書かれていないからいいが、これが実際にプログラムになると他にもいろいろ入ってくるからみにくい。
実はJavaではforやwhileといった反復構造のみにラベルを使用することができ、break文でどのループを抜け出すか指定ができる。
class Test{
     public static void main (String args[]) {
     LOOP1;
     for ( int i = 0 : i < 10 : i++  ) {
            for( int j = 0 : j < 10 : i++ ) {
                 System.out.println("i=" + i + " j=" + j ) ;
                 if ( i == 5 && j == 5 ) {
                      break LOOP1 ;
                 }
            }
         }
    }
}
　

胸騒ぎ

2005-02-03 / / 0 Comments

　最近、ふとよく思うことがある。
　世界中で、大地震・大津波・災害・異常気象・・・・・・・TVでは「今、東京で大地震がおきたら～～～～」的な番組が多数放映され、地震の周期的にも今この瞬間いつ大地震が起きてもおかしくないという。
　動物には、人間にはない危険予測能力が備わっているのであろうか、いや人も以前は持っていた能力を忘れてしまったのであろうか。
　想像もしたくないが、明日自分の命が必ずしもあるとは限らない。今そこにある危機は迫っているのかもしれない。ならば、ますます今この瞬間を大切に生きていくべきである。思いきって何かに挑戦してみよう、でないと・・・・・・・って――――――――――――――――――――
　今の自分は少し悲観的・マイナス思考気味なのかもしれない。人生のあらゆるものが思い通りにならない苛立ち・あせりで臆病になっているのかもしれない。もっと能天気に明るく生きるのがおそらくいいのであろう。
　もう一度、失敗を恐れず・傷つくことを恐れず挑戦してみよう。七転び八起きどころではなく、千転び千一起きだ。その繰り返しが人をタフにしていくはずだ！って言い聞かせている。