11.Java String/StringBuilder/날짜데이터/Wrapper클래스/컬렉션(Collection API)

2022.07.18.월

---

1.String

		String x3 = "hello";
		System.out.println("8.문자열  연결 : " + x3.concat(" world")); //hello world

		System.out.println("9.문자열 변경 : " + x3.replace('h', 'H'));   //Hello
		System.out.println("9.문자열 변경 : " + x3.replace("he", "HE")); //HEllo
		
		System.out.println("10.부분열 : " + x3.substring(1)); //ello
		System.out.println("10.부분열 : " + x3.substring(1, 4)); //ell, endIndex 포함 안됨
		
		//특정문자를 구분자로 해서 문자열 분리하기
		String xx = "홍길동/이순신/유관순";
		String[] names = xx.split("/");
		System.out.println("특정 문자 구분해서 문자열 구분하기 : " + Arrays.toString(names)); //[홍길동, 이순신, 유관순]
		
		//문자열 ==> 문자의 배열
		String xx2 = "hello";
		char[] chrs = xx2.toCharArray();
		System.out.println(Arrays.toString(chrs)); //[h, e, l, l, o]
		
		//문자열이 아닌값을 문자열로 변경 => static method 제공
		String k = String.valueOf(10); //10
		System.out.println(k);
		String k2 = String.valueOf(new char[] {'h', 'e', 'l', 'l', 'o'}); //hello
		System.out.println(k2);

---

2.StringBuilder

package com.stringbuilder;

public class TestMain 
{
	public static void main(String[] args) 
	{
		//StringBuffer / StringBuilder
		//StringBuffer : 여러 쓰레드가 사용시 하나의 쓰레드만 사용 가능(직렬) 
		//				  즉 순서대로 접근해서 사용, 성능 떨어짐, 데이터 무결성보장O
		//StringBuilder : 동시에 여러 쓰레드가 사용 가능, 성능 좋음, 데이터 무결성보장X  
		
		//생성은  new 이용
		StringBuffer buffer = new StringBuffer("hello");
		StringBuilder builder = new StringBuilder("hello");
		
		System.out.println(buffer);
		System.out.println(builder);
		System.out.println(buffer instanceof StringBuffer);
//		System.out.println(buffer instanceof String); buffer String type 아님
		
		
	}
}

package com.stringbuilder;

public class TestMain2 
{
	public static void main(String[] args) 
	{
		//StringBuilder 클래스 method
		
		StringBuilder builder = new StringBuilder();
		
		System.out.println("1.값 추가 : " + builder.append("Hello")); //Hello
		System.out.println("1.값 추가 : " + builder.append(true)); //Hellotrue
		System.out.println("1.값 추가 : " + builder.append(100)); //Hellotrue100
		System.out.println("1.값 추가 : " + builder.append(new char[] {'h', 'e', 'l', 'l', 'o'})); //Hellotrue100hello
		
		System.out.println("2.중간 삽입 : " + builder.insert(0, "홍길동")); //홍길동Hellotrue100hello
		
		System.out.println("3.삭제 : " + builder.delete(1, 5)); //홍llotrue100hello
		
		System.out.println("4.특정문자얻기 : " + builder.charAt(0)); //홍
		
		System.out.println("5.특정문자 위치값 얻기 : " + builder.indexOf("홍")); //0
		
		System.out.println("6.부분열 : " + builder.substring(1)); //llotrue100hello
		System.out.println("6.부분열 : " + builder.substring(1, 4)); //llo
		
		System.out.println("7.거꾸로 : " + builder.reverse()); //olleh001eurtoll홍
		
		//String 타입에 저장
		String xxx = builder.toString();
		System.out.println("8.String 타입으로 변경 : " + xxx + " " + (xxx instanceof String)); //olleh001eurtoll홍 true
		
		
		//원본출력 : StringBuilder 원본 영향 받음
		System.out.println("원본 : " + builder);
	}
}

---

3.날짜데이터

 -Date

package com.date;

import java.util.Date;

public class TestMain 
{
	public static void main(String[] args) 
	{
		/*
			날짜 데이터
			1.java.util.Date
			
			2.java.util.Calendar(주로 사용)
		 */
		
		//1.java.util.Date 사용
		Date d = new Date();
		System.out.println(d); //Mon Jul 18 10:36:21 KST 2022
		System.out.println(d.getYear()); //deprecated 된 경우
		
	}
}

 -Calendar

package com.date;

import java.util.Calendar;
import java.util.Date;

