자바 - List & ArrayList

지환·2023년 10월 13일
0

JAVA

목록 보기
30/39
post-thumbnail

List< object >

  1. List-ArrayList
  • 싱글스레드에서 안전하다.

-> 단점은 인터셉트 당할 수 있다.

  1. Vector - 멀티스레드에서 안전하다.
  • 읽기 쓰기 속도가 느리다.(ArrayList보다)

ArrayList

(1)


package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		ArrayList fruits = new ArrayList();
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		fruits.add(1,"❤️");
		fruits.add(1,"👍"); 
		/*
		 * 끼워 넣기 부분 
		 */
		
		System.out.println(fruits.get(0));
		System.out.println(fruits.get(1));
	}

}
----------------------------------------------
😊
👍

(2)

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		ArrayList fruits = new ArrayList();
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		fruits.add(1,"❤️");
		fruits.add(1,"👍"); 
		/*
		 * 끼워 넣기 부분 
		 */
		
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i)); 
			/*
			 * 하트가 밀려난다.
			 */
		}
		
	}

}
------------------------------------------
😊
👍
❤️
  • 하트가 밀려난다. , 그리고 for문 돌릴 때 size()로 한다.

(3) 형 변환

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		
		String s1 = null;
		String s2 = null;
		String s3 = null;
		ArrayList fruits = new ArrayList();
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		s1=(String)fruits.get(0);
		fruits.add(1,"❤️");
		s2 =(String)fruits.get(1);
		fruits.add(1,"👍"); 
		s3 = (String)fruits.get(2);
		/*
		 * 끼워 넣기 부분 
		 */
		
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i)); 
			/*
			 * 하트가 밀려난다.
			 */
		}
		System.out.println(s1+","+s2+","+s3);
		
	}

}
---------------------------------------------
😊
👍
❤️
😊,❤️,❤️
package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		
		String s1 = null;
		String s2 = null;
		String s3 = null;
		ArrayList fruits = new ArrayList();
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		s1=(String)fruits.get(0);
		fruits.add(1,"❤️");
		s2 =(String)fruits.get(1);
		fruits.add(1,"👍"); 
		s3 = (String)fruits.get(1);
		/*
		 * 끼워 넣기 부분 
		 */
		
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i)); 
			/*
			 * 하트가 밀려난다.
			 */
		}
		System.out.println(s1+","+s2+","+s3);
		
	}

}
----------------------------------------
😊
👍
❤️
😊,❤️,👍

(4) boolean 추가

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		
		String s1 = null;
		String s2 = null;
		String s3 = null;
		ArrayList fruits = new ArrayList();
		boolean isOk = fruits.add("😊");
		System.out.println(isOk);
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		s1=(String)fruits.get(0);
		fruits.add(1,"❤️");
		s2 =(String)fruits.get(1);
		fruits.add(1,"👍"); 
		s3 = (String)fruits.get(2);
		/*
		 * 끼워 넣기 부분 
		 */
		
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i)); 
			/*
			 * 하트가 밀려난다.
			 */
		}
		System.out.println(s1+","+s2+","+s3);
		
	}

}

------------------------------------------------
true<너가 선택한 과일 들어가있어>
😊
👍
❤️
😊
😊,❤️,❤️

(5) 리턴 타입이 void

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List1 {

	public static void main(String[] args) {
		
		String s1 = null;
		String s2 = null;
		String s3 = null;
		ArrayList fruits = new ArrayList();
		boolean isOk = fruits.add("😊");
		System.out.println(isOk);
		/*
		 * Stack 구조다
		 */
		fruits.add("😊");
		s1=(String)fruits.get(0);
		s2= fruits.add(1,"❤️");
		/*
		 * 리턴 타입이 void라 대입이 안 된다. 그래서 오류 발생
		 */
		s2 =(String)fruits.get(1);
		fruits.add(1,"👍"); 
		s3 = (String)fruits.get(2);
		/*
		 * 끼워 넣기 부분 
		 */
		
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i)); 
			/*
			 * 하트가 밀려난다.
			 */
		}
		System.out.println(s1+","+s2+","+s3);
		
	}

}
  • s2= fruits.add(1,"❤️"); 해당 부분 왜 오류가 발생하는가?


이런 이유 때문에 안 된다.

(6) remove

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List2 {

	public static void main(String[] args) {
		ArrayList fruits = new ArrayList(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
		fruits.add("😊");
		fruits.add(1,"👍"); 
		fruits.add(1,"❤️");
		String r1= (String)fruits.remove(1);
		
		System.out.println(fruits);
		System.out.println(r1);
	}

}

-------------------------------------------
[😊, 👍]
❤️

E= remove(int);
E 부분 수정 가능
String r1= (String)fruits.remove(1);

메소드를 통한 ArrayList

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List3 {
	void getFruitList(ArrayList<String> fruits)
	{
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i));
		}
	}
	
	public static void main(String[] args) {
		ArrayList<String> fruits = new ArrayList<>(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
		fruits.add("😊");
		fruits.add(1,"👍"); 
		fruits.add(1,"❤️");
		
		List3 l3= new List3();
		l3.getFruitList(fruits);
	}

}
---------------------------------------------
😊
❤️
👍

ArrayList methodA()

package com.CollectionFrameWork;

import java.util.ArrayList;

