본문 바로가기
Web & Mobile/JAVA

Lecture 29 - Java(10) ArrayList, LinkedList, HashSet, TreeSet, HashMap, File

by Bennyziio 2023. 6. 20.
반응형

ArrayList 계속

ArrayListEx05 - 2차원 데이터를 저장

2차원 데이터를 저장(행과 열) = 테이블 

2차원 배열 
ArrayList 2개 : ArrayList안에 ArrayList를 넣는다 
ArrayList + 클래스 

   1 홍길동 010-111-1111 20 서울시 
   2 박문수 010-222-2222 22 경기도 
   3 이몽룡 010-333-3333 23 강원도 
위 데이터를 2차원 배열 넣고 싶은데 어떻게 하면 될까요?

public class ArrayListEx05 {

	public static void main(String[] args) {
		
		// 2차원 데이터를 저장(행과 열) = 테이블
		
		// 2차원 배열
		// ArrayList 2개 : ArrayList안에 ArrayList를 넣는다
		// ArrayList + 클래스
		/*
		 * 	1	홍길동	010-111-1111	20	서울시
		 * 	2	박문수	010-222-2222	22	경기도
		 * 	3 	이몽룡	010-333-3333	23	강원도
		 */
		
		// 2차원 배열 넣고 싶다 어떻게?
		
		String[] data1 = {"1", "홍길동", "010-111-1111", "20", "서울시"};
		String[] data2 = {"2", "박문수", "010-222-2222", "22", "경기도"};
		String[] data3 = {"3", "이몽룡", "010-333-3333", "23", "강원도"};
		
		String[][] datas = new String[3][];
		datas[0] = data1;
		datas[1] = data2;
		datas[2] = data3;
		
		// 향상된 for문을 이용해 데이터 가져오기
		for(String[] data : datas) {
			for(String str : data) {
				System.out.println(str + "\t");
			}
			System.out.println();
		}
	}
}

2차원 배열을 이용하여 데이터를 저장

import java.util.ArrayList;

public class ArrayListEx05 {

	public static void main(String[] args) {
		
		// 2차원 데이터를 저장(행과 열) = 테이블
		
		// 2차원 배열
		// ArrayList 2개 : ArrayList안에 ArrayList를 넣는다
		// ArrayList + 클래스
		/*
		 * 	1	홍길동	010-111-1111	20	서울시
		 * 	2	박문수	010-222-2222	22	경기도
		 * 	3 	이몽룡	010-333-3333	23	강원도
		 */
		
		// 2차원 배열 넣고 싶다 어떻게?
		/*
		String[] data1 = {"1", "홍길동", "010-111-1111", "20", "서울시"};
		String[] data2 = {"2", "박문수", "010-222-2222", "22", "경기도"};
		String[] data3 = {"3", "이몽룡", "010-333-3333", "23", "강원도"};
		
		String[][] datas = new String[3][];
		datas[0] = data1;
		datas[1] = data2;
		datas[2] = data3;
		
		// 향상된 for문을 이용해 데이터 가져오기
		for(String[] data : datas) {
			for(String str : data) {
				System.out.println(str + "\t");
			}
			System.out.println();
		}
		*/
		
		ArrayList<String> data1 = new ArrayList<>();
		ArrayList<String> data2 = new ArrayList<>();
		ArrayList<String> data3 = new ArrayList<>();
		
		data1.add("1"); data1.add("홍길동"); data1.add("010-111-1111"); data1.add("20"); data1.add("서울시");
		data2.add("2"); data2.add("박문수"); data2.add("010-222-2222"); data2.add("22"); data2.add("경기도");
		data3.add("3"); data3.add("이몽룡"); data3.add("010-333-3333"); data3.add("23"); data3.add("강원도");
		
		ArrayList<ArrayList<String>> datas = new ArrayList<>();
		datas.add(data1);
		datas.add(data2);
		datas.add(data3);
		
		// 향상된 for문
		for(ArrayList<String> data : datas) {
			for(String str : data) {
				System.out.println(str + "\t");
			}
			System.out.println();
		}
		
	}
}

ArrayList를 2차원으로 하여 데이터를 저장

ArrayListEx06 - ArrayList + 클래스를 이용한 2차원 배열에 데이터 저장

import java.util.ArrayList;

