List Management Functions in java

Learn different types of List function

이번에 포스팅 할 내용은 프로그램 안에서생겨나는 

많은 데이터들을 필요조건에 맞게 함수를 사용하여 관리하는 방법을 기록하겠습니다.

# List

: data를 쉽게 관리하기 위한 기능

2018/05/23 - [Java/Open source] - 알고리즘을 이용한 동적배열(Dynamic Array)

2018/05/23 - [Java/Open source] - ArrayList를 이용한 동적배열(Dynamic Array)

 

# 종류

List - ArrayList , LinkedList

Map - HashMap , TreeMap

Standard Template Library(STL)

# ArrayList == Vector

배열목록 - 배열(Array[])처럼 사용 할 수 있다.

선형구조를 이루고 있다.

검색속도 빠르다

저장된 파일은 index number 주소값을 가지게 된다.

# LinkedList

연결목록 - 배열(Array[])처럼 사용 할 수 있다.

선형구조를 이루고 있다.

검색속도 LinkedList < ArrayList

저장된 파일은 index number 주소값을 가지게 된다.

추가, 삭제가 실시간으로 빈번할 때 우수하다.

(ex. 드레곤플라이트 - 총알)

* ArrayList와 LinkedList는 데이터의 교환이 자유로워

필요에 따라 데이터 형을 바꿔 사용할 수 있다.

import java.util.ArrayList;
 
public class mainClass {
 
    public static void main(String[] args) {
        
        // 배열 arrList[]
        ArrayList<Integer> arrList = new ArrayList<Integer>();
        
        // 추가
        arrList.add(111);
        Integer iObj = new Integer(222);
        arrList.add(iObj);
        arrList.add(333);
        
        // 특정 element에 추가
        arrList.add(1, 111);
        
        // 리스트의 길이 - element == 요소(node)
        int len = arrList.size();
        System.out.println("len = "+len);
        
        // 모두 출력
        for (int i = 0; i < arrList.size(); i++) {
            System.out.println("arrList["+i+"] = "+arrList.get(i));
        }
        
        // 삭제
        arrList.remove(1);
        for (int i = 0; i < arrList.size(); i++) {
            System.out.println("arrList["+i+"] = "+arrList.get(i));
        }
        
        // 검색
        int findIndexNum = arrList.indexOf(222);
        System.out.println("findIndexNum = "+findIndexNum);
        
        // 수정
        arrList.set(1, 111-222);
        System.out.println("arrList["+1+"] = "+arrList.get(1));
        
        
        // for-each 문
        int arr[] = {1,2,3};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        for(int val : arr) {
            System.out.println(val);
        }
        
        // for-each 응용
        for(Integer integer : arrList) {
            System.out.println(integer);
        }
    }
}
 

package main;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Vector;
 
public class mainClass {
 