public class TestMain2 
{
	public static void main(String[] args) 
	{
		/*
			날짜 데이터
			1.java.util.Date
			
			2.java.util.Calendar(주로 사용)
			 => new 이용(x)
			 => Calendar.getInstance() 이용
			 => 직접 new하지 않고 static 메서드인  getInstance() 에서
			         객체 생성해서 반환해주는 방식으로 사용됨
			 => 이유 : new를 여러번 하지 못하게 막기 위함(싱글턴 패턴)
		 */
		
		//1.java.util.Calender 사용
		Calendar cal = Calendar.getInstance();
		
		System.out.println("1.날짜 출력 : " + cal);
		
		int year = cal.get(Calendar.YEAR);
		int month = cal.get(Calendar.MONTH) + 1; //월 : 0 ~ 11로 관리 -> +1 해줘야함
		int day = cal.get(Calendar.DAY_OF_MONTH);
		int hour = cal.get(Calendar.HOUR_OF_DAY);
		int minute = cal.get(Calendar.MINUTE);
		int seconds = cal.get(Calendar.SECOND);
		
		System.out.println("년도 : " + year);
		System.out.println("월 : " + month);
		System.out.println("일 : " + day);
		System.out.println("시 : " + hour);
		System.out.println("분 : " + minute);
		System.out.println("초 : " + seconds);
		
		//특정날짜 설정
		Calendar cal2 = Calendar.getInstance();
		cal2.set(2021, 11, 25);
		
		//Calendar에서 Date 설정
		//cal2.setTime(new Date());
		
		int year2 = cal2.get(Calendar.YEAR);
		int month2 = cal2.get(Calendar.MONTH) + 1; //월 : 0 ~ 11로 관리 -> +1 해줘야함
		int day2 = cal2.get(Calendar.DAY_OF_MONTH);
		
		System.out.println("작년 년도 : " + year2);
		System.out.println("작년 월 : " + month2);
		System.out.println("작년 일 : " + day2);
		
	}
}

---

4.Wrapper클래스

package com.wrapper;

public class TestMain 
{
	public static void main(String[] args) 
	{
		//wrapper 클래스
		//오토박싱, 오토언박싱 : 기본형 <-> 참조형 자동 형변환
		int n = 10; //기본형으로 10생성
		Integer n2 = new Integer(10); //참조형(클래스)으로 10생성
		
		System.out.println(n);
		System.out.println(n2); //n2.toString()
		
		//wrapper 클래스 제공 이유 => 유용한 메서드 및 상수 활용
		System.out.println(Integer.MIN_VALUE); //-2147483648
		System.out.println(Integer.MAX_VALUE); //2147483647
		
		//"10" -> 10
		int x = Integer.parseInt("10");
		System.out.println(x); //10
		//100 -> "100"
		String s = String.valueOf(100);
		System.out.println(s); //100
		
		//최대값 얻기
		int max = Integer.max(100, 101);
		int min = Integer.min(100, 101);
		int sum = Integer.sum(100, 101);
		
		System.out.println(max); //101
		System.out.println(min); //100
		System.out.println(sum); //201
		
	}
}

package com.wrapper;

public class TestMain2 
{
	public static void main(String[] args) 
	{
		//wrapper 클래스
		//오토박싱, 오토언박싱 : 기본형 <-> 참조형 자동 형변환
		int n = 10;
		Integer n2 = new Integer(10);
		
		//1.오토박싱 : 기본형 -> 참조형 자동 형변환
		Integer x = n;
		
		//2.오토언박싱 : 참조형 -> 기본형 자동 형변환
		int x2 = x;
		
		System.out.println(x);
		System.out.println(x2);
		
	}
}

---

5.컬렉션(Collection API)

 -데이터 저장 방법

 -특징

  1)다양한 자료구조  2)참조형만 저장가능(기본형 불가)

  3)컬렉션은 참조형  4)크기변경 가능

  5)type이 달라도 저장가능

 -자료구조

  1)Set 계열 : 값만 저장, 순서X, 중복 저장X

   ->HashSet

package com.set;

import java.util.*;