public class ArrayListEx06 {

	public static void main(String[] args) {

		// 클래스를 만들때 기능상 분류(자바 패턴)
		// 1. DTO(Data Transfer Object) : 데이터 저장 / Transfer
		// 		멤버변수 (VO : Value Object)
		// 2. DAO(Data Access Object) : 데이터 삽입 / 수정 / 삭제
		//		메서드
		// 3. 실행 클래스 : public static void main(String[] args)
		
		// 1차원 배열
		Student stu1 = new Student("1", "홍길동", "010-111-1111", "20", "서울시");
		Student stu2 = new Student("2", "박문수", "010-222-2222", "22", "경기도");
		Student stu3 = new Student("3", "이몽룡", "010-333-3333", "23", "강원도");
		
		ArrayList<Student> datas = new ArrayList<>();
		// 2차원 배열
		datas.add(stu1);
		datas.add(stu2);
		datas.add(stu3);
		
		// 향상된 for문
		for(Student stu : datas) {
			System.out.print(stu.getSeq() + "\n");
			System.out.print(stu.getName() + "\n");
			System.out.print(stu.getPhone() + "\n");
			System.out.print(stu.getAge() + "\n");
			System.out.print(stu.getRegion() + "\n");			
		}
	}
}

LinkedList, DoubleLinkedList
배열은 가장 기본적인 형태의 자료구조로 구조가 간단하며 사용하기 쉽고 데이터를 읽어오는데 걸리는 시간(접근시간, access time)이 가장 빠르다는 장점을 가지고 있지만 다음과 같은 단점도 가지고 있다.
1. 크기를 변경할 수 없다
  - 크기를 변경할 수 없으므로 새로운 배열을 생성해서 데이터를 복사해야한다.
2. 비순차적인 데이터의 추가 또는 삭제에 시간이 많이 걸린다
  - 차례대로 데이터를 추가하고 마지막에서부터 데이터를 삭제하는 것은 빠르지만, 배열의 중간에 데이터를 추가하려면, 빈자리를 만들기 위해 다른 데이터들을 복사해서 이동해야 한다.

이러한 배열의 단점을 보완하기 위해서 링크드 리스트라는 자료구조가 고안되었다. 배열은 모든 데이터가 연속적으로 존재하지만 링크드 리스트는 불연속적으로 존재하는 데이터를 서로 연결한 형태로 구성되어있다.

LinkedListEx01

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

public class ArrayListLinkedListTest {

	public static void main(String[] args) {
		// 추가할 데이터의 개수를 고려하여 충분히 잡아야 한다.
		ArrayList al = new ArrayList<>(2000000);
		LinkedList ll = new LinkedList<>();
		
		System.out.println("= 순차적으로 추가하기 =");
		System.out.println("ArrayList : " + add1(al));
		System.out.println("LinkedList : " + add1(ll));
		System.out.println();
		System.out.println("= 중간에 추가하기 =");
		System.out.println("ArrayList : " + add2(al));
		System.out.println("LinkedList : " + add2(ll));
		System.out.println();
		System.out.println("= 중간에서 삭제하기 =");
		System.out.println("ArrayList : " + remove2(al));
		System.out.println("LinkedList : " + remove2(ll));
		System.out.println();
		System.out.println("= 순차적으로 삭제하기 =");
		System.out.println("ArrayList : " + remove1(al));
		System.out.println("LinkedList : " + remove1(ll));
		System.out.println();
	}
	
	public static long add1(List list) {
		long start = System.currentTimeMillis();
		for(int i = 0; i<1000000; i++) {
			list.add(i+"");
		}
		long end = System.currentTimeMillis();
		return end - start;
	}
	
	public static long add2(List list) {
		long start = System.currentTimeMillis();
		for(int i = 0; i<10000; i++) {
			list.add(500, "X");
		}
		long end = System.currentTimeMillis();
		return end - start;
	}

	public static long remove1(List list) {
		long start = System.currentTimeMillis();
		for(int i = list.size()-1; i>= 0; i--) {
			list.remove(i);
		}
		long end = System.currentTimeMillis();
		return end - start;
	}
	
	public static long remove2(List list) {
		long start = System.currentTimeMillis();
		for(int i = 0; i<10000; i++) {
			list.remove(i);
		}
		long end = System.currentTimeMillis();
		return end - start;
	}
}

