[JAVA] 배열의 활용 예제/총합과 평균/ 최대값과 최소값/섞기/난수/정렬/빈도수 구하기

#예5) //총합과 평균

public class ArrayEx5 {
	public static void main(String[] args) {
		int sum = 0; // 총점을 저장하기 위한 변수
		float average = 0.0f; // 평균을 저장하기 위한 변수

		int[] score = { 100, 88, 100, 100, 90 };
		// 반복문을 이용해서 배열에 있는 모든 값들을 더한다.
		for (int i = 0; i < score.length; i++) {
			sum += score[i];
		}
		average = sum / (float) score.length; // 계산 결과를 float로 얻기 위해 형변환
		System.out.println(sum);
		System.out.println(average);

	}
}

for문을 이용해서 배열에 저장된 값들을 모두 더한 다음, 이걸 배열의 개수로 나누어서 평균을 구한다. 

int 연산 int ->int  이기 때문에 float로 나누어 형변환해준다. 

478 /5 ->95

478 / (float)5 ->478 / 0.5f -> 478.0f / 5.0f ->95.6f 

 

 

#예6) //최대값 최소값

public class ArrayEx6 {
	public static void main(String[] args) {
		int[] score = { 79, 88, 91, 33, 100, 55, 95 };

		int max = score[0]; // 배열의 첫번째 값으로 최대값을 초기화
		int min = score[0]; // 배열의 첫번째 값으로 최소값을 초기화

		for (int i = 0; i < score.length; i++) {
			if (score[i] > max) {
				max = score[i];
			} else if (score[i] < min) {
				min = score[i];
			}
		}
		System.out.println("최대값: " + max);
		System.out.println("최소값: " + min);
	}
}

 

배열의 첫번째 요소 'score[0]' 의 값으로 max와 min을  초기화했다. 
그 다음 반복문을 통해서 배열의 두번째 요소 'score[1]'부터 max와 비교하기 시작한다. 
만일 배열에 담긴 값이  max에 저장된 값보다 크다면, 이 값을 max에 저장한다. 

이런식으로 배열의 마지막 요소까지 비교하고 나면 max에는 배열에 담긴 값 중에서 최대값이 저장된다. 
최소값도 같은 방식으로 구한다. 

 

 

 

#예7) //섞기

public class ArrayEx7 {
	public static void main(String[] args) {
		int[] numArr = new int[10]; // 배열의 길이 설정

		// for문으로 배열의 값 넣기
		for (int i = 0; i < numArr.length; i++) {
			numArr[i] = i; // 0~9값 넣기
			System.out.print(numArr[i]); // for문으로 배열 속 값들 모두 출력
		}
		System.out.println(); // 한줄 띄우기

		// 섞기.for문을 이용해서 100번 섞기
		for (int i = 0; i < 100; i++) { // 빈 공간 tmp를 이용해 섞기
			int n = (int) (Math.random() * 10); // 0~9중 임의의 한 값을 얻는다.
			int tmp = numArr[0]; // tmp에 numArr의 값 저장
			numArr[0] = numArr[n];
			numArr[n] = tmp;
		}
		// 100번 섞은 결과를 for문을 이용해 하나씩 출력
		for (int i = 0; i < numArr.length; i++) {
			System.out.print(numArr[i]);

		}
	}
}

길이가 10인 배열 numArr을 생성하고 0~9의 숫자로 차례대로 초기화하여 출력한다. 

그 다음 random()을 이용해서 배열의 임의의 위치에 있는 값과 배열의 첫 번째 요소인 'numArr[0]' 의 값을 교환하는 일을 100번 반복한다. 

두 변수에 담긴 값을 바꾸려면  tmp 같은 별도의 저장공간이 필요하다. 

애초에 중복된 값이 없는 배열에서 값을 섞으면 중복이 발생하지 않는다. 

 

System.out.print(numArr[i]); 는 for문 안에서 

System.out.println(Arrays.toString(numArr)); 는 for 문 밖에서 ;ㅣ 왜냐햐면 안에서 실행하면 출력이 반복됨

import java.util.Arrays;