public class List3 {
	void getFruitList(ArrayList<String> fruits)
	{
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i));
		}
	}
	
	ArrayList<String> methodA()
	{
		ArrayList<String> fruits = new ArrayList<>(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
		fruits.add("😊");
		fruits.add(1,"👍"); 
		fruits.add(1,"❤️");
		return fruits;
	}
	public static void main(String[] args) {
		ArrayList<String> fruits = new ArrayList<>(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
//		fruits.add("😊");
//		fruits.add(1,"👍"); 
//		fruits.add(1,"❤️");
		
		
		List3 l3= new List3();
		fruits=l3.methodA();
		l3.getFruitList(fruits);
	}

}
------------------------------------------
😊
❤️
👍
package com.CollectionFrameWork;

import java.util.ArrayList;

public class List3 {
	void getFruitList(ArrayList<String> fruits)
	{
		for(int i =0; i<fruits.size(); i++)
		{
			System.out.println(fruits.get(i));
		}
	}
	
	ArrayList<String> methodA()
	{
		ArrayList<String> fruits = new ArrayList<>(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
		fruits.add("🎶🎶");
		fruits.add(0,"👍"); 
		fruits.add(1,"❤️");
		return fruits;
	}
	public static void main(String[] args) {
		ArrayList<String> fruits = new ArrayList<>(); // 배열로 웃는얼굴-하트- 딸기 (밀려나서)
		List3 l3= new List3();
		fruits=l3.methodA();
		System.out.println(fruits); // 이렇게 호출하면 리스트형태로 반환된다. [, , , ,]
	}

}
-----------------------------------
[👍, ❤️, 🎶🎶]

심화

package com.CollectionFrameWork;

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

public class List4 {
	
	List<DeptDTO> li = new ArrayList<>();
	public static void main(String[] args) {
		List4 l4 = new List4();
		DeptDTO dept = new DeptDTO();
		
		
		dept.setDeptno(10);
		dept.setDname("영업부");
		dept.setLoc("부산");
		
		
		l4.li.add(dept);
		System.out.println(l4.li);
		DeptDTO rd = l4.li.get(0);
		
		System.out.println(rd.getDeptno()+"," + rd.getDname() + "," + rd.getLoc());
		
		
		
		
		
	}

}
-----------------------------------------
[com.CollectionFrameWork.DeptDTO@372f7a8d]
10,영업부,부산
package com.CollectionFrameWork;

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

public class List4 {
	List<DeptDTO> list = new ArrayList<>(); // DeptDTO불변객체를 제네릭으로 List를 만든다.
	public static void main(String[] args) {
	
		List4 l4 = new List4(); // 만약에 List4에서 -> list 접근하고 싶으면? = l4.list.add/get
		DeptDTO dept = new DeptDTO(); // dept는 getter / setter로 정보입력가능
		dept.setDeptno(50);
		dept.setDname("이경영");
		dept.setLoc("신세계"); // 이렇게 되면 dept 클래스내에 해당 정보가 set된다. 꺼낼때는 ? getter 이용 
		
		/*
		 * list에 dept 제네릭으로 추가하고 싶다. How? -> l4.list.add
		 */
		
		l4.list.add(dept); // 이게 무슨말이냐면 -> 해당 입력값이 list 0 번 인덱스에 저장된다.
		// 0번 인덱스를 꺼내고 싶다? get -> Object 리턴타입이기  때문에 + 타입을 Dept로 하는게 맞음 
		
		DeptDTO rd = l4.list.get(0);
		
		System.out.println(rd); // DeptDTO = 불변객체 이기 때문에 -> 주소 타입이 나온다. [list의 주소타입이]
		System.out.println(l4.list); // 이것을 증명하는 내용 
		
		
		
		
		

	}

}
--------------------------------------
com.CollectionFrameWork.DeptDTO@372f7a8d
[com.CollectionFrameWork.DeptDTO@372f7a8d]
package com.CollectionFrameWork;

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

// 불변 객체를 통해서 ArrayList를 활용하자!
/*
 * 1. 요구사항. ArrayList를 전역변수로 선언을 하고
 * 2. 인스턴스화를 통해서 이 ArrayList 타입인 Dept를 사용해보자.
 * 
 */
public class TestList3 {
	List<DeptDTO> list = new ArrayList<>();

	public static void main(String[] args) {
		TestList3 t3 = new TestList3();
		/*
		 * 여기서 의문이 발생 할 수 있다. 왜? 인스턴스화를 하지?
		 * list.add(dept) 하면 안 되나? 근데 인스턴스화를 하지 않으면
		 * list라는 전역변수에 선언 되어 있는 t3를 방문하지 않아서 
		 * 인스턴스화를 하지 않으면 객체 자체가 생성되지 않는다. 
		 */
		DeptDTO dept = new DeptDTO();
		dept.setDeptno(10);
		dept.setDname("오지환");
		dept.setLoc("인천"); // 3개의 데이터를 저장했다. set를 이용해서 -> how arraylist에 저장?
		t3.list.add(dept);
		dept  = t3.list.get(0);
		System.out.println(dept); // 주소값이 나온다.
		System.out.println(dept.getDeptno() +", "+ dept.getDname() +","+ dept.getLoc());
		
		/*
		 * DeptDTO는 불변객체다. -> 그렇기 때문에 setter / getter 프로퍼티가 선언
		 * 
		 */
		
	}
}
  • 여기서 의문이 발생 할 수 있다. 왜? 인스턴스화를 하지?
package com.CollectionFrameWork;

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

public class List4 {
	List<DeptDTO> list = new ArrayList<>(); // DeptDTO불변객체를 제네릭으로 List를 만든다.
	public static void main(String[] args) {
	
		List4 l4 = new List4(); // 만약에 List4에서 -> list 접근하고 싶으면? = l4.list.add/get
		DeptDTO dept = new DeptDTO(); // dept는 getter / setter로 정보입력가능
		dept.setDeptno(50);
		dept.setDname("이경영");
		dept.setLoc("신세계"); // 이렇게 되면 dept 클래스내에 해당 정보가 set된다. 꺼낼때는 ? getter 이용 
		
		/*
		 * list에 dept 제네릭으로 추가하고 싶다. How? -> l4.list.add
		 */
		
		l4.list.add(dept); // 이게 무슨말이냐면 -> 해당 입력값이 list 0 번 인덱스에 저장된다.
		// 0번 인덱스를 꺼내고 싶다? get -> Object 리턴타입이기  때문에 + 타입을 Dept로 하는게 맞음 
		
		DeptDTO rd = l4.list.get(0); // 50,이경영, 신세계를 rd에 저장한다.
		
		System.out.println(rd); // DeptDTO = 불변객체 이기 때문에 -> 주소 타입이 나온다. [list의 주소타입이]
		System.out.println(l4.list); // 이것을 증명하는 내용  -> 해당 내용을 꺼내고 싶어 ㅠㅠ How? -> getter 
		
		System.out.println("Deptno :" + dept.getDeptno() + "  " + "Dname : " + dept.getDname() + " Loc :" + "  "+ dept.getLoc());
		
		
		
		
		
		
		

	}

}
-------------------------------------------
com.CollectionFrameWork.DeptDTO@372f7a8d
[com.CollectionFrameWork.DeptDTO@372f7a8d]
Deptno :50  Dname : 이경영 Loc :  신세계
package com.step5;

import java.util.ArrayList;

public class EmpManager {
	ArrayList<EmpDTO> empList = new ArrayList<>();
	
	void getEmpList()
	{
		System.out.println(empList.size()); // 0
		EmpDTO emp = new EmpDTO();
		empList.add(emp);
		System.out.println(empList.size()); // 1
		
	}
	
	public static void main(String[] args) {
		
		EmpManager em = new EmpManager(); 
		//자기자신을 인스턴스화 해야만 전역변수의 인식됨.
		em.getEmpList();
	}

}
-----------------------------------------------
0
1

package com.step5;

import java.util.ArrayList;

public class EmpManager {
	ArrayList<EmpDTO> empList = new ArrayList<>();
	
	void getEmpList()
	{
		System.out.println(empList.size()); // 0
		EmpDTO emp = new EmpDTO();
		empList.add(0,emp);
		emp = new EmpDTO();
		empList.add(1, emp);
		System.out.println(empList.size()); // 2
		
	}
	
	public static void main(String[] args) {
		
		EmpManager em = new EmpManager(); 
		//자기자신을 인스턴스화 해야만 전역변수의 인식됨.
		em.getEmpList();
	}

}
----------------------------------------------------
0
2
package com.step5;

import java.util.ArrayList;

public class EmpManager {
	ArrayList<EmpDTO> empList = new ArrayList<>();
	
	void getEmpList()
	{
		System.out.println(empList.size()); // 0
		EmpDTO emp = new EmpDTO();
		empList.add(0,emp);
		emp = new EmpDTO();
		empList.add(1, emp);
		System.out.println(empList.size()); // 2
		
		for(int i = 0; i<empList.size(); i++)
		{
			EmpDTO remp = empList.get(i);
			System.out.println(remp.getEmpno()+ ", " + remp.getEmpno() + "," + remp.getHiredate());
		}
		
	}
	
	public static void main(String[] args) {
		
		EmpManager em = new EmpManager(); 
		//자기자신을 인스턴스화 해야만 전역변수의 인식됨.
		em.getEmpList();
	}

}
-------------------------------------------
0
2
0, 0,null
0, 0,null

package com.step5;

import java.util.ArrayList;

public class EmpManager {
	ArrayList<EmpDTO> empList = new ArrayList<>();
	
	void getEmpList()
	{
		System.out.println(empList.size()); // 0
		EmpDTO emp = new EmpDTO();
		empList.add(0,emp);
		emp = new EmpDTO(7566,"나신입", "영업",7800,"2000-10-20",3000,500,10);
		empList.add(1, emp);
		System.out.println(empList.size()); // 2
		
		for(int i = 0; i<empList.size(); i++)
		{
			EmpDTO remp = empList.get(i);
			System.out.println(remp.getEmpno()+ ", " + remp.getEmpno() + "," + remp.getHiredate());
		}
		
	}
	
	
	
	public static void main(String[] args) {
		
		EmpManager em = new EmpManager(); 
		//자기자신을 인스턴스화 해야만 전역변수의 인식됨.
		em.getEmpList();
	}

}
-----------------------------------------
0
2
0, 0,null
7566, 7566,2000-10-20

심화2

package com.CollectionFrameWork;

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

public class List4 {
	List<DeptDTO> li = new ArrayList<>();//확장성, 유지보수할때 코스 수정 양을 줄여줌
	public static void main(String[] args) {
		List4 l4 = new List4();
		DeptDTO  dept = new DeptDTO();
		dept.setDeptno(10);
		dept.setDname("영업부");
		dept.setLoc("부산");
		l4.li.add(dept);
		
		dept = new DeptDTO();
		dept.setDeptno(20);
		dept.setDname("개발부");
		dept.setLoc("대전");
		l4.li.add(dept);
		
		System.out.println(l4.li);//[]
		DeptDTO rd = l4.li.get(0);
		System.out.println(rd.getDeptno()+", "+rd.getDname()+", "+rd.getLoc());//[]
		rd = l4.li.get(1);
		System.out.println(rd.getDeptno()+", "+rd.getDname()+", "+rd.getLoc());//[]
	}

}
---------------------------------------------
[com.CollectionFrameWork.DeptDTO@372f7a8d, com.CollectionFrameWork.DeptDTO@2f92e0f4]
10, 영업부, 부산
20, 개발부, 대전

심화3

package com.CollectionFrameWork;

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

public class List4 {
	List<DeptDTO> list = new ArrayList<>(); // DeptDTO불변객체를 제네릭으로 List를 만든다.
	public static void main(String[] args) {
	
		List4 l4 = new List4(); // 만약에 List4에서 -> list 접근하고 싶으면? = l4.list.add/get
		DeptDTO dept = new DeptDTO(); // dept는 getter / setter로 정보입력가능
		dept.setDeptno(50);
		dept.setDname("이경영");
		dept.setLoc("신세계"); // 이렇게 되면 dept 클래스내에 해당 정보가 set된다. 꺼낼때는 ? getter 이용 
		
		/*
		 * list에 dept 제네릭으로 추가하고 싶다. How? -> l4.list.add
		 */
		
		l4.list.add(dept); // 이게 무슨말이냐면 -> 해당 입력값이 list 0 번 인덱스에 저장된다.
		// 0번 인덱스를 꺼내고 싶다? get -> Object 리턴타입이기  때문에 + 타입을 Dept로 하는게 맞음 
		
		DeptDTO rd = l4.list.get(0); // 50,이경영, 신세계를 rd에 저장한다.
		
		System.out.println(rd); // DeptDTO = 불변객체 이기 때문에 -> 주소 타입이 나온다. [list의 주소타입이]
		System.out.println(l4.list); // 이것을 증명하는 내용  -> 해당 내용을 꺼내고 싶어 ㅠㅠ How? -> getter 
		
		System.out.println("Deptno :" + dept.getDeptno() + "  " + "Dname : " + dept.getDname() + " Loc :" + "  "+ dept.getLoc());
		
		dept = new DeptDTO();
		dept.setDeptno(80);
		dept.<setDname("이순재할아버지");
		dept.setLoc("충청북도");
		
		l4.list.add(dept); 
		
		DeptDTO d4 = l4.list.get(1);
		System.out.println(d4);
		System.out.println(l4.list);
		System.out.println("Deptno :" + dept.getDeptno() + "  " + "Dname : " + dept.getDname() + " Loc :" + "  "+ dept.getLoc());
		
		
		
		
		
		

	}

}
--------------------------------------------

com.CollectionFrameWork.DeptDTO@372f7a8d
[com.CollectionFrameWork.DeptDTO@372f7a8d]
Deptno :50  Dname : 이경영 Loc :  신세계
com.CollectionFrameWork.DeptDTO@2f92e0f4
[com.CollectionFrameWork.DeptDTO@372f7a8d, com.CollectionFrameWork.DeptDTO@2f92e0f4]
Deptno :80  Dname : 이순재할아버지 Loc :  충청북도
  • [com.CollectionFrameWork.DeptDTO@372f7a8d, com.CollectionFrameWork.DeptDTO@2f92e0f4] 리스트형태로 주소번지 주소를 저장하는 방법을 유심히 살펴보자.

2023.10.19 추가분

package com.step6;

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


class Kiwi{
	String name = null;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

class Tomato{
	String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

public class List3 {
	List<String> bread = new ArrayList<>();
	List<Kiwi> kiwis = new ArrayList<>();
	List<Tomato> tomatos = new ArrayList<>();
	
	void methodA()
	{
		bread.add("소보로");
		System.out.println(bread.get(0));
		
		Kiwi kiwi = new Kiwi();
		kiwi.name = "골드키위";
		kiwis.add(kiwi);
		kiwi = kiwis.get(0);
		System.out.println(kiwi.getName());
		
		//System.out.println();
		
		Tomato tomato = new Tomato();
		tomato.name = "안녕";
		tomatos.add(tomato);
		tomato = tomatos.get(0);
		System.out.println(tomato.getName());
	}
	
	void methodB()
	{
		int i = 0;
		Kiwi kiwi = null;
		while(true)
		{
			/*
			 * 왜 무한루프인가? -> i가 1로 계속 초기화 되기 때문이다. ---> 이 부분에 대한 학습이 필요함
			 * 
			 */
			
			kiwi = new Kiwi();
			System.out.println(kiwi); // 여기서 주소번지가 달라진다는걸 알아야된다.
			i++;
			if(i == 5)
			{
				
				break;
			}
		}
	}
	public static void main(String[] args) {
		List3 list3 =new List3();
		list3.methodA();
		list3.methodB();
		
		System.out.println(list3.bread.size());
		/**
		 * 전역변수에 담고 싶다면? 
		 * - 인스턴스화를 해서 List에 대한 접근을 얻고
		 * list3.bread[리스트].~~메소드
		 */
	}

}
--------------------------------------------------
소보로
골드키위
안녕
com.step6.Kiwi@2f92e0f4
com.step6.Kiwi@28a418fc
com.step6.Kiwi@5305068a
com.step6.Kiwi@1f32e575
com.step6.Kiwi@279f2327
1

2023.10.20 추가분

package orcle;

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

public class List2 {
/**
 * 이렇게 활용 되는지는 몰랐다. ->
 */
	void methodA(List<BookVO> bookList)
	{
		BookVO bVO = new BookVO(); // b_no, b_author , b_price , -- private 
		bVO.setB_title("수학의 정석");
		bVO = new BookVO();
		System.out.println(bVO.getB_title()); // ""으로 나옴 
	}
	
	void methodB(List<Map<String,Object>> bookList)
	{
		
	}
	public static void main(String[] args) {
		List2 list2 = new List2();
		list2.methodA(null);
		/*
		 * 이 부분은 null을 넣게되면 null이 출력 될까? -> No -> 12번에서 새로 인스턴스화 해서 
		 */
		

	}

}

------------------------------------------
null

java.lang.NullPointerException:

package orcle;

public class BookVO {
	private int b_no = 0;
	private String b_title= null; 
	private String b_author= "";
	private int b_price= 0;
	
	/*
	 * ""와 null의 차이를 이해하고 있는가? ->
	 * sys("".length());
	 * sys(null.length()); 이 두개 차이를 알아야 한다. null이 아니라 빈 문자열이다.
	 */
	
	public int getB_no() {
		return b_no;
	}
	public void setB_no(int b_no) {
		this.b_no = b_no;
	}
	public String getB_title() {
		return b_title;
	}
	public void setB_title(String b_title) {
		this.b_title = b_title;
	}
	public String getB_author() {
		return b_author;
	}
	public void setB_author(String b_author) {
		this.b_author = b_author;
	}
	public int getB_price() {
		return b_price;
	}
	public void setB_price(int b_price) {
		this.b_price = b_price;
	}
}
// 소문자 CTRL+SHIFT+Y
package orcle;

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

public class List2 {
/**
 * 이렇게 활용 되는지는 몰랐다. ->
 */
	void methodA(List<BookVO> bookList)
	{
		BookVO bVO = new BookVO(); // b_no, b_author , b_price , -- private 
		bVO.setB_title("수학의 정석");
		bVO.setB_author(null);
		System.out.println(bVO.getB_title().length());
		System.out.println(bVO.getB_author());
		System.out.println(bVO.getB_author().length());
		bVO = new BookVO();
		//System.out.println(bVO.getB_title()); // ""으로 나옴 
	}
	
	void methodB(List<Map<String,Object>> bookList)
	{
		
	}
	public static void main(String[] args) {
		List2 list2 = new List2();
		list2.methodA(null);
		/*
		 * 이 부분은 null을 넣게되면 null이 출력 될까? -> No -> 12번에서 새로 인스턴스화 해서 
		 */
		

	}

}

--------------------------------------
6
null
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because the return value of "orcle.BookVO.getB_author()" is null
	at orcle.List2.methodA(List2.java:17)
	at orcle.List2.main(List2.java:28)

isEmpty()

contains(Object o)

iterator()

Map

(1)

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Map;

public class MapTest1 {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		
		/*
		 * 선언부와 생성부의 타입을 다르게 인스턴스화 하기 - 다형성
		 * 선언부(추상클래스, 인터페이스, 구현체클래스) - 고급 , 세련됨
		 * Hashtable (멀티스레드 안전) + HashMap(싱글안전)
		 * List 보다 속도 빠름 -> 순서가 없다. [2차 가공이 필요없다.]
		 * 
		 */
		map.put("deptno", "10");
		map.put("dname", "영업부");
		map.put("loc", "부산");
		System.out.println(map.get("deptno"));
		
		
		
	}
}


------------------------------------------
10

(2)

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Map;

public class MapTest1 {

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		
		/*
		 * 선언부와 생성부의 타입을 다르게 인스턴스화 하기 - 다형성
		 * 선언부(추상클래스, 인터페이스, 구현체클래스) - 고급 , 세련됨
		 * Hashtable (멀티스레드 안전) + HashMap(싱글안전)
		 * List 보다 속도 빠름 -> 순서가 없다. [2차 가공이 필요없다.]
		 * 
		 */
		map.put("deptno", "10");
		map.put("dname", "영업부");
		map.put("loc", "부산");
		System.out.println(map.get("deptno"));
		System.out.println(map.containsKey(10));
		System.out.println(map.containsKey("deptno"));
		System.out.println(map.containsKey("Deptno"));
		
//		if(!map.containsKey(10))
//		{
//			
//		}
		
		
		
	}
}
-----------------------------------------
10
false
true
false
package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest2{

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		

		map.put("deptno", "10");
		map.put("dname", "영업부");
		map.put("loc", "부산");
		Set<String> set =map.keySet();
		 Object[] keys =set.toArray();
		 System.out.println(keys[0]); // detpno ? 
		 System.out.println(keys[1]); // dname ?
		 System.out.println(keys[2]); // loc ? -------> No!!! 순서 없다.
		 
// 키 값을 덩어리로 꺼낼 수 있다면 반복문을 이용할 수 있다.
		
		
		
		
	}
}
-------------------------------------------
loc
dname
deptno

만약에 for문을 통해서 돌린다면?

(3)

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest2{

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		

		map.put("deptno", "10");
		map.put("dname", "영업부");
		map.put("loc", "부산");
		Set<String> set =map.keySet();
		 Object[] keys =set.toArray();
		 
// 키 값을 덩어리로 꺼낼 수 있다면 반복문을 이용할 수 있다.
		
		for(int i = 0; i < keys.length; i++)
		{
			System.out.println(keys[i]);
			// 애는 keys.length Col의 개수다. 왜? -> keys--> 는 key이기 때문이다.
			
		}
		
		
	}
}
----------------------------------
loc
dname
deptno
  • value를 찍어보려면? key말고