순차적으로 추가/삭제는 ArrayList가 빠르고, 중간 데이터를 추가/삭제는 LinkedList가 매우 빠르다.

Stack과 Queue
Stack은 마지막에 저장한 데이터를 가장 먼저 꺼내게 되는 LIFO(Last In First Out)구조 : 후입선출
  - 동전통과 같은 구조로 양 옆과 바닥이 막혀 있어서 한 방향으로만 뺄 수 있는 구조
Queue는 처음에 저장한 데이터를 가장 먼저 꺼내게 되는 FIFO(First In First Out)구조 : 선입선출
  - 양 옆만 막혀 있고 위아래로 뚫려 있어서 한 방향으로 넣고 한 방향으로 빼는 파이프와 같은 구조

스택과 큐의 활용
스택의 활용 예 : 수식계산, 수식괄호검사, 워드프로세서의 undo/redo, 웹브라우저의 뒤로/앞으로
큐의 활용 예 : 최근사용문서, 인쇄작업 대기목록, 버퍼(buffer)

Hashset
HashSet은 Set인터페이스를 구현한 가장 대표적인 컬렉션이며, set인터페이스의 특징대로 HashSet은 중복된 요소를 저장하지 않는다.

HashSetEx01

import java.util.HashSet;

public class HashSetEx01 {

	public static void main(String[] args) {

		HashSet<String> hs = new HashSet<>();
		
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
	
	}
}


import java.util.HashSet;

public class HashSetEx01 {

	public static void main(String[] args) {

		HashSet<String> hs = new HashSet<>();
		
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
	
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
	}
}

중복된 요소를 저장하지 않는다

여기서 내부데이터를 직접 가져올 수 없기 때문에 Iterator을 사용 한다.

import java.util.HashSet;
import java.util.Iterator;

public class HashSetEx01 {

	public static void main(String[] args) {

		HashSet<String> hs = new HashSet<>();
		
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
	
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
		
		// 내부 데이터
		Iterator<String> i = hs.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
	}
}


import java.util.HashSet;
import java.util.Iterator;

public class HashSetEx01 {

	public static void main(String[] args) {

		HashSet<String> hs = new HashSet<>();
		
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
	
		hs.add("자바");
		hs.add("에스프레소");
		hs.add("카푸치노");
		
		System.out.println(hs.size());
		System.out.println(hs.toString());
		
		// 내부 데이터
		Iterator<String> i = hs.iterator();
		while(i.hasNext()) {
			System.out.println(i.next());
		}
		
		for(String str : hs) {
			System.out.println(str);
		}
	}
}

향상된 for문으로 사용하는 방법

HashSet으로 Lotto 발생기 작성

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;

public class LottoEx01 {

	public static void main(String[] args) {
		// 랜덤변수를 출력하는 인스턴스
		Random r = new Random(System.currentTimeMillis());
		
		for(int i=1; i<=5; i++) {
			//ArrayList<Integer> lottoNumbers = new ArrayList<>();
			HashSet<Integer> lottoNumbers = new HashSet<>();
			while(true) {
				// nextInt(45)는 0~45까지 랜덤변수를 받아온다
				lottoNumbers.add(r.nextInt(45)+1);
				// 컨텐츠가 6개가 되면 while문 탈출
				if(lottoNumbers.size() == 6) {
					break;
				}
			}
			// HashSet으로 출력된 값을 불러온다
			System.out.println(lottoNumbers.toString());
		}
	}
}

기존에 중복을 제거해주기 위해서 indexOf로 제거해주었는데 HashSet 자체에서 중복은 제외해주므로 훨씬 짧게 코딩이 가능하다

HashSetEx02

public class Person {
	private String name;
	private int age;
	
	// generate constructor using field
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	// generate toString()
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

import java.util.HashSet;

public class HashSetEx02 {

	public static void main(String[] args) {

		Person p1 = new Person("홍길동", 20);
		Person p2 = new Person("박문수", 23);
		Person p3 = new Person("홍길동", 20);
		
		HashSet<Person> hs = new HashSet<>();
		hs.add(p1);
		hs.add(p2);
		
		System.out.println(hs.size());
		
		// 주소값이 같을 때
		//hs.add(p1);
		// 실제 데이터가 같을 때
		hs.add(p3);
		System.out.println(hs.size());
	}
}


public class Person {
	private String name;
	private int age;
	