public class ArrayEx7_2 {
	public static void main(String[] args) {
		int[] numArr = new int[10]; // 길이가 10인 배열 생성

		// for문으로 배열의 모든 값 출력
		for (int i = 0; i < numArr.length; i++) {
			numArr[i] = i; // 0~9의 값을 배열에 값 넣기
			System.out.print(numArr[i]);
		}
		System.out.println();// 한줄 띄우기

		// 섞기 / 배열의 길이만큼 섞자!
		for (int i = 0; i < numArr.length; i++) {
			// 배열의 값들에 임의의 값을 넣어주자.
			int n = (int) (Math.random() * 10); // 0~9까지의 값을 index와 맞춰넣음
			// 빈 저장공간 tmp을 이용해 하나씩 섞기
			int tmp = numArr[i]; // tmp에 numArr[i]넣기
			numArr[i] = numArr[n]; // numArr[n]의 값을 numArr[i]에 넣기
			numArr[n] = tmp; // tmp의 값을 numArr[n]에 넣기
		}
		System.out.println(Arrays.toString(numArr));
//		for(int i=0; i<numArr.length; i++) {
//			System.out.print(numArr[i]);
	}
}

 

 

 

#예8) //로또 번호 

public class ArrayEx8 {
	public static void main(String[] args) {
		int[] ball = new int[45]; // 길이가 45인 배열 생성

		// 배열의 각요소에 1~45의 값을 저장한다.
		for (int i = 0; i < ball.length; i++) {
			ball[i] = i + 1; // 1~45의 값 저장
		}

		int tmp = 0; // 두 값을 바꾸는 데 사용할 변수 설정
		int n = 0; // 임의의 값을 얻어서 저장할 변수
		// 임의의 값에 임의의 값 넣기
		// 배열의 i번째 요소와 임의의 요소에 저장된 값을 서로 바꿔서 값을 섞는다.
		// 0번째부터 5번째 요소까지 모두 6개만 바꾼다.
		for (int i = 0; i < 6; i++) {
			n = (int) (Math.random() * 45); // 인덱스0~44까지 맞춤
			// 섞기
			tmp = ball[i];
			ball[i] = ball[n];
			ball[n] = tmp;
		}
		// 배열ball의 앞에서부터 6개의 요소를 출력한다.
		for (int i = 0; i < 6; i++) {
			System.out.println("ball[i]=" + ball[i]);
		}
	}
}

 

길이가 45인 배열에 1부터 45까지 값을 담은 다음 반복문을 이용해서 배열의 첫 번째 값과 
random()에 의해서 결정된 임의의 위치에 있는 값과 자리를 바꾸는 것을 6번 반복한다.
이것은 1~45까지 번호가 쓰인 카드를 잘 섞은 다음 맨 위 6장을 꺼내는 것과 같다.

 

 

 //임의의 값으로 배열 채우기 

 

배열을 연속적인 임의의 값으로 채우는 것은 random()만 사용하면 쉽게할 수 있다. 

 

for(i=0; i<arr.length; i++){
	arr[i] = (int)(Math.random()*5); //0~4범위의 임의의 값을 저장
}

불연속적인 범위의 값들로 배열을 채우는 것은? 배열을 하나 더 사용한다. 

배열 code에 불연속적인 값들을 담고, 임의로 선택된 index에 저장된 값으로 배열 arr의 요소들을 하나씩 채우면 된다.

저장된 값에 상관없이 index는 항상 연속적이다. 

 

#예9)

import java.util.*;

public class ArrayEx9 {
	public static void main(String[] args) {

		int[] code = { -4, -1, 3, 6, 11 }; // 불연속적인 값들로 구성된 배열
		int[] arr = new int[10]; // 길이가 10인 arr 생성

		for (int i = 0; i < arr.length; i++) {
			int tmp = (int) (Math.random() * code.length);
			arr[i] = code[tmp];
		}
		System.out.println(Arrays.toString(arr));
	}
}

배열 code의 길이가 5이므로 code.length의 값은 5가 된다.
따라서 변수 tmp에는 0~4범위에 속한 임의의 정수가 저장되는데, 이 범위는 배열 code의 index범위와 일치한다.

  int tmp = (int)(Math.random()*code.length);