(4)

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest2{

	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		

		map.put("deptno", "10");
		map.put("dname", "영업부");
		map.put("loc", "부산");
		Set<String> set =map.keySet();
		 Object[] keys =set.toArray();
		 
// 키 값을 덩어리로 꺼낼 수 있다면 반복문을 이용할 수 있다.
		
		for(int i = 0; i < keys.length; i++)
		{
			System.out.println(keys[i] +"=======> " + map.get(keys[i]));
			// 애는 keys.length Col의 개수다. 왜? -> keys--> 는 key이기 때문이다.
			
		}
		
		
	}
}
--------------------------------------------------
loc=======> 부산
dname=======> 영업부
deptno=======> 10

(5)

Map을 이용해서 3건을 받으려면?

package com.CollectionFrameWork;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapTest3{

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		

		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		map.put("LOC", "부산");
		/*
		 * 1. 대문자 소문자 키 값을 항시 확인해야 된다. 그 이유는 소문자 대문자를 구별하기 때문이다.
		 */
		detpList.add(map);
		Set<String> set =map.keySet();
		 Object[] keys =set.toArray();
		 
// 키 값을 덩어리로 꺼낼 수 있다면 반복문을 이용할 수 있다.
		
		for(int i = 0; i < keys.length; i++)
		{
			System.out.println(keys[i] +"=======> " + map.get(keys[i]));
			// 애는 keys.length Col의 개수다. 왜? -> keys--> 는 key이기 때문이다.
			
		}
		
		/*
		 * mySql -> 조인의 개념과 같음 -> 쉽게 생각해서 조인한 결과값을 받아오려면 -> List & Map을 섞어쓴다.
		 * 1. List<VO> -> 타입을 맞추지 않아서 되서 연산할 때 주로 사용한다.
		 * 2. List<Map> -> 조인 할 때 주로 사용 || 타입을 맞춰야함
		 */
		

		
	}
}
-----------------------------------------------------
LOC=======> 부산
DEPTNO=======> 10
DNAME=======> 영업부

