빅데이터 Java 개발자 교육 - 12일차 [REST API DB자료전송]

지난 11일차에는 REST API를 배웠었다.

지난 글에서는 양이 많아서 포스팅 내용에 포함하진 못했지만, 타이타닉호의 탑승자 정보를 바탕으로 REST API를 실습하여 자료값을 받아오는부분까지 했었다.

https://raw.githubusercontent.com/AISPUBLISHING/dsfs-python/master/titanic.json

package day11;

import lombok.Data;

@Data
public class Titanic {
	
	private String name = null; // 이름
	private String survived = null; //생존여부	0 = No, 1 = Yes
	private int pclass = 0; // 티켓 등급	1 = 1st, 2 = 2nd, 3 = 3rd
	private String sex = null; // 성별
	private Float age = 0.0f; // 나이
	private int sibsp = 0; // 타이타닉에 탑승한 형제/자매 수
	private int parch = 0; // 타이타닉에 탑승한 부모/자녀 수
	private String ticket = null; // 티켓번호
	private Float fare = 0.0f; // 운임(티켓요금)
	private String cabin = null; // 객실 번호
	private String embarked = "C"; // 탑승한 곳(항구)	C = Cherbourg, Q = Queenstown, S = Southampton
	private int passengerId = 0;
}

package day11;

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

import org.bson.Document;
import org.json.JSONArray;
import org.json.JSONObject;

import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;