public class SetTest 
{
	public static void main(String[] args) 
	{
		/* 
			Set계열
			-순서 없고 중복 불가
			-HashSet 클래스 사용
		
			<E> ==> 제네릭스(generics)
			     용도 : 저장할 데이터 타입 제한용도
		 */
//		HashSet set = new HashSet();
		Set set = new HashSet(); //다형성
		
		set.add("홍길동");
		set.add(222);
		set.add(3.13);
		set.add("홍길동"); //중복안됨
		set.add(true); 
		set.add(222); //중복안됨
		set.add(3.13); //중복안됨
		
		//문자열만 가져오자? instanceof 로 ...
		for (Object obj : set) 
		{
			if(obj instanceof String) 
			{
				System.out.println(obj);
			}
		}

		
		//출력하기1
		System.out.println(set); //toString()
		//출력하기2
		for(Object obj : set)
		{
			System.out.println("<<" + obj);
		}
		//출력하기3
		Iterator iter = set.iterator();
		while(iter.hasNext())
		{
			System.out.println("$$" + iter.next());
		}
		
		System.out.println("포함여부 : " + set.contains("홍길동"));
		System.out.println("포함여부 : " + set.contains("이순신"));
		
		System.out.println("삭제 : " + set.remove("홍길동"));
		System.out.println("삭제 : " + set.remove("이순신"));
		System.out.println(set);
		
		System.out.println("크기 : " + set.size());
		
		//clear
		set.clear();
		System.out.println(set);
		
		
		
		
	}
}

package com.set;

import java.util.*;

public class SetTest2 
{
	public static void main(String[] args) 
	{
		/* 
			Set계열
			-순서 없고 중복 불가
			-HashSet 클래스 사용
		
			<E> ==> 제네릭스(generics)
			     용도 : 저장할 데이터 타입 제한용도
			     
			-기본형 데이터는 저장할 때는 반드시  wrapper 사용
			-저장할 때는 기본형 사용가능(오토박싱)
		 */
		
		//제네릭스 -> 기본형 데이터 저장 wrapper클래스 이용
		HashSet<Integer> kk1 = new HashSet<Integer>();
		kk1.add(10);
		HashSet<Boolean> kk2 = new HashSet<Boolean>();
		kk2.add(true);
		HashSet<Float> kk3 = new HashSet<Float>();
		kk3.add(3.14f);
		HashSet<Character> kk4 = new HashSet<Character>();
		kk4.add('A');
		
		//제네릭스 -> 이름만 저장
		HashSet<String> set = new HashSet<String>();
		set.add("홍길동1");
		set.add("홍길동2");
//		set.add(20); //문자열만 저장가능
		
		//출력하기1
		System.out.println(set);
		//출력하기2
		for(String str : set)
			System.out.println(">>" + str);
		//출력하기3
		Iterator<String> iter = set.iterator();
		while(iter.hasNext())
			System.out.println("$$" + iter.next());
		
		
		
		
	}
}

  2)List 계열 : 값만 저장, 배열과 비슷한 구조, 순서O, 중복 저장O

   ->ArrayList

package com.list;
import java.util.*;

public class ListTest 
{

	public static void main(String[] args) 
	{
		/*
			List 계열
			-순서있고 중복허용
			-ArrayList 클래스 사용
		 */
		
//		ArrayList<String> list = new ArrayList<String>();
		List<String> list = new ArrayList<String>(); //다형성
		
		
		list.add("홍길동"); list.add("이순신"); list.add("유관순");
		list.add("홍길동"); list.add("이순신"); list.add("유관순"); //중복가능
		
		//출력하기1
		System.out.println(list); //toString
		//출력하기2
		for(String s : list)
			System.out.println(">>" + s);
		//출력하기3
		for(int i = 0; i < list.size(); i++)
			System.out.println("##" + list.get(i));
		//출력하기4
		Iterator<String> iter = list.iterator();
		while(iter.hasNext())
			System.out.println("$$" + iter.next());
	}

}

package com.list;
import java.util.*;

public class ListTest2 
{

	public static void main(String[] args) 
	{
		/*
			List 계열
			-순서있고 중복허용
			-ArrayList 클래스 사용
		 */
		
		//CRUD : create(저장), read(읽기, 조회), update(수정), delete(삭제)
		List<String> list = new ArrayList<String>(); //다형성
		
		//method
		//추가
		list.add("홍길동"); list.add("이순신"); list.add("유관순");
		
		//삽입
		list.add(0, "강감찬");
		
		//수정
		list.set(1, "아버지");
		
		//삭제
		list.remove(0); //위치
		list.remove("아버지"); //값
		
		System.out.println("특정 값의 위치 : " + list.indexOf("이순신"));
		
		//배열로 바꾸기
		Object[] arr = list.toArray();
		System.out.println(Arrays.toString(arr));
		
		//출력
		System.out.println(list);
	}
}

package com.list;
import java.util.*;

public class ListTest3 
{