(6)


package com.CollectionFrameWork;

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

public class TestMap2 {

	public static void main(String[] args) {
		List<Map<String, Object>> list = new ArrayList<>();
		Map<String, Object> map = new HashMap<>();
		
		map.put("오지환", 30);
		map.put("이수정", 25);
		map.put("홍준표", "대구");
		list.add(map);
		
		map.put("이순길", 30);
		map.put("윤석열", 25);
		map.put("안철수", "대구");
		list.add(map);
		/*
		 * 안에 있는 키 값들을 출력하고 싶어 How?
		 */
		Set<String> keySet = map.keySet();
		Object[] keys = keySet.toArray(); // 키 값이 keys 에 저장 된다
		
		for(int i = 0; i < keys.length; i++)
		{
			System.out.println(keys[i] +"=======> " + map.get(keys[i]));
			// 애는 keys.length Col의 개수다. 왜? -> keys--> 는 key이기 때문이다.
			
		}
		
		/*
		 * 리스트를 통해서 키 값을 가지고 벨류를 얻는다. 
		 */
		System.out.println(list.get(0).get("오지환"));
		System.out.println(list.get(1).get("안철수"));
		
	}
}

-----------------------------------
이수정=======> 25
홍준표=======> 대구
이순길=======> 30
윤석열=======> 25
오지환=======> 30
안철수=======> 대구
30
대구
  • list.get(0).get("key 값") : 위에 보면 list.add를 한 순간 인덱스가 증가한다. 그렇기 떄문에 0번째 방에 저장되어 있는 키-값들은 
		map.put("오지환", 30);
		map.put("이수정", 25);
		map.put("홍준표", "대구");