    public static void main(String[] args) {
        Vector<String> vec = new Vector<String>(); // ArrayList
 
        vec.add("Hello");
 
        String str = new String("world");
        vec.add(str);
 
        ArrayList<String> aList = new ArrayList<String>();
        aList.add("hys");
        aList.add("hys1");
        aList.add("hys2");
 
        LinkedList<String> lList = new LinkedList<String>(aList); // .addFirst 기능이 가능하다.
 
        for (int i = 0; i < lList.size(); i++) {
            System.out.println("lList[" + i + "] = " + lList.get(i));
        }
 
        if (lList.isEmpty()) { // lList 값이 null일때 사용
            System.out.println("리스트가 비어있습니다.");
        }
 
        lList.addFirst("first");
        for (int i = 0; i < lList.size(); i++) {
            System.out.println("lList[" + i + "] = " + lList.get(i));
        }
 
        ArrayList<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");
        list.add("333");
 
        // iterator == 반복자 -> 포인터
        Iterator<String> it;
        it = list.iterator();
 
        // 속도의 차이
        // 1등
        while (it.hasNext()) { // iterator과 함께 사용
            String _str = it.next(); // next : 다음포인터로 이동 & 값을 리턴
            System.out.println("str = " + _str);
        }
        // 2등
        for (String s : list) {
            System.out.println(s);
        }
        // 3등
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

# HashMap

Tree 구조를 이루고 있다.

pair로 관리된다(key, value)

검색속도가 매우 빠르다

# TreeMap

Tree 구조를 이루고 있다.

pair로 관리된다(key, value)

처리속도 TreeMap < HashMap

정렬이 가능하다.(Sorting - 올림,내림)

package main;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
 
import dto.dtoClass;
 
public class mainClass {
 
    public static void main(String[] args) {
        /*
         * hashMap : 사전 apple : 사과 사과 : apple key : value -> 1 pair XML JSON(hashMap이랑
         * JSON이랑 중요!!!)
         * 
         * key의 값의 중복을 허용하지 않는다. Tree 구조
         * 
         * treeMap : hashMap + sorting
         */
 
        HashMap<Integer, String> hMap = new HashMap<Integer, String>();
 
        // 추가
        hMap.put(111, "일일일");
        hMap.put(222, "이이이");
        hMap.put(333, "삼삼삼");
 
        // 검색
        boolean b = hMap.containsKey(new Integer(333));
        System.out.println("b =" + b);
        String value = hMap.get(222);
        System.out.println("value = " + value);
 
        if (hMap.containsKey(333)) {
            value = hMap.get(333);
            System.out.println("value = " + value);
        }
 
        // 삭제
        String d = hMap.remove(222);
        System.out.println("b = " + b);
 
        // 수정
        hMap.replace(111, "111");
        hMap.put(111, "2323232");
        value = hMap.get(111);
        System.out.println("value = " + value);
 
        // 전체출력
 
        // Iterator
        Iterator<Integer> keys = hMap.keySet().iterator();
        while (keys.hasNext()) {
            Integer key = keys.next();
            System.out.println("key = " + key + " value = " + hMap.get(key));
        }
 
        // for
        for (Integer key : hMap.keySet()) {
            System.out.println("key = " + key + " value = " + hMap.get(key));
        }
 
        HashMap<String, String> sMap = new HashMap<>();
        sMap.put("apple", "사과");
        sMap.put("pear", "배");
        sMap.put("grape", "포도");
 
        // 취득
        String val = sMap.get("grape");
        System.out.println("val = " + val);
 
        // 수정
        sMap.replace("apple", "애플");
        val = sMap.get("apple");
        System.out.println("val = " + val);
 
        // sorting
        TreeMap<String, String> trMap = new TreeMap<>(sMap);
 
        // 오름 차순
        /*
         * Iterator<String> itKey = trMap.keySet().iterator(); while(itKey.hasNext()) {
         * String key = itKey.next();
         * System.out.println("key = "+key+" value = "+trMap.get(key));
         */
 
        // 내림 차순
        Iterator<String> itKey = trMap.descendingKeySet().iterator();
        while (itKey.hasNext()) {
            String key = itKey.next();
            System.out.println("key = " + key + " value = " + trMap.get(key));
 
        }
 
        HashMap<Integer, dtoClass> myMap = new HashMap<>();
        dtoClass dto = new dtoClass();
        Scanner sc = new Scanner(System.in);
 
        int count = 1;
 
        // 추가
        String name;
        int number;
        System.out.println("이름 = ");
        name = sc.next();
        System.out.println("번호 = ");
        number = sc.nextInt();
        myMap.put(count, new dtoClass(number, name));
 
        // 검색 - 이름
        boolean check = myMap.containsKey(new Integer(number));
        System.out.println("b =" + b);
        String _value = myMap.get(number).toString();
        System.out.println("value = " + _value);
 
        // 수정
        System.out.println("이름 = ");
        name = sc.next();
        System.out.println("번호 = ");
        number = sc.nextInt();
        myMap.replace(number, new dtoClass(number, name));
        val = myMap.get(number).toString();
        System.out.println("val = " + val);
 
        // 삭제
        myMap.remove(count);
 
        // 출력
        Iterator<Integer> keyss = myMap.keySet().iterator();
        while (keyss.hasNext()) {
            Integer key = keyss.next();
            System.out.println("key = " + key + " value = " + myMap.get(key));
        }
    }
}