	// generate constructor using field
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	// generate hashCode() and equals()
	@Override
	public int hashCode() {
		System.out.println("hashCode() 호출");
		return (name + age).hashCode();
	}

	// generate hashCode() and equals()
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals(Object obj) 호출");
		if(obj instanceof Person) {
			Person tmp = (Person)obj;
			return name.equals(tmp.name) && age == tmp.age;
		}
		return false;
	}

	// generate toString()
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

import java.util.HashSet;

public class HashSetEx02 {

	public static void main(String[] args) {

		Person p1 = new Person("홍길동", 20);
		Person p2 = new Person("박문수", 23);
		Person p3 = new Person("홍길동", 20);
		
		HashSet<Person> hs = new HashSet<>();
		hs.add(p1);
		hs.add(p2);
		
		System.out.println(hs.size());
		
		// 주소값이 같을 때
		//hs.add(p1);
		// 실제 데이터가 같을 때
		hs.add(p3);
		System.out.println(hs.size());
	}

}

기존 데이터 name, age와 새로 들어온 데이터 p3 =  Object로 저장된 name, age를 비교한다. obj가 Person의 인스턴스일 경우 서로 비교하며 그렇지 않을땐 false를 return한다

TreeSet
이진 검색 트리라는 자료구조의 형태로 데이터를 저장하는 컬렉션 클래스이다. 
이진 검색 트리는 정렬, 검색, 범위검색(range search)에 높은 성능을 보이는 자료구조이며 TreeSet은 이진 검색 트리의 성능을 향상시킨 '레드-블랙 트리(Red-Black Tree)'로 구현되어 있다
Set인터페이스를 구현했으므로 중복된 데이터의 저장을 허용하지 않으며 정렬된 위치에 저장하므로 저장순서를 유지하지도 않는다. 
  - 모든 노드는 최대 두 개의 자식노드를 가질 수 있다.
  - 왼쪽 자식노드의 값은 부모노드의 값보다 작고 오른쪽자식노드의 값은 부모노드의 값보다 커야한다
  - 노드의 추가 삭제에 시간이 걸린다
  - 검색(범위검색)과 정렬에 유리하다
  - 중복된 값을 저장하지 못한다

TreeSetEx02

import java.util.TreeSet;

public class TreeSetEx02 {

	public static void main(String[] args) {

		TreeSet set = new TreeSet<>();
		int[] score = {80, 95, 50, 35, 45, 65, 10, 100};
		
		for(int i=0; i < score.length; i++)
			set.add(new Integer(score[i]));
		
		System.out.println("50보다 작은 값 : " + set.headSet(new Integer(50)));
		System.out.println("50보다 큰 값 : " + set.tailSet(50));
	}
}

 

지정된 값보다 크거나 작은것을 headSet, tailSet으로 구할 수 있다

Map인터페이스
키(key)와 값(value)을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는 데 사용된다. 키는 중복될 수 없지만 값은 중복을 허용한다

HashMap과 Hashtable
HashMap이 신버전

HashMapEx01

import java.util.HashMap;

public class HashMapEx01 {

	public static void main(String[] args) {
		
		// <key 자료형, 값의 자료형>
		HashMap<String, String> hm = new HashMap<>();
		
		hm.put("a", "박문수");
		hm.put("b", "이몽룡");
		hm.put("c", "성춘향");
		
		System.out.println(hm.size());
		System.out.println(hm.toString());
	}
}


import java.util.HashMap;

public class HashMapEx01 {

	public static void main(String[] args) {
		
		// <key 자료형, 값의 자료형>
		HashMap<String, String> hm = new HashMap<>();
		
		hm.put("a", "박문수");
		hm.put("b", "이몽룡");
		hm.put("c", "성춘향");
		
		System.out.println(hm.size());
		System.out.println(hm.toString());
		
		// index라는 숫자값 대신 key(문자열)를 사용
		System.out.println(hm.get("a"));
		System.out.println(hm.get("c"));
		
	}
}

index라는 숫잣값 대신 key를 사용하여 출력

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

public class HashMapEx01 {