되고,

list.add 하는 순간 인덱스가 1로 바뀐다. 그렇기 때문에 0번째 인덱스에는 저 값들이 저장되어 있는 것이다.

(7) - detpList.add(map) x 2

package com.CollectionFrameWork;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapTest4{

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		map.put("LOC", "부산");
		
		map = new HashMap<>();
		map.put("DEPTNO", 20);
		map.put("DNAME", "개발부");
		map.put("LOC", "대구");
		detpList.add(map);
		detpList.add(map);
		System.out.println(detpList);
		
		
		
		
		Set<String> set =map.keySet();
		 Object[] keys =set.toArray();
		 
// 키 값을 덩어리로 꺼낼 수 있다면 반복문을 이용할 수 있다.
		
		for(int i = 0; i < keys.length; i++)
		{
			System.out.println(keys[i] +"=======> " + map.get(keys[i]));
			// 애는 keys.length Col의 개수다. 왜? -> keys--> 는 key이기 때문이다.
			
		}
		
		
		/*
		 * mySql -> 조인의 개념과 같음 -> 쉽게 생각해서 조인한 결과값을 받아오려면 -> List & Map을 섞어쓴다.
		 * 1. List<VO> -> 타입을 맞추지 않아서 되서 연산할 때 주로 사용한다.
		 * 2. List<Map> -> 조인 할 때 주로 사용 || 타입을 맞춰야함
		 */
		System.out.println(detpList.get(0).get("DEPTNO"));
		System.out.println(detpList.get(0).get("dname"));
		System.out.println(detpList.get(0).get("LOC"));
		

		/*
		 * detpList.get(0) 부분은 detpList에서 첫 번째 요소를 나타내는 부분이며, 이 요소는 map 객체다.
		 * detpList.get(0) 부분은 detpList의 첫 번째 요소를 가리키는 고정된 참조이므로, detpList에 다른 요소를 추가하더라도 이 부분은 변하지 않는다.
		 * detpList.get(0)은 항상 첫 번째 map 객체를 가리키며, detpList.get(1)은 두 번째 map 객체를 가리키게 된다.
		 * 새로운 요소를 detpList에 추가할 때, 그것은 다른 map 객체가 될 것이지만, detpList.get(0) 부분은 여전히 첫 번째 map 객체를 가리키게된다.
		 */
		
	}
}
---------------------------------------------
[{LOC=대구, DEPTNO=20, DNAME=개발부}, {LOC=대구, DEPTNO=20, DNAME=개발부}]
LOC=======> 대구
DEPTNO=======> 20
DNAME=======> 개발부
20
null
대구

  • [{LOC=대구, DEPTNO=20, DNAME=개발부}, {LOC=대구, DEPTNO=20, DNAME=개발부}] 부분 확인

  • map = new HashMap<>();를 사용하면, 이전의 맵을 삭제하고 새로운 맵을 생성하는 것이 아니라, 동일한 맵에 대한 새로운 참조를 생성하는 것이다.

  • map 변수가 새로운 HashMap 인스턴스를 가리키도록 변경하는 것이지만, 이전에 map 변수가 가리키고 있던 HashMap 객체는 그대로 남아 있습니다. 그것은 여전히 메모리에 존재하며 변경사항이 그 객체에 반영된다.