->int tmp = (int)(Math.random()*5); //tmp에 01,2,3,4 중의 하나가 저장된다.

만일 i의 값이 0이고, tmp의 값이 4라면 arr[0]에는 code[4]의 값인 11이 저장된다. 

 arr[i] = code[tmp]; 
->arr[0] = code[4];
-> arr[0] = 11; 

 

 

#예10) //정렬하기 **(버블정렬)

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

		for (int i = 0; i < numArr.length; i++) {
			System.out.print(numArr[i] = (int) (Math.random() * 10));
		}
		System.out.println();

		for (int i = 0; i < numArr.length - 1; i++) {
			boolean changed = false; // 자리바꿈이 발생했는지 체크

			for (int j = 0; j < numArr.length - 1 - j; j++) {
				if (numArr[j] > numArr[j + 1]) { // 옆의 값이 작으면 서로 바꾼다.
					int tmp = numArr[j];
					numArr[j] = numArr[j + 1];
					numArr[j + 1] = tmp;
					changed = true; // 자리바꿈이 발생했으니 changed를 true로
				}
			}
			if (!changed)
				break; // 자리바꿈이 없으면 반복문을 벗어난다.

			for (int k = 0; k < numArr.length; k++)
				System.out.print(numArr[k]); // 정렬된 결과를 출력한다.
			System.out.println();
		}
	}
}

길이가 10인 배열에 0과 9사이의 임의의 값으로 채운 다음, 버블정렬 알고리즘을 통해서 크기순으로 정렬한다. 

 

배열의 길이가 n일 때, 배열의 첫 번째부터 n-1까지의 요소에 대해, 근접한 값과 크기를 비교하여 자리바꿈을 반복하는 것이다. 

 

for(int j=0; j <numArr.length-1-i; j++){
	//numArr[j]와 바로 옆의 요소 numArr[j+1]을 비교한다.
	if(numArr[j] > numArr[j+1]){    //왼쪽의 값이 크면 서로 바꾼다. 
	int tmp = numArr[j];
	numArr[j] = numArr[j+1];
	numArr[j+1] = tmp;
	}
}

 

 

 

#예11) //빈도수 구하기

public class ArrayEx11 {
	public static void main(String[] args) {
		int[] numArr = new int[10];
		int[] counter = new int[10];
		// 임의의 수를 랜덤으로 배열에 저장
		for (int i = 0; i < numArr.length; i++) {
			numArr[i] = (int) (Math.random() * 10);
			System.out.print(numArr[i]);
		}
		// counter를 이용해서 하나씩 큰지비교
		for (int i = 0; i < numArr.length; i++) {
			counter[numArr[i]]++; // 그 인덱스 값에 있는 counter를 하나씩 증가시킴.counter[i]의 모든 요소는 0이었다가 증가됨
		}
		System.out.println();
		// counter배열의 모든 요소 출력
		for (int i = 0; i < numArr.length; i++) {
			System.out.println(i+"의 개수:" + counter[i]);
		}
	}
}

길이가 10인 배열을 만들고 0~9 의 임의의 값으로 초기화한다. 그리고 이 배열에 저장된 각 숫자가 몇 번 반복해서 나타나는지 세어서 배열 counter에 담은 뒤 출력한다. 

for (int i = 0; i < numArr.length; i++) {
			counter[numArr[i]]++;
		}

random()을 사용했기 때문에 실행할 때마다 결과가 달라진다. 

 

   counter[numArr[i]]++; //i의 값이 0인 경우를 가정하면,

->counter[numArr[0]]++;  //numArr[0]의 값은 2이다. 

->counter[2]++;             //counter[2]의 값을 1증가시킨다. 

 

 

배열 counter 에서, 배열 numArr에 저장된 값과 일치하는 인덱스의 요소에 저장된 값을 1증가시킨다. 

numArr[0]에 2가 저장되어 있으므로 배열 counter의 인덱스가 2인 요소에 저장된 값이 0에서 1로 증가됐다.

이 과정이 반복되면 배열 counter의 각 요소에는 해당 인덱스의 값이 몇 번 나타났는지 알 수 있다.