	public static void main(String[] args) {
		
		// <key 자료형, 값의 자료형>
		HashMap<String, String> hm = new HashMap<>();
		
		hm.put("a", "박문수");
		hm.put("b", "이몽룡");
		hm.put("c", "성춘향");
		
		System.out.println(hm.size());
		System.out.println(hm.toString());
		
		// index라는 숫자값 대신 key(문자열)를 사용
		System.out.println(hm.get("a"));
		System.out.println(hm.get("c"));
		
		// 키값만 별도로 접근 가능
		Set<String> keys = hm.keySet();
		System.out.println(keys.toString());
		
		for(String key : keys) {
			System.out.printf("%s - %s%n", key, hm.get(key));
		}
	}
}

키 값만 별도로 접근

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class HashMapEx01 {

	public static void main(String[] args) {
		
		// <key 자료형, 값의 자료형>
		HashMap<String, String> hm = new HashMap<>();
		
		hm.put("a", "박문수");
		hm.put("b", "이몽룡");
		hm.put("c", "성춘향");
		
		System.out.println(hm.size());
		System.out.println(hm.toString());
		
		// index라는 숫자값 대신 key(문자열)를 사용
		System.out.println(hm.get("a"));
		System.out.println(hm.get("c"));
		
		// 키값만 별도로 접근 가능
		Set<String> keys = hm.keySet();
		System.out.println(keys.toString());
		
		for(String key : keys) {
			System.out.printf("%s - %s%n", key, hm.get(key));
		}
		
		// 값만 추출
		Collection<String> values = hm.values();
		for(String value : values) {
			System.out.println(value);
		}
	}
}

값만 추출

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class HashMapEx01 {

	public static void main(String[] args) {
		
		// <key 자료형, 값의 자료형>
		HashMap<String, String> hm = new HashMap<>();
		
		hm.put("a", "박문수");
		hm.put("b", "이몽룡");
		hm.put("c", "성춘향");
		
		System.out.println(hm.size());
		System.out.println(hm.toString());
		
		// index라는 숫자값 대신 key(문자열)를 사용
		System.out.println(hm.get("a"));
		System.out.println(hm.get("c"));
		
		// 키값만 별도로 접근 가능
		Set<String> keys = hm.keySet();
		System.out.println(keys.toString());
		
		for(String key : keys) {
			System.out.printf("%s - %s%n", key, hm.get(key));
		}
		
		// 값만 추출
		Collection<String> values = hm.values();
		for(String value : values) {
			System.out.println(value);
		}
		
		Student stu1 = new Student("1", "홍길동", "010-111-1111", "20", "서울시");
		Student stu2 = new Student("2", "박문수", "010-222-2222", "22", "경기도");
		Student stu3 = new Student("3", "이몽룡", "010-333-3333", "23", "강원도");
		
		HashMap<String, Student> hm2 = new HashMap<>();
		hm2.put("1001", stu1);
		hm2.put("1002", stu2);
		hm2.put("1003", stu3);
		
		// 출력
		Set<String> keys2 = hm2.keySet();
		for(String key : keys2) {
			Student stu = hm2.get(key);
			System.out.println(stu.getSeq());
			System.out.println(stu.getName());
			System.out.println(stu.getPhone());
			System.out.println(stu.getAge());
			System.out.println(stu.getRegion());
			
		}
	}
}

HashMapEx04 - 문자열 배열에 담긴 문자열을 카운트 하는 소스

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

public class HashMapEx04 {

	public static void main(String[] args) {

		String[] data = {"A", "K", "A", "K", "D", "K", "A", "K", "K", "K", "Z", "D"};
		
		HashMap map = new HashMap();
		
		for(int i=0; i < data.length; i++) {
			if(map.containsKey(data[i])) {
				Integer value = (Integer)map.get(data[i]);
				map.put(data[i], new Integer(value.intValue() + 1));
			} else {
				map.put(data[i], new Integer(1));
			}
		}
		
		Iterator it = map.entrySet().iterator();
		
		while(it.hasNext()) {
			Map.Entry entry = (Map.Entry)it.next();
			int value = ((Integer)entry.getValue()).intValue();
			System.out.println(entry.getKey() + " : " + printBar('#', value) + " " + value);
		}
			
	}
	