다른 방법

List<Map<String, Object>> detpList = new ArrayList<>();

Map<String, Object> map1 = new HashMap<>();
map1.put("DEPTNO", 10);
map1.put("DNAME", "영업부");
map1.put("LOC", "부산");

Map<String, Object> map2 = new HashMap<>();
map2.put("DEPTNO", 20);
map2.put("DNAME", "개발부");
map2.put("LOC", "대구");

detpList.add(map1);
detpList.add(map2);
----------------------------------------------------------
[{LOC=부산, DEPTNO=10, DNAME=영업부}, {LOC=대구, DEPTNO=20, DNAME=개발부}]
  • detpList에는 두 개의 별개이며 독립적인 맵이 포함되며, 하나의 맵에 대한 변경사항이 다른 맵에 영향을 미치지 않는다.

(8) - detpList.add(map)의 활용2

package com.CollectionFrameWork;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapTest4{

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		detpList.add(map);
		map.put("LOC", "부산"); // 부산이 how 들어오는가?
		
		map = new HashMap<>();
		map.put("DEPTNO", 20);
		map.put("DNAME", "개발부");
		map.put("LOC", "대구");
		
		detpList.add(map);
		System.out.println(detpList);
        
        
        }
------------------------------------------------------------
[{LOC=부산, DEPTNO=10, DNAME=영업부}, {LOC=대구, DEPTNO=20, DNAME=개발부}]

  • map 객체를 생성하고 "DEPTNO"와 "DNAME" 키에 값을 넣고 detpList에 추가한다. 이 때, map 객체에는 "DEPTNO"와 "DNAME" 키의 값만 존재한다.

  • map 객체에 "LOC" 키에 "부산" 값을 추가한다. 이것은 이미 detpList에 추가된 map 객체와 동일한 객체에 대한 변경한다.

  • "부산" 값은 map 객체에 추가되고, 이 변경사항은 detpList에 있는 해당 map 객체에 반영한다.