	public static void main(String[] args) 
	{
		//List를 매우 쉽게 만드는 법
		
		//1.기본적인 방법
		List<String> list = new ArrayList<String>(); //다형성
		list.add("홍길동"); list.add("이순신"); list.add("유관순");
		System.out.println(list);
		
		//2.Arrays 유틸리티 이용하는 방법
		List<String> list2 = Arrays.asList("홍길동", "이순신", "유관순");
		System.out.println(list2);
		
		List<Integer> list3 = Arrays.asList(0, 1, 2, 3, 4);
		System.out.println(list3);
		
		//이름과 나이 저장
		//홍길동/20, 이순신/40, 유관순/18
		List<Object> xxx = new ArrayList<Object>(); 
		xxx.add("홍길동"); xxx.add(20);
		xxx.add("이순신"); xxx.add(40);
		xxx.add("유관순"); xxx.add(18);

		
		//다음 방법이 가장 많이 사용되는 형태이다
		List<Person> xxx2 = new ArrayList<Person>();
		xxx2.add(new Person("홍길동", 20));
		xxx2.add(new Person("이순신", 40));
		xxx2.add(new Person("유관순", 18));
		
		List<Person> xxx3 
			= Arrays.asList(new Person("홍길동", 20), new Person("이순신", 40), new Person("유관순", 18));
		
		for(Person p : xxx2)
			System.out.println(p);
		
		Iterator<Person> iter = xxx2.iterator();
		while(iter.hasNext())
			System.out.println(iter.next());
		
	}
}

class Person
{
	String name;
	int age;
	
	public Person() {}
	public Person(String name, int age) 
	{
		this.name = name;
		this.age = age;
	}
	//getter
	public String getName() { return name; }
	public int getAge() { return age; }
	//setter
	public void setName(String name) { this.name = name; }
	public void setAge(int age) { this.age = age; }
	//toString 재정의
	@Override
	public String toString() { return "[name=" + name + ", age=" + age + "]"; }
	
	
}

※가변인자

package com.list;

import java.util.Arrays;

public class 가변인자 {

	public static void a2(int... n)
	{
		System.out.println(Arrays.toString(n));
	}

	public static void main(String[] args) 
	{
		a2(10);	
		a2(10, 20);	
		a2(10, 20, 1, 2, 34, 4, 5);	

	}

}

  3)Map 계열 : 값 + 이름(키) 쌍으로 저장 

   ->HashMap

package com.map;
import java.util.*;

public class MapTest 
{

	public static void main(String[] args) 
	{
		/*
			Map 계열
			-Collection API 무관
			-key/value(name/value) 쌍으로 저장
			-key를 이용해서 대부분 관리
			-제네릭스 지원
			-HashMap 클래스 사용
			-Set과 동일하게 순서없이 저장
		 */
		
//		HashMap<String, String> map = new HashMap<String, String>();
		Map<String, String> map = new HashMap<String, String>(); //다형성
		
		//저장
		map.put("A1", "홍길동1");
		map.put("A2", "홍길동2");
		map.put("A3", "홍길동3");
		map.put("A3", "이순신"); //동일한 key인 경우 덮어쓰기 됨
		
		//출력1
		System.out.println(map); //toString()
		//출력2
		System.out.println(map.get("A1"));
		System.out.println(map.get("A2"));
		System.out.println(map.get("A4")); //존재하지 않는 key접근 -> null반환
		//출력3 ==> key값을 먼저 얻고 나중에 value값 얻기
		Set<String> keys = map.keySet(); //데이터가 많거나 또는 키값을 모를 때 사용
		for(String key : keys)
			System.out.println(key + " : " + map.get(key));
		Iterator<String> iter = keys.iterator();
		while(iter.hasNext())
		{
			String s = iter.next();
			System.out.println(s + " | " + map.get(s));
		}

	}

}

package com.map;
import java.util.*;

public class MapTest2 
{

	public static void main(String[] args) 
	{
		//Map 계열
		
		Map<String, String> map = new HashMap<String, String>(); //다형성
		
		//저장
		map.put("A1", "홍길동1");
		map.put("A2", "홍길동2");
		map.put("A3", "홍길동3");
		
		//method
		//size()
		System.out.println(map.size());
		
		//replace()
		System.out.println(map.replace("A3", "유관순")); //replace 변경전 값 반호나
		
		//remove()
		map.remove("A1");
		
		//clear()
		map.clear();
		
		System.out.println(map);
	}

}

  4)중첩 컬렉션(nested Collection)

package com.nested;
import java.util.*;

public class TestMain 
{
	public static void main(String[] args) 
	{
		//중첩 컬렉션
		
		//Map안에 List
		Map<String, ArrayList<String>> map
		 = new HashMap<String, ArrayList<String>>();
		
		//List안에 Map
		List<Map<String, String>> list = new ArrayList<Map<String,String>>();
		
		//Set안에 List
		Set<List<String>> set = new HashSet<List<String>>();
	}
}