	public static String printBar(char ch, int value) {
		char[] bar = new char[value];
		
		for(int i=0; i < bar.length; i++)
			bar[i] = ch;
		
		return new String(bar);
	}
}

해싱과 해시함수 - 블록체인에서 체인역활을 해싱을 이용하여 개발하곤 한다
해싱이란 해시함수(hash function)를 이용해서 데이터를 해시테이블(hash table)에 저장하고 검색하는 기법을 말한다. 해시함수는 데이터가 저장되어 있는 곳을 알려 주기 때문에 다량의 데이터 중에서도 원하는 데이터를 빠르게 찾을 수 있다.

Properties
: HashMap의 구번전인 Hashtable을 상속받아 구현한 것으로, hashtable은 키와 값을 (Object, Object)의 형태로 저장하는데 비해 Properties는 (String, String)의 형태로 저장하는 보다 단순화된 컬렉션 클래스이다.
주로 애플리케이션의 환경설정과 관련된 속성(property)을 저장하는데 사용되며 데이터를 파일로부터 읽고 쓰는 편리한 기능을 제공한다.

PropertiesEx01

import java.util.Properties;

public class PropertiesEx01 {

	public static void main(String[] args) {

		Properties props = new Properties();
		
		props.setProperty("timeout", "30");
		props.setProperty("language", "kr");
		props.setProperty("size", "10");
		
		System.out.println(props.getProperty("timeout"));
	}

}

해시테이블에 키와 값을 입력하고 키를 통해서 값을 읽어온다

import java.util.Enumeration;
import java.util.Properties;

public class PropertiesEx01 {

	public static void main(String[] args) {

		Properties props = new Properties();
		
		props.setProperty("timeout", "30");
		props.setProperty("language", "kr");
		props.setProperty("size", "10");
		
		System.out.println(props.getProperty("timeout"));
		
		Enumeration e = props.propertyNames();
		while(e.hasMoreElements()) {
			System.out.println((String)e.nextElement());
		}
	}
}

전체 데이터 출력

import java.util.Enumeration;
import java.util.Properties;

public class PropertiesEx01 {

	public static void main(String[] args) {

		Properties props = new Properties();
		
		props.setProperty("timeout", "30");
		props.setProperty("language", "kr");
		props.setProperty("size", "10");
		
		System.out.println(props.getProperty("timeout"));
		
		Enumeration e = props.propertyNames();
		while(e.hasMoreElements()) {
			System.out.println((String)e.nextElement());
		}
		
		// System : 자바의 환경설정에 대한 이야기
		Properties systemProps = System.getProperties();
		Enumeration se = systemProps.propertyNames();
		while(se.hasMoreElements()) {
			String key = (String)se.nextElement();
			System.out.println(key);
		}
	}
}


import java.util.Enumeration;
import java.util.Properties;

public class PropertiesEx01 {

	public static void main(String[] args) {

		Properties props = new Properties();
		
		props.setProperty("timeout", "30");
		props.setProperty("language", "kr");
		props.setProperty("size", "10");
		
		System.out.println(props.getProperty("timeout"));
		
		Enumeration e = props.propertyNames();
		while(e.hasMoreElements()) {
			System.out.println((String)e.nextElement());
		}
		
		// System : 자바의 환경설정에 대한 이야기
		Properties systemProps = System.getProperties();
		Enumeration se = systemProps.propertyNames();
		while(se.hasMoreElements()) {
			String key = (String)se.nextElement();
			System.out.println(key);
		}
		
		System.out.println(systemProps.getProperty("java.runtime.version"));
		System.out.println(System.getProperty("os.name"));
	}
}

위와 같이 시스템의 내용을 가져올 수 있다.(java version, os version)

데이터
    임시
        - 변수
            단순 구조
            집합 구조
                Array / Collection
        => 프로그램이 끝나면 같이 없어진다
    영구
        로컬
            1. 파일(I/O)           java.io
            2. 데이터베이스(SQL)    java.sql
        원격
            + 네트워크              java.net
                                   java.io

지금까지 임시 영역을 공부하였고 이제 영구 영역에 대해서 배운다

File
자바에서는 File클래스를 통해서 파일과 디렉토리를 다룰 수 있도록 하고 있다. 그래서 File인스턴스는 파일일 수도 있고 디렉토리일 수도 있다. 앞으로 File클래스의 생성자와 메서드를 관련된 것들 끼리 나누어서 예제와 함께 설명하고자 한다.

FileEx01

import java.io.File;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f1.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
	}

}