리팩토링 코드


    public static void main(String[] args) {
        List<Map<String, Object>> detpList = new ArrayList<>();

        // 첫 번째 map 객체 생성
        Map<String, Object> map1 = new HashMap<>();
        map1.put("DEPTNO", 10);
        map1.put("DNAME", "영업부");
        map1.put("LOC", "부산");
        detpList.add(map1);

        // 두 번째 map 객체 생성
        Map<String, Object> map2 = new HashMap<>();
        map2.put("DEPTNO", 20);
        map2.put("DNAME", "개발부");
        map2.put("LOC", "대구");
        detpList.add(map2);

        System.out.println(detpList);
    }
package com.CollectionFrameWork;

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

public class TestMap2 {

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		detpList.add(map);
		map.put("LOC", "부산"); // 부산이 how 들어오는가?
		

		map.put("DEPTNO", 20);
		map.put("DNAME", "개발부");
		map.put("LOC", "대구");
		detpList.add(map);
		
		/*
		 * 업데이트 된 것 부분들이 add 해서 -> 그 값이 2번 저장된거임
		 * 이번 Test Case는 재정의를 하지 x 
		 * detpList의 크기는 2
		 * 두 번째 추가된 map 객체가 첫 번째 map 객체를 덮어쓰게 된다.
		 * map 객체는 실제로는 메모리에 한 번만 존재하고, 
		 * detpList에는 이 map 객체의 참조만 저장
		 *  따라서 map 객체를 수정하면 모든 detpList의 인덱스에서 동일한 map 객체를 참조하게 되므로,
		 *   수정 사항이 모든 항목에 반영
		 */
		System.out.println(detpList);
        
        
        }
}
-------------------------------------------
[{LOC=대구, DEPTNO=20, DNAME=개발부}, {LOC=대구, DEPTNO=20, DNAME=개발부}]