import day8.Config;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class RestClientTitanic {
	private MongoCollection<Document> titanic = null;
	private MongoCollection<Document> sequence = null;

	final String URL = "https://raw.githubusercontent.com/AISPUBLISHING/dsfs-python/master/titanic.json";
	private String data = null;

	public RestClientTitanic() {

		this.sequence = MongoClients.create(Config.URL).getDatabase(Config.DBNAME).getCollection(Config.RESEQUENCECOL);
		this.titanic = MongoClients.create(Config.URL).getDatabase(Config.DBNAME).getCollection(Config.TITANICOL);

		try {
			OkHttpClient client = new OkHttpClient();
			Request request = new Request.Builder().url(URL).get().build();
			Response response = client.newCall(request).execute();

			if (response.isSuccessful()) {
				this.data = response.body().string().toString();

			}
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public List<Titanic> paraseData() {
		List<Titanic> list = new ArrayList<>();
		// [ {0},{},{},{}....{n} ]
		JSONArray jary = new JSONArray(this.data);
		for (int i = 0; i < jary.length(); i++) {
			JSONObject jobj = jary.getJSONObject(i).getJSONObject("fields");

			Titanic t1 = new Titanic();

			t1.setFare(jobj.getFloat("fare"));
			t1.setName(jobj.getString("name"));
			t1.setAge(0.0f);
			t1.setCabin("정보없음.");
			t1.setParch(0);
			t1.setPclass(0);
			t1.setSex("정보없음.");
			t1.setSurvived("정보없음.");
			t1.setEmbarked("정보없음.");
			t1.setTicket("정보없음.");
			t1.setPassengerId(0);
			t1.setSibsp(0);

			if (!jobj.isNull("survived")) {
				t1.setSurvived(jobj.getString("survived"));
			}
			if (!jobj.isNull("pclass")) {
				t1.setPclass(jobj.getInt("pclass"));
			}
			if (!jobj.isNull("sex")) {
				t1.setSex(jobj.getString("sex"));
			}
			if (!jobj.isNull("age")) {
				t1.setAge(jobj.getFloat("age"));
			}
			if (!jobj.isNull("sibsp")) {
				t1.setSibsp(jobj.getInt("sibsp"));
			}
			if (!jobj.isNull("parch")) {
				t1.setParch(jobj.getInt("parch"));
			}
			if (!jobj.isNull("fare")) {
				t1.setFare(jobj.getFloat("fare"));
			}
			if (!jobj.isNull("ticket")) {
				t1.setTicket(jobj.getString("ticket"));
			}
			if (!jobj.isNull("cabin")) {
				t1.setCabin(jobj.getString("cabin"));
			}
			if (!jobj.isNull("passengerId")) {
				t1.setPassengerId(jobj.getInt("passengerId"));
			}
//			if (jobj.getString("embarked").equals("C")) {
//				System.out.println("셰르부르");
//			}
//			else if(jobj.getString("embarked").equals("Q")){
//				System.out.println("퀸스타운");
//			}
//			else if(jobj.getString("embarked").equals("S")){
//				System.out.println("사우샘프턴");
//			}  // 강사님께 2/14일에 질문하기. 
			if (!jobj.isNull("embarked")) {
				t1.setEmbarked(jobj.getString("embarked"));
			}
			list.add(t1);
		}
		return list;
	}

	public void saveMongoDB() {
		try {
			Document doc = this.sequence.findOneAndUpdate
					(Filters.eq("_id", "SEQ_TITANIC_CODE"), Updates.inc("idx", 1));
			long code = doc.getLong("idx");
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

package day11;

import java.util.List;

public class MainTaitanic {

	public static void main(String[] args) {
		RestClientTitanic titanic = new RestClientTitanic();
		List<Titanic> list = titanic.paraseData();
		System.out.println("------------------------");
		System.out.println("    타이타닉호 탑승자 명단");
		System.out.println("------------------------");
		for (Titanic t : list) {
			System.out.println("이름 : " + t.getName());
			System.out.println("생존여부 : " + t.getSurvived());
			System.out.println("티켓등급 : " + t.getPclass());
			System.out.println("성별 : " + t.getSex());
			System.out.println("나이 : " + t.getAge());
			System.out.println("동승한 형제/자매 수 : " + t.getSibsp());
			System.out.println("동승한 부모/자녀 수  : " + t.getParch());
			System.out.println("티켓번호 : " + t.getTicket());
			System.out.println("운임요금 : " + t.getFare());
			System.out.println("객실번호 : " + t.getCabin());
			System.out.println("승객ID : " + t.getPassengerId());
			System.out.println("탑승한 곳 : " + t.getEmbarked());
			System.out.println("------------------------");
		}
	}

}

결과값은 바로 위의 사진처럼 나오게 된다.

(너무 많아서 부분만)

그렇다면 오늘은 이렇게 받은 파일을 토대로 MongoDB에 저장을 해보도록 하겠다.

먼저 MongoDB에 저장을 도와줄 메소드이다.

// 타이타닉 칸 생성
   private MongoCollection<Document> titanicCollection = null;

// 생성자 안
    MongoClient dbClient = MongoClients.create(Config.URL);
    this.titanicCollection = dbClient.getDatabase(Config.DBNAME).getCollection(Config.TITANICCOL);

메소드를 구성하기전 먼저 위의 코드들을 넣어준다.

public void saveMongodDB() {
		List<Titanic> list = this.paraseData();
		//List<Titanic>  => List<Document>
		List<Document> saveList = new ArrayList<Document>();
		for( Titanic tmp : list ) {
			Document doc = new Document();
			doc.append("fare", tmp.getFare());
			doc.append("survived", tmp.getSurvived());
			doc.append("pclass", tmp.getPclass());
			doc.append("sex", tmp.getSex());
			doc.append("sibsp", tmp.getSibsp());
			doc.append("parch", tmp.getParch());
			doc.append("ticket", tmp.getTicket());
			doc.append("cabin", tmp.getCabin());
			doc.append("embarked", tmp.getEmbarked());
			doc.append("name", tmp.getName());
			doc.append("passengerid", tmp.getPassengerId());
			doc.append("age", tmp.getAge());
			doc.append("regdate", new Date());
			doc.append("age", tmp.getAge());

			saveList.add(doc);
		}
		
		InsertManyResult result = titanicCollection.insertMany( saveList );
		System.out.println(result);
	}
}

이후 MongoDB에 들어갈 필드들을 위처럼 구성해준 뒤 메인에서 실행시키면

package day12;

import day11.RestClientTitanic;

public class Main {

	public static void main(String[] args) {
		RestClientTitanic obj = new RestClientTitanic();
		obj.saveMongodDB();
	}

}

성공적으로 DB로 들어간것을 확인할 수 있다.
이후 DB에서 확인들 해보면..

(891명 ㄷㄷ; 너무많고..)

성공이다.

​

추가로 _id칸을 보면 이전과 달리 암호화키로 이상한 문자들이 구성되어있는것을 볼 수 있는데,

지난번 실습때처럼 시퀀스 (sequnce)값을 따로 지정하지도 않았기 때문이다.

지난번 실습들에서는 DB에서 시퀀스의 이름을 만든 후 DB의 데이터 가짓수가 증가할 수 있도록 idx를 할당해주었는데

이번에는 이런 과정없이 바로 DB로 직행했다.

위 사진은 예전 책정보 DB넣기 실습때 시퀀스를 추가했던 방법이다.

추후에 생각나지 않을 때 참고하도록 하자.

---

이번에는 interface를 구성,

DB에 있는 자료들을 불러와서 출력하는 실습을 진행해보도록 하겠다.

package day12;

import java.util.List;
import java.util.Map;

import day11.Titanic;

// 메소드 정의

public interface TitanicDB {

	// 전체조회
	public List<Titanic> selectTitanicList();

	// 전체조회 Map방식
	public List<Map<String, Object>> selectTitaniListMap();

	// 나이순으로 정렬한 후 n명 조회
	public List<Titanic> selectTitanicAge(int n);
}

먼저 위와 같이 interface를 구성해준다.

package day12;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;

import day11.Titanic;
import day8.Config;

public class TitanicDBImpl implements TitanicDB {
	private MongoCollection<Document> titanic = null;

	// 1. titanic 컬렉션 접속하기
	public TitanicDBImpl() {
		try {
			this.titanic = MongoClients.create(Config.URL).getDatabase(Config.DBNAME).getCollection(Config.TITANICCOL);

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// 전체조회
	@Override
	public List<Titanic> selectTitanicList() {
		try {
			// 반환 타입
			List<Titanic> list = new ArrayList<>();
			// _id (시퀀스 대신값)
			Bson sort = Filters.eq("fare", 1);
			// 원본 타입
			FindIterable<Document> docs = this.titanic.find().sort(sort);
			for (Document doc : docs) { // 원본데이터 반복
				Titanic titanic = new Titanic();
				// age가 원래 float이었으나, getFloat이 되지않아 double로 바꿈.
				// titanic.setAge(doc.getDouble("age").floatValue()); 도 가능!! (더블로 빼고 다시 float으로
				// 바꿔주기)
				titanic.setName(doc.getString("name"));
				titanic.setSurvived(doc.getString("survived"));
				titanic.setPclass(doc.getInteger("pclass"));
				titanic.setSex(doc.getString("sex"));
				titanic.setAge(doc.getDouble("age")); // float은 어떻게 받아와야할까
				titanic.setSibsp(doc.getInteger("sibsp"));
				titanic.setParch(doc.getInteger("parch"));
				titanic.setTicket(doc.getString("ticket"));
				titanic.setFare(doc.getDouble("fare"));
				titanic.setCabin(doc.getString("cabin"));
				titanic.setEmbarked(doc.getString("embarked"));
				titanic.setPassengerId(doc.getInteger("passengerid"));
				titanic.setDate(doc.getDate("regdate"));

				list.add(titanic);
			}
			return list;

		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	// Map 방식 전체조회
	@Override
	public List<Map<String, Object>> selectTitaniListMap() {
		try {
			// 원본 타입
			FindIterable<Document> docs = this.titanic.find().sort(Filters.eq("fare", 1));
			// 빈 배열 list 선언
			List<Map<String, Object>> list = new ArrayList<>();
			for (Document doc : docs) {
				Map<String, Object> map = new HashMap<>(); // 형태가 Map<String, Object> 이기 때문에 key, value 대로 입력해준다.
				map.put("name", doc.getString("name"));
				map.put("survived", doc.getString("survived"));
				map.put("pclass", doc.getInteger("pclass"));
				map.put("sex", doc.getString("sex"));
				map.put("age", doc.getDouble("age")); // float은 어떻게 받아와야할까
				map.put("sibsp", doc.getInteger("sibsp"));
				map.put("parch", doc.getInteger("parch"));
				map.put("ticket", doc.getString("ticket"));
				map.put("fare", doc.getDouble("fare"));
				map.put("cabin", doc.getString("cabin"));
				map.put("embarked", doc.getString("embarked"));
				map.put("passengerid", doc.getInteger("passengerid"));
				map.put("regdate", doc.getDate("regdate"));
				list.add(map);
			}
			if (!list.isEmpty()) {
				return list;
			}

		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return null;
	}

	//
	@Override
	public List<Titanic> selectTitanicAge(int n) { // n 값을 입력
		// 891개를 가
		Bson sort = Filters.eq("age", -1); // 내림차순 (나이 많은사람부터)
		List<Titanic> list = new ArrayList<>(); // 빈 배열 생성
		FindIterable<Document> docs = this.titanic.find().sort(sort).limit(n);

		for (Document doc : docs) { // 원본데이터 반복
			Titanic titanic = new Titanic();
			// age가 원래 float이었으나, getFloat이 되지않아 double로 바꿈.
			// titanic.setAge(doc.getDouble("age").floatValue()); 도 가능!! (더블로 빼고 다시 float으로
			// 바꿔주기)
			titanic.setName(doc.getString("name"));
			titanic.setSurvived(doc.getString("survived"));
			titanic.setPclass(doc.getInteger("pclass"));
			titanic.setSex(doc.getString("sex"));
			titanic.setAge(doc.getDouble("age")); // float은 어떻게 받아와야할까
			titanic.setSibsp(doc.getInteger("sibsp"));
			titanic.setParch(doc.getInteger("parch"));
			titanic.setName(doc.getString("ticket"));
			titanic.setFare(doc.getDouble("fare"));
			titanic.setCabin(doc.getString("cabin"));
			titanic.setEmbarked(doc.getString("embarked"));
			titanic.setPassengerId(doc.getInteger("passengerid"));
			titanic.setDate(doc.getDate("regdate"));

			list.add(titanic);
		}
		return list;

	}
}

원래는 위의 세가지 기능만 있었으나, 블로그 주인장이 아래의 메소드 기능도 추가해보았다.

	@Override
	public List<Titanic> selectTitanicEmbarkedList(String E) {
		try {
			Bson sort = Filters.eq("fare", -1);
			Bson filter = Filters.eq("embarked", E);
			FindIterable<Document> docs = this.titanic.find(filter).sort(sort);
			List<Titanic> list = new ArrayList<>();
			for (Document doc : docs) { // 원본데이터 반복
				Titanic titanic = new Titanic();
				// age가 원래 float이었으나, getFloat이 되지않아 double로 바꿈.
				// titanic.setAge(doc.getDouble("age").floatValue()); 도 가능!! (더블로 빼고 다시
				// float으로바꿔주기)
				titanic.setName(doc.getString("name"));
				titanic.setSurvived(doc.getString("survived"));
				titanic.setPclass(doc.getInteger("pclass"));
				titanic.setSex(doc.getString("sex"));
				titanic.setAge(doc.getDouble("age")); // float은 어떻게 받아와야할까
				titanic.setSibsp(doc.getInteger("sibsp"));
				titanic.setParch(doc.getInteger("parch"));
				titanic.setTicket(doc.getString("ticket"));
				titanic.setFare(doc.getDouble("fare"));
				titanic.setCabin(doc.getString("cabin"));
				titanic.setEmbarked(doc.getString("embarked"));
				titanic.setPassengerId(doc.getInteger("passengerid"));
				titanic.setDate(doc.getDate("regdate"));

				list.add(titanic);
			}
			return list;

		} catch (Exception e) {
			e.printStackTrace();
			return null;

		}

	}

기능은 간단하게 출발 항구 이니셜 코드를 입력하면

해당 항구에서 타이타닉호에 탑승한 승객들의 명단을 불러오도록 코드를 설정해보았다.

package day12;

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

import day11.Titanic;

public class Main {

	public static void main(String[] args) {
		// 객체 생성
		TitanicDB tDB = new TitanicDBImpl();
        Scanner sc = new Scanner(System.in);
		System.out.println("조회 가능한 코드는 C, Q, S 세가지 입니다.");
		System.out.print("조회하고자 하는 항구의 코드를 입력해주세요. : ");

		String code = sc.next();
		List<Titanic> list = tDB.selectTitanicEmbarkedList(code);
		if (code.equals("C")) {
			code = "Cherbourg";
		} else if (code.equals("Q")) {
			code = "Queenstown";
		} else if (code.equals("S")) {
			code = "Southampton";
		}
		for (Titanic t : list) {
			System.out.println(t.getName());
			System.out.println();
		}
		if (list.isEmpty()) {
			System.out.println("Error!! 입력값을 확인해주세요.");
		}
		System.out.println("----------------------------");
		System.out.println("[ " + code + " ]" + " 항구 출발 승객명단");
		System.out.println("----------------------------");
		sc.close();
    }
}

기존에 DB에 저장되어있던 코드는 C, Q, S 세가지였는데, 출력했을때 항구의 이름이 떠서 구별이 쉽게끔

메인클래스에 기능을 추가하여 코드를 구성해보았다.

(뭔가 메인클래스가 좀 지저분한것같지만..ㅎㅎ)

메인 클래스를 Run 시키면 위와 같은 화면이 출력된다.

여기서 'C'를 입력하게 되면,

이런 식으로 결과값이 도출되게 된다.

이후에는 이러한 기능을 사용하여 출력만을 도맡아서 수행하는 클래스도 만들어주었다.

package day12;

import java.util.Iterator;
import java.util.List;

import day11.Titanic;

// 출력하는 곳
public class Print {

	// 전체 목록을 받아서 생존자의 인원수를 구하시오.

	public void printSurvived(List<Titanic> list) {
		// 전체목록 입력
		int cnt = 0;
		for (Titanic t : list) {
			if (t.getSurvived().equalsIgnoreCase("yes")) {
				cnt++;
			}
		}
		System.out.println("총 생존자는 " + cnt + "명 입니다.");
	}

	// 전체 목록을 받아서 연령대별 인원수를 구하시오. (단 0은 제회)
	// 단, 0살로 나오는 사람은 제외, 0.01~9, 9~19 등..
	public void printAge(List<Titanic> list) {
		int[] idx = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
		// ------------------------------------------
		int i = 0;
		while (i < list.size()) {
			Titanic t = list.get(i);

			if (t.getAge() > 0) {
				int n = t.getAge().intValue() / 10;
				idx[n]++;
			}
			i++;
		}
		for (i = 0; i < idx.length; i++) {
			System.out.println(i * 10 + "대 => " + idx[i] + "명");
		}
		// ------------------------------------------

//		for (Titanic t : list) {
//			if (t.getAge() > 0 && t.getAge() <= 9) {
//				idx[0]++;
//			} else if (t.getAge() <= 19) {
//				idx[1]++;
//			} else if (t.getAge() <= 29) {
//				idx[2]++;
//			} else if (t.getAge() <= 39) {
//				idx[3]++;
//			} else if (t.getAge() <= 49) {
//				idx[4]++;
//			} else if (t.getAge() <= 59) {
//				idx[5]++;
//			} else if (t.getAge() <= 69) {
//				idx[6]++;
//			} else if (t.getAge() <= 79) {
//				idx[7]++;
//			} else if (t.getAge() <= 89) {
//				idx[8]++;
//			}
//		}
//		System.out.println("---------------------");
//		System.out.println("어린이 수 : " + idx[0] + "명");
//		System.out.println("10대 수 : " + idx[1] + "명");
//		System.out.println("20대 수 : " + idx[2] + "명");
//		System.out.println("30대 수 : " + idx[3] + "명");
//		System.out.println("40대 수 : " + idx[4] + "명");
//		System.out.println("50대 수 : " + idx[5] + "명");
//		System.out.println("60대 수 : " + idx[6] + "명");
//		System.out.println("70대 수 : " + idx[7] + "명");
//		System.out.println("80대 수 : " + idx[8] + "명");
//		System.out.println("---------------------");

		// ------------------------------------------

	}

	// 전체 목록에서 pclass값의 종류별 갯수를 구하시오.(종류는 1,2,3)
	public int[] printPclass(List<Titanic> list) {
		int[] idx = { 0, 0, 0, 0 };
		for (Titanic t : list) {
			int n = t.getPclass();
			idx[n]++;

			// ------------------------------------------
//			if (t.getPclass() == 1) {
//				idx[0]++;
//			} else if (t.getPclass() == 2) {
//				idx[1]++;
//			} else if (t.getPclass() == 3) {
//				idx[2]++;
//			}
			// ------------------------------------------

		}
		return idx;

	}

	// 전체 목록에서 운임요금(fare) 30보다 큰것만 fare와 name으로 출력. (단, fare는 소수점을 올림하여 정수로 표시)
	public void printFare(List<Titanic> list) {
		for (Titanic t : list) {
			if (t.getFare() > 30) {
				System.out.println("이름 : " + t.getName());
				System.out.println("요금 : " + t.getFare().intValue() + "$");
				System.out.println("----------------------------------------");
			}
		}
	}

	// 전체 목록에서 이름(name)에서 Mr. Miss. Mrs. 를 각각 포함하는 인원수를 구하시오.
	public void printName(List<Titanic> list) {
		int[] idx = { 0, 0, 0 };
		// int idx = new int idx[3];
		for (Titanic t : list) {
			if (t.getName().contains("Mr.")) {
				idx[0]++;
			} else if (t.getName().contains("Miss.")) {
				idx[1]++;
			} else if (t.getName().contains("Mrs.")) {
				idx[2]++;
			}
		}
		System.out.println("성인남성 수 : " + idx[0] + "명");
		System.out.println("미혼여성 수 : " + idx[1] + "명");
		System.out.println("기혼여성 수 : " + idx[2] + "명");
	}

	// 연령대별 생존자수 구하기 (전체 생존자 수 891명, 비율은 소수점으로 표시)
	public void printAgeSurvived(List<Titanic> list) {
		// 0.01~9까지, 연령대별 인원수를 구하고 연령대별 생존자수 구하기
		// 생존자수 / 전체인원 * 100
		int[] idx1 = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
		int[] idx2 = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

		// ------------------------------------------
		int i = 0;
		for (Titanic t : list) {

			if (t.getAge() > 0) {
				int n = t.getAge().intValue() / 10;
				idx1[n]++;
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[n]++;
				}
			}
		}
		for (i = 0; i < idx1.length; i++) {
			System.out.println(i * 10 + "대 생존자 => " + idx1[i] + "명");
			System.out.println(i * 10 + "대 생존자 비율 => " + (float) idx2[i] / idx1[i] * 100);
			System.out.println("----------------------------");

		}
	}

	// 성별 생존자수 구하기 (전체 생존자 수 891명, 비율은 소수점으로 표시)
	public void printSexSurvived(List<Titanic> list) {
		// 남녀 인원수 구하기, 남녀 생존자수 구하기
		// 생존자수 / 전체인원 * 100
		int idx1[] = { 0, 0 };
		int idx2[] = { 0, 0 };

		for (Titanic t : list) {
			if (t.getSex().equals("male")) {
				idx1[0]++; // 남자전체수
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[0]++; // 남자생존자
				}
			} else if (t.getSex().equals("female")) {
				idx1[1]++;
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[1]++;
				}
			}
		}
		System.out.println((float) (idx2[0] / (float) idx1[0]) * 100);
		System.out.println((float) (idx2[1] / (float) idx1[1]) * 100);
		System.out.println("----------");
	}

// 티켓 등급별 생존자수 구하기 (전체 생존자 수 891명, 비율은 소수점으로 표시)
	public void printPClassSurvived(List<Titanic> list) {
		// 남녀 인원수 구하기, 남녀 생존자수 구하기
		// 생존자수/전체인원*100
        int[] idx1 = new int[4];
		int[] idx2 = new int[4];

		for (Titanic t : list) {
			if (t.getPclass() == 1) {
				idx1[1]++;
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[1]++;
				}
			} else if (t.getPclass() == 2) {
				idx1[2]++;
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[2]++;
				}
			} else if (t.getPclass() == 3) {
				idx1[3]++;
				if (t.getSurvived().equalsIgnoreCase("yes")) {
					idx2[3]++;
				}
			}
		}
		for (int i = 1; i < 4; i++) {
			System.out.println(i + "등급 대 생존자 => " + idx2[i] + "명");
			System.out.println(i + "등급 대 생존자 비율 => " + (float) idx2[i] / (float) idx1[i] * 100);
			System.out.println("-------------------------");
		}
	}

	// for문 사용해서 출력
	public void printListAll0(List<Titanic> list) {

		for (Titanic t : list) { // 너무 기니까 이정도만.
			System.out.println(t.getName());
		}
		for (int i = 0; i < list.size(); i++) {
			Titanic t = new Titanic();
			System.out.println(t.getName());
		}

	}

	// while문 이용해서 출력
	public void printListAll1(List<Titanic> list) {
		Iterator<Titanic> cursor = list.iterator(); // 변환해줘야함
		while (cursor.hasNext()) { // 만약 list값이 계속해서 다음값이 존재한다면
			Titanic c = cursor.next();
			System.out.println(c.getName());
		}

		int i = 0; // 초기값
		while (i < list.size()) {
			Titanic c = list.get(i);
			System.out.println(c.getName());
		}
	}

	// do-while문 이용해서 출력
	public void printListAll2(List<Titanic> list) {
		int i = 0;
		do {
			Titanic c = list.get(i);
			System.out.println(c.getName());
			i++; // 증가값
		} while (i < list.size()); // 조건

	}

}

위와 같이 코드를 구성하였다.

예시로 '티켓 등급별 생존자수 구하기' 를 수행해보면..

이러한 식으로

각 행선 등급별의 승객들의 생존자 수와 더불어

각 등급의 생존 비율에 대해서 나타내준다.

(아이러니하게도 1등급대가 제일 생존률이 높다..)

---