조심 !! : 대소문자 구분함

import java.io.File;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f3.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
	}

}


import java.io.File;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f3.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
		// f1.isDirectory() - 디렉토리를 물을 때
		if(f1.isFile()) {
			System.out.println("파일");
		} else {
			System.out.println("디렉토리");
		}
	}

}

파일인지 확인

파일 확인

import java.io.File;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f3.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
		// f1.isDirectory() - 디렉토리를 물을 때
		if(f1.isFile()) {
			System.out.println("파일");
		} else {
			System.out.println("디렉토리");
		}
		
		File f5 = new File("c:/Java/test.txt");
		if(f5.canWrite()) {
			System.out.println("읽기쓰기");
		} else {
			System.out.println("읽기전용");
		}
	}
}

읽기쓰기 / 읽기전용

Unhandled exception type IOException 라는 오류구문이 생기면 IOException을 추가해 줘야 한다

import java.io.File;
import java.io.IOException;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f3.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
		// f1.isDirectory() - 디렉토리를 물을 때
		if(f1.isFile()) {
			System.out.println("파일");
		} else {
			System.out.println("디렉토리");
		}
		
		File f5 = new File("c:/Java/test.txt");
		if(f5.canWrite()) {
			System.out.println("읽기쓰기");
		} else {
			System.out.println("읽기전용");
		}
		
		// 파일의 위치 정보
		System.out.println(f5.getName());
		System.out.println(f5.getParent());
		System.out.println(f5.getPath());
		System.out.println(f5.getAbsolutePath());
		
		// surround try-catch block
		try {
			System.out.println(f5.getCanonicalPath());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

파일의 위치 정보

import java.io.File;
import java.io.IOException;

public class FileEx01 {

	public static void main(String[] args) {

		// File 생성
		// 파일이나 디렉토리 경로를 통해서 생성
		// 파일이나 디렉토리가 반드시 존재하지 않아도 객체 생성 가능하다
		
		File f1 = new File("c:\\Java");			// windows
		File f2 = new File("c:/Java");			// linux / mac
		File f3 = new File("c:/Java/test.txt");	// 파일명
		File f4 = new File("c:/Java", "test.txt");	// 경로, 파일명
		// 경로명 : 절대경로 / 상대경로(java에서 부터 상대적 위치)
		
		// exist()
		if(f3.exists()) {
			System.out.println("존재");
		} else {
			System.out.println("미존재");
		}
		// f1.isDirectory() - 디렉토리를 물을 때
		if(f1.isFile()) {
			System.out.println("파일");
		} else {
			System.out.println("디렉토리");
		}
		
		File f5 = new File("c:/Java/test.txt");
		if(f5.canWrite()) {
			System.out.println("읽기쓰기");
		} else {
			System.out.println("읽기전용");
		}
		
		// 파일의 위치 정보
		System.out.println(f5.getName());
		System.out.println(f5.getParent());
		System.out.println(f5.getPath());
		System.out.println(f5.getAbsolutePath());
		
		// surround try-catch block
		try {
			System.out.println(f5.getCanonicalPath());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// 파일 속성
		// 크기 / 최종 수정일
		long filesize = f5.length();
		System.out.println(filesize);
	}
}

 

파일 크기 / 최종수정일 확인

 

반응형
저작자표시 동일조건

'Web & Mobile > JAVA' 카테고리의 다른 글

Lecture 31 - Java(12) DataInputStream, DataOutputStream, PrintStream, System.in, out, err, Menu, RandomAccessFile, ObjectInputStream, ObjectOutputStream  (0) 2023.06.20
Lecture 30 - Java(11) File, InputStream, OutputStream, 보조스트림, FileReader, ZipCode 검색  (0) 2023.06.20
Lecture 28 - Java(9) 로또발생기, StringTokenizer, StringJoiner, Scanner, Arraylist  (0) 2023.06.20
Lecture 27 - Java(8) 추상화, 형변환, 다형성, 예외처리  (0) 2023.06.20
Lecture 26 - Java(7) 주민번호체크, wrapper 클래스, Date, Calendar  (0) 2023.06.20

관련글

댓글

티스토리툴바