* 업데이트 된 것 부분들이 add 해서 -> 그 값이 2번 저장된거임
* 이번 Test Case는 재정의를 하지 x 
* detpList의 크기는 2
* 두 번째 추가된 map 객체가 첫 번째 map 객체를 덮어쓰게 된다.
* map 객체는 실제로는 메모리에 한 번만 존재하고, 
* detpList에는 이 map 객체의 참조만 저장
* 따라서 map 객체를 수정하면 모든 detpList의 인덱스에서 동일한 map 객체를 참조하게 되므로,
* 수정 사항이 모든 항목에 반영
public class TestMap2 {

    public static void main(String[] args) {
        List<Map<String, Object>> detpList = new ArrayList<>();

        Map<String, Object> map = new HashMap<>();
        map.put("DEPTNO", 10);
        map.put("DNAME", "영업부");
        map.put("LOC", "부산");
        detpList.add(map);

        map = new HashMap<>(); // 새로운 map 객체 생성
        map.put("DEPTNO", 20);
        map.put("DNAME", "개발부");
        map.put("LOC", "대구");
        detpList.add(map);

        System.out.println(detpList);
    }
  • 이렇게 하면 각 map 객체는 별도의 인스턴스로 유지되며, detpList에 추가된 각각의 map 객체에 대한 수정 사항이 서로에게 영향을 주지 않는다.

(9)

package com.CollectionFrameWork;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapTest4{

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		detpList.add(map);
		map = null;
		map = new HashMap<>(); // 복사보니다.
		map.put("LOC", "부산"); // 부산이 how 들어오는가?
		
		map = new HashMap<>();
		map.put("DEPTNO", 20);
		map.put("DNAME", "개발부");
		map.put("LOC", "대구");
		
		detpList.add(map);
		System.out.println(detpList);
		
		


		
	}
}

---------------------------------------
[{DEPTNO=10, DNAME=영업부}, {LOC=대구, DEPTNO=20, DNAME=개발부}]

(10)

package com.CollectionFrameWork;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapTest4{

	public static void main(String[] args) {
		List<Map<String, Object>> detpList = new ArrayList<>();
		/*
		 * value를 Object로 하는 이유는 여러 타입을 받기 위해서임
		 * Array와 List를 섞어 쓸 수 있음.
		 */
		Map<String, Object> map = new HashMap<>();
		map.put("DEPTNO", 10);
		map.put("DNAME", "영업부");
		detpList.add(map);
		map = null;
		map = new HashMap<>();
		map.put("LOC", "부산"); // 부산이 how 들어오는가?
		//부산도 담아줘
		detpList.add(map);
		
		
		map = new HashMap<>();
		map.put("DEPTNO", 20);
		map.put("DNAME", "개발부");
		map.put("LOC", "대구");
		
		detpList.add(map);
		System.out.println(detpList);
		

		
	}
}

------------------------
[{DEPTNO=10, DNAME=영업부}, {LOC=부산}, {LOC=대구, DEPTNO=20, DNAME=개발부}]

(11) - Iterator

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class TestMap {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String,Integer>();
		Set<String> keyMap = map.keySet();
		map.put("오지환", 20);
		map.put("오지수", 50);
		Iterator<String> iter = keyMap.iterator(); // 여기서 중요한건 key를 쓴다는 것
		while(iter.hasNext())
		{
			String str1 = iter.next();
			// 키 값
			
			int s1 = map.get(str1);
			// 값이 들어가야함
			System.out.println(str1 + "," + s1);
			
		}
	}
	
}
----------------------------------------------------------------
오지수,<50
오지환,20

(12) - Map.Entry

package com.CollectionFrameWork;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class TestMap {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<String,Integer>();
		map.put("오지환", 20);
		map.put("오지수", 50);
		
		
		Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, Integer>> iter = entrySet.iterator();
		while(iter.hasNext())
		{
			Map.Entry<String, Integer> entry = iter.next();
			String str1 = entry.getKey();
			int s = entry.getValue();
			System.out.println(str1 + "," + s);
			
		}
	}
	
}

------------------------------------------------
오지수,50
오지환,20
profile
지환
아는만큼보인다.
이전 포스트

자바 - SungJukView 리팩토링

다음 포스트

JFrame crud & List<Map> 강화

0개의 댓글