TIL(22.3.30.WED)

184561 단어 Java 표기법Java 변수java 자료형Java 변수

변수(Variable)

  • 자료형 변수이름 = 자료형에 해당하는 데이터값;

변수 사용하기

public class Main {
    public static void main(String[] args) {

//      1. 변수 사용하기
        System.out.println("== 변수 사용하기 ==");
        int age = 10;
        System.out.println(age);
        String country = "Korea";
        System.out.println(country);
	}
}
  • (자료형) (변수이름) = (자료형에 해당하는 값);
    • 변수 앞에 항상 값에 대한 데이터 타입을 기입해야 한다.

변수 이름 규칙

  • 문자, 숫자, _(underscore), $ 사용 가능
    public class Main {
    public static void main(String[] args) {
        int apple = 2000;
        int apple3 = 2000;
        int _apple = 2000;
        int $apple = 2000;
        System.out.println("apple = " + apple);
        System.out.println("apple3 = " + apple3);
        System.out.println("_apple = " + _apple);
        System.out.println("$apple = " + $apple);
    }
}
  • 숫자로 시작 X
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int 3apple = 2000;
		System.out.println(3apple);
	}
}
  • 대소문자 구분
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int apple = 1000;
		int Apple = 2000;
		System.out.println(apple);
		System.out.println(Apple);
	}
}
    • 위에 이미 사용한 변수가 있을 경우 중복으로 사용할 수 없다.
  • 공백 사용 X
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int one apple = 1000;
		System.out.println(one apple);
	}
}
  • 공백을 카멜표기법, _(underscore)로 대체 사용
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int one_apple = 1000;
		int oneApple = 1000;
		System.out.println(one_apple);
		System.out.println(oneApple);
	}
}
  • 예약어 사용 X

    • 예약어 예시: true, false, if, switch, for, continue, break, ....

      package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int true = 1000;
		System.out.println(true);
	}
}
  • 참고) 변수명에 한글 사용 가능
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int 사과 = 1000;
		System.out.println("사과 = " + 사과);
	}
}
    • 기본적으로 변수명의 코드는 영어로 작성되다보니 한글은 사용하지 않는 추세. 그러니 참고로만 알아두자

표기법

  • 카멜 표기법(camelCase)
    • 변수명, 함수명에 사용
      package testPackage;

public class JavaPrac {
	public static void main(String[] args) {
		int myAge = 25;
		int oneApplePrice = 1000;
	}
}
  • 파스칼 표기법(PascalCase)
    • 클래스명에 사용
      package testPackage;

public class JavaPrac {
	public static void main(String[] args) {
		int MyAge = 25;
		int OneApplePrice = 1000;
	}
}
  • 참고) 스네이크 표기법(snake_case)
    package testPackage;

public class Javaprac {
	public static void main(String[] args) {
		int my_age = 25;
		int one_apple_price = 1000;
	}
}
    • 자바에서는 잘 쓰이지 않고, 파이썬에 자주 쓰임.
    • 대체로 소문자 snake표기법이 통상적이나 java같은 경우에 대문자 snake표기법이 이런데에서 등장한다.
      • 변경되지 않는 상수값과 같은 곳에 대문자snake표기법이 사용된다.
        System.out.println(Integer.MAX_VALUE);

자료형 - 숫자

  • 정수
    • 정수자료형⇒int, long 정수명 = 정수데이터값;
    • 데이터를 담을 수 있는 자료 타입에 int와 long이 있다
      • int
        • 4byte
        • 상대적으로 작은 데이터를 받음
        • 표현 범위
          • -2147483648 ~ 2147483647
      • long
        • 8byte
        • 상대적으로 큰 데이터를 받음
        • 표현 범위
          • -9223372036854775808 ~ 9223372036854775807
  • 실수
    • 실수자료형⇒float, double 실수명 = 실수데이터값;
    • 데이터를 담을 수 있는 자료 타입에 float과 double이 있다.
      • float
        • 4byte
        • 상대적으로 작은 데이터를 받음
      • double
        • 8byte
        • 상대적으로 큰 데이터를 받음
  • 진수
    • 정수자료형⇒int, long 진수명 = 진수포맷값;
    • 이해에 도움되는 출처
    • 2진수
      • 0~1로 이루어진 숫자
        • 0,1/10,11....
    • 10진수
      • 0~9로 이루어진 숫자
        • 0~9/10,11....
    • 8진수
      • 0~7로 이루어진 숫자
        • 0~7/10,11.....
    • 16진수
      • 0~9 & A~F로 이루어진 숫자
        • 0~9,A~F/10,11.....
    • 10진수 12를 다른 진수로 표현하라
      • 2진수
        • 0b이용
          int numBase2 = 0b1100;
      • 8진수
        • 0이용
          int numBase8 = 014;
      • 16진수
        • 0x사용
          int numBase16 = 0xC;
  • 숫자자료형(Number)

    • 정수자료형

      • 정수자료형표현하기

        public class Main {
    public static void main(String[] args) {
        int intNum = 10;
        System.out.println("intNum = " + intNum);
    }
}

      • 정수(Integer)의 최댓값(MAX_VALUE), 최솟값(MIN_VALUE)알아보기

        • 최댓값(MAX_VALUE)

          public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
    }
}
          • Integer가 담을 수 있는 Max값이 표시됨.
          • 대체로 소문자 snake표기법이 통상적이나 java같은 경우에 대문자 snake표기법이 이런데에서 등장한다.
          • 대문자 snake 표기법은 대개 상수와 같이 변하지 않는 것에 쓰이는듯.
            • 변경되지 않는 상수값이라고 한다.

        • 최솟값(MIN_VALUE)

          public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);
    }
}
          • Integer가 담을 수 있는 Min값이 표시됨.

      • int 와 Integer

        • int는 기본 타입으로 본다.
        • Integer는 기본 타입에 더해서 몇가지 기능이 더 있다라고 이해해두자
        • int와 Integer의 차이 알아보기

      • int 정수의 최댓값을 넘어간 값을 기입했을 때 데이터가 어떻게 변하나?

        public class Main {
    public static void main(String[] args) {
        int intNum2 = Integer.MAX_VALUE;
        int intNum3 = Integer.MAX_VALUE + 1;
        System.out.println("intNum2 = " + intNum2);
        System.out.println("intNum3 = " + intNum3);
    }
}

        • 그 다음 값이 Max값을 넘어가 Integer의 최솟값으로 출력된다.

        • long으로 형변환하여 Integer의 최댓값 넘어간 값 표현해보기

          public class Main {
    public static void main(String[] args) {
        int intNum2 = Integer.MAX_VALUE;
				System.out.println("intNum2 = " + intNum2);
        long longNum = (long)Integer.MAX_VALUE + 1;
        System.out.println("longNum = " + longNum);
    }
}
          • Integer의 최댓값(MAX_VALUE)보다 더 큰 수를 담기 위해서는 정수형 자료형중에 long타입을 쓴다.

    • 실수자료형

      • 실수형 자료형표현하기
        • float자료형같은 경우 값의 마지막자리에 f를 넣어주지 않으면, double로 인식함. 그래서 f를 넣어줘야함.
          public class Main {
    public static void main(String[] args) {
        float floatNum = 1.23f;
				System.out.println(floatNum);
        double doubleNum = 1.23;
        System.out.println(doubleNum);
    }
}
      • float, double의 최댓값(MAX_VALUE) 나타내기
        • float의 최댓값
          public class Main {
    public static void main(String[] args) {
        System.out.println(Float.MAX_VALUE);
    }
}
          • E38은 10의 38승을 의미
        • double의 최댓값
          public class Main {
    public static void main(String[] args) {
        System.out.println(Double.MAX_VALUE);
    }
}
          • E308은 10의 308승을 의미

    • 진수자료형

      • 2진수, 8진수, 16진수를 10진수 12로 출력하기
        public class Main {
    public static void main(String[] args) {
        int numBase2 = 0b1100;
				System.out.println("numBase2 = " + numBase2);
        int numBase8 = 014;
				System.out.println("numBase8 = " + numBase8);
        int numBase16 = 0xC;
        System.out.println("numBase16 = " + numBase16);
    }
}
      • 2진수 / 8진수 / 16진수 원래 포맷 그대로 출력하기
        public class Main {
    public static void main(String[] args) {
        int numBase2 = 0b1100;
				System.out.println("0b" + Integer.toBinaryString(numBase2));
        int numBase8 = 014;
				System.out.println("0" + Integer.toOctalString(numBase8));
        int numBase16 = 0xC;
        System.out.println("0x" + Integer.toHexString(numBase16));
    }
}

자료형 - 부울

  • 부울자료형⇒boolean 부울명 = true or false;
  • 부울자료형(Boolean)
    public class Main {
    public static void main(String[] args) {
        boolean isPass = true;
				System.out.println("isPass = " + isPass);
        boolean isOk = false;
        System.out.println("isOk = " + isOk);
    }
}

자료형 - 문자

  • 문자자료형⇒char 문자명 = ‘문자데이터값’
  • 문자자료형(Character)
    public class Main {
    public static void main(String[] args) {
        char keyFirst = 'a';
				System.out.println("keyFirst = " + keyFirst);
        char keyLast = 'z';
        System.out.println("keyLast = " + keyLast);
    }
}
    • 문자 자료형데이터를 int로 형변환 시켜보기
      • 아스키 코드값이란

        • 문자 데이터들이 각각 어떤 숫자로 맵핑(매치?)되어 있음
          - 문자에 대해 각각의 숫자가 할당 되어 있음. 즉 문자에 정수 형변환 코드인 (int) 를 통해 구현하는듯

          public class Main {
    public static void main(String[] args) {
        char keyFirst = 'a';
				System.out.println("keyFirst = " + keyFirst);
        char keyLast = 'z';
        System.out.println("keyLast = " + keyLast);
        System.out.println((int)keyFirst);
        System.out.println((int)keyLast);
    }
}

자료형 - 문자열

  • 문자열자료형⇒String 문자열명 = “문자열 데이터값”
  • 문자열(String)
    • 문자열 나타내기
      public class Main {
    public static void main(String[] args) {
        String s1 = "Hello World!";
				System.out.println("s1 = " + s1);
        String s2 = "01234";
        System.out.println("s2 = " + s2);
    }
}

    • 문자열 메소드
    • equals
    • 문자열의 값을 비교해주는 메소드
    • 문자열.equals(비교대상 문자열)
      public class Main {
    public static void main(String[] args) {
        String s3 = "Hi";
        String s4 = "Hi";
        System.out.println(s3.equals(s4));
        System.out.println(s3 == s4);
    }
}
      • 비교연산자== 와 equals의 차이
        • equals는 값만 비교해주는 메서드
        • 비교연산자== 는 값과 객체를 비교해주는 연산자 즉, 객체가 같은지 다른지 판단할 때 유용할듯
          • 객체에 대한 설명도 class파트로 가야 좀 더 명확하지만 아래에 간략하게 설명해보도록 한다. 😀
        • 뭔가 값에 따라 객체가 생성되어 메모리에 저장되는듯. 즉, 객체 생성은 값과 관련있는 것 같다.
        • 따라서, 객체 생성은 1. 값을 다르게 정의하여 생성 2. new String을 이용하여 명시적으로 생성
          • 새로운 변수를 정의하는데 값이 같아 객체는 따로 객체를 생성하지 않는다.
            public class Main {
    public static void main(String[] args) {
        String s3 = "Hi";
        String s5 = "Hi";
        System.out.println(s3.equals(s5));
        System.out.println(s3 == s5);
    }
}
            • 문자열은 기존에 메모리에 잡혀있는 똑같은 데이터가 있으면 새로 객체를 만드는게 아니라 그냥 기존것에 잡아준다.
              • 따라서 s3와 s5를 비교연산자를 이용하여 비교하면 동일한 객체 Hi를 가리키므로 true가 반환.
          • 새로운 변수를 정의하는데 값이 같아 new String으로 새로운 문자열객체를 생성하는 경우
            public class Main {
    public static void main(String[] args) {
        String s3 = "Hi";
        String s5 = new String("Hi");
        System.out.println(s3.equals(s5));
        System.out.println(s3 == s5);
    }
}
            • new String의 경우는 아예 명시적으로 새롭게 데이터를 하나 만들어준것이기에 별도로 데이터 메모리객체가 잡히고 그 객체를 가리킨다.
              • 따라서 s3와 s5를 비교연산자를 이용하여 비교하면 객체가 서로 다르기에 반환값이 false로 반환됨.
          • 새로운 변수를 정의하는데 값이 달라 새로운 객체가 생성된다.
            public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        String s7 = s6.replace("Hello", "Bye");
        System.out.println("s6 = " + s6);
        System.out.println("s7 = " + s7);
        System.out.println(s6 == s7);
    }
}

  • indexOf
    • 문자열에서 특정 문자의 위치를 찾아주는 메소드
    • 문자열.indexOf(특정문자, default(인덱스번호0))
      public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        System.out.println(s6.indexOf("!"));
    }
}
      • 어디서부터 찾을 건지 위치를 지정할 수 있다. 즉, default값에 인덱스 번호 부여시 해당 인덱스 번호 후 부터 찾는다.
        • 첫 번째 찾은 특정 문자 뒤에 똑같은 특정 문자를 찾을 때
          • 문자열.indexOf(특정문자, 인덱스번호)
            public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        System.out.println(s6.indexOf("!", 6));
    }
}

          • 좀 더 프로그래머적으로 찾기
            • 인덱스 번호를 indexOf의 반환이 숫자인 점 활용
              public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        System.out.println(s6.indexOf("!", s6.indexOf("!") + 1));
    }
}
  • replace
    • 문자열에서 특정 문자를 다른 문자로 바꿀때 사용하는 메소드
    • 문자열.replace(기존 문자, 바꿀 문자)
      • 기존 정의한 변수에 바꾼 값 넣기
        public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        s6 = s6.replace("Hello", "Bye");
        System.out.println("s6 = " + s6);
    }
}
      • 새로운 변수를 정의하여 바꾼 값 넣기
        public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
				System.out.println("s6 = " + s6);
        String s7 = s6.replace("Hello", "Bye");
        System.out.println("s7 = " + s7);
    }
}

  • substring
    • 문자열에서 특정 인덱스 범위를 지정하여 그 부분만 출력하게 하는 메소드
      • 즉, 기존 문자열에서 부분 문자열을 뽑는다.
    • 문자열.substring(인덱스시작점, 인덱스끝점)
      • s6.substring(0, 3) → 인덱스번호0~인덱스번호2 까지 출력
        public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        s6 = s6.replace("Hello", "Bye");
        System.out.println("s6 = " + s6);
        System.out.println(s6.substring(0, 3));
    }
}

    • 활용
      • indexOf 활용 반환값이 숫자인 점을 인덱스번호에 이용
        public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        s6 = s6.replace("Hello", "Bye");
        System.out.println("s6 = " + s6);
        System.out.println(s6.substring(0, s6.indexOf("!")+ 1));
    }
}

  • toUpperCase
    • 문자열을 모두 대문자로 변환시키는 메소드
    • 문자열.toUppercase()
      public class Main {
    public static void main(String[] args) {
        String s6 = "Hello! World!";
        System.out.println("s6 = " + s6);
        System.out.println(s6.toUpperCase());
    }
}

자료형 - StringBuffer

  • 문자열자료형⇒String 문자열명 = “문자열 데이터값”
  • 문자열의 데이터가 많이 변경되거나 중간에 삭제되거나 이런일이 빈번하게 발생 할때는 StringBuffer를 사용하는게 좋다.
    • StringBuffer의 경우에는 데이터가 막 변경되도, 새로운 객체를 생성하여 만들지 않음. 즉, 기존 객체, 기존 메모리에서 데이터의 수정이 이루어짐.
      public class Main {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
        sb1.append("01234");
        System.out.println("sb1 = " + sb1);
        sb1.append("56789");
        System.out.println("sb1 = " + sb1);
    }
}

    • String의 경우에는 데이터의 변화가 일어날 때마다 새로운 객체를 생성한다. 즉, 새로운 메모리를 생성하여 데이터를 할당함.
      • 따라서 객체가 여러번 만들어진다는것은 다른말로 메로리가 여러번 생성되는 거고, 시스템적으로 속도 딜레이가 발생함.
        public class Main {
    public static void main(String[] args) {
        String a = "01234";
        String b = "56789";
        String c = a;
        System.out.println(a);
        System.out.println(c);
        System.out.println(a == c);
    }
}
        public class Main {
    public static void main(String[] args) {
        String a = "01234";
        String b = "56789";
        String c = a;
        System.out.println(c);
        
        a += b;
        System.out.println(a);
        System.out.println(a == c);
    }
}

자료형 - 배열

  • 자료형[] 배열명 = {자료형에 해당하는 데이터값들};
  • 배열(Array)생성
    • 데이터 초기화
      • 정수형 배열생성
        int[] myArray1 = { 1, 2, 3, 4, 5 };
      • 정수형 배열생성후 출력하기
        • 일일이 인덱스번호로 출력하기
          public class Main {
    public static void main(String[] args) {
        int[] myArray1 = {1,2,3,4,5};
        System.out.println(myArray1[0]);
        System.out.println(myArray1[1]);
        System.out.println(myArray1[2]);
        System.out.println(myArray1[3]);
        System.out.println(myArray1[4]);
    }
}

        • 반복문 사용하여 출력하기
          public class Main {
    public static void main(String[] args) {
        int[] myArray1 = {1, 2, 3, 4, 5};
        for (int i = 0; i < myArray1.length; i++) {
            System.out.println(myArray1[i]);
        }
    }
}

        • java.util.Arrays의 toString()메소드 사용하여 출력하기
          • java.util.Arrays.toString() 메소드를 사용. 이 메소드는 파라미터로 배열을 입력받아서 배열에 정의된 값들을 문자열 형태로 만들어서 리턴해줌.
            import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] myArray1 = { 1, 2, 3, 4, 5 };
        System.out.println(Arrays.toString(myArray1));
    }
}

    • 특정 데이터 갯수 명시하기
      • 데이터요소갯수가 3개인 문자열 배열을 생성
        String[] myArray3 = new String[3];
        • 3개의 데이터가 들어갈 수 있는 String배열 생성
      • 인덱스번호를 이용하여 직접 데이터 넣고, 출력하기
        • 데이터 인덱스에 직접 넣기
          String[] myArray3 = new String[3];
myArray3[0] = "Hello";
myArray3[1] = " ";
myArray3[2] = "World!";
        • 데이터 출력하기
          • 자료형이다 보니 + 이용하여 출력
            public class Main {
    public static void main(String[] args) {
        String[] myArray3 = new String[3];
        myArray3[0] = "Hello";
        myArray3[1] = " ";
        myArray3[2] = "World!";
        System.out.println(myArray3[0] + myArray3[1] + myArray3[2]);
    }
}

          • 일일이 출력하기
            public class Main {
    public static void main(String[] args) {
        String[] myArray3 = new String[3];
        myArray3[0] = "Hello";
        myArray3[1] = " ";
        myArray3[2] = "World!";
        System.out.println(myArray3[0]);
        System.out.println(myArray3[1]);
        System.out.println(myArray3[2]);
    }
}

          • 반복문 사용하여 출력하기
            public class Main {
    public static void main(String[] args) {
        String[] myArray3 = new String[3];
        myArray3[0] = "Hello";
        myArray3[1] = " ";
        myArray3[2] = "World!";
        for (int i = 0; i < myArray3.length; i++) {
            System.out.println(myArray3[i]);
        }
    }
}

          • java.util.Arrays의 toString()메소드 사용하여 출력하기
            import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] myArray3 = new String[3];
        myArray3[0] = "Hello";
        myArray3[1] = " ";
        myArray3[2] = "World!";
        System.out.println(Arrays.toString(myArray3));
    }
}

    • 주의할 점
      • 정수형 배열생성후 출력에서 문제발생
        public class Main {
    public static void main(String[] args) {
        int[] myArray1 = {1,2,3,4,5};
        System.out.println(myArray1);
    }
}
        • 위와 같이 출력하게 되면 myArray1라는 변수가 가리키고 있는, [1, 2, 3, 4, 5] 값이 들어있는 메모리의 주소값이 출력됨.
          • 따라서 반복문을 사용하거나, 배열을 출력할 수 있는 특별한 메소드를 이용해야 함.

자료형 - 리스트

  • 리스트자료형 ⇒ ArrayList 리스트명 = new ArrayList();
  • 리스트(List) 생성
    public class Main {
    public static void main(String[] args) {
			ArrayList li = new ArrayList();
	}
}
    • 에러가 발생하는 이유는?
      • Java의 기본적인 Class를 사용할건데, ArrayList를 사용하겠다고 명시가 되지 않아서 그렇다.
      • Java에 기본적으로 포함되어 있지 않은 애들은 위의 사진처럼 띄어짐. 따라서 해당위치를 클릭하고 마우스를 갖다 대고 alt + enter를 누르면 도움말이 뜸
      • Import class를 적용해준다.
      • 따라서 ArrayList를 사용하려면 import java.util.ArrayList; 를 해줘야함.
        import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
			ArrayList li = new ArrayList();
	}
}
        • Tip
          • 일일이 코드를 작성하지 않고, 어느 부분까지 코드를 작성하다 보면 자동완성이 띄어짐 그걸 enter하면 위와 같은 사진이 바로 적용된다.
            • 일일이 쓰지말고, 자동완성을 이용하자.
  • 리스트(List) 메소드
    • add ⇒ 리스트 안에 데이터 추가하는 메소드
      • 리스트명.add(추가하는 데이터값);
        import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        System.out.println("li = " + li);
	}
}

      • 구체적으로 위치를 지정하여 데이터 넣기
        • 리스트명.add(인덱스번호, 추가하는 데이터값);
          import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        System.out.println("li = " + li);
        //인덱스번호에 데이터 추가
        //형태: 리스트명.add(index, 추가할 데이터)
        li.add(0, "inoh");
        System.out.println("li = " + li);
    }
}

    • get ⇒ 리스트 안의 데이터를 출력하는 메소드
      • 리스트명.get(출력한 데이터 위치 인덱스)
        import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        li.add(0, "inoh");

        System.out.println(li.get(0));
        System.out.println(li.get(3));
    }
}

    • size ⇒ 리스트 안에 들어 있는 데이터갯수(원소갯수) 출력하는 메소드
      • 숫자 자료형으로 반환
      • 리스트명.size()
        import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        li.add(0, "inoh");

        System.out.println(li.size());
    }
}

    • remove ⇒ 리스트 안에 들어있는 데이터 지우는 메소드
      • 구체적인 위치index를 지정하여 해당하는 데이터를 지운다
        • 리스트명.remove(인덱스번호)
          • 지우려는 인덱스번호에 위치한 데이터가 출력하고, 그 데이터가 지워져서 출력됨.
            import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        li.add(0, "inoh");

        System.out.println(li.remove(0));
        System.out.println("li = " + li);
    }
}

      • 인덱스번호를 이용하여 지우지 않고, 데이터값을 명시적으로 작성하여 지울경우
        • 리스트명.remove(Integer.valueOf(지울 데이터값))
          import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        li.add(0, "inoh");

        System.out.println(li.remove(Integer.valueOf(2)));
        System.out.println("li = " + li);
    }
}

    • clear ⇒ 리스트안의 모든 데이터를 제거하는 메소드
      • 리스트명.clear()
        import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li = new ArrayList();
        li.add(1);
        li.add("hello");
        li.add(2);
        li.add(3);
        li.add(4);
        li.add("world!");
        li.add(0, "inoh");

        li.clear();
        System.out.println("li = " + li);
    }
}

    • sort ⇒ 내림차순, 오름차순으로 정렬해주는 메소드
      • 새로운 리스트 생성
        import java.util.ArrayList;
import java.util.Comparator;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li2 = new ArrayList();
        li2.add(5);
        li2.add(3);
        li2.add(4);
        System.out.println("li2 = " + li2);
    }
}

      • 오름차순 형태
        • import java.util.Comparator; 해줘야 함
        • 리스트명.sort(Comparator.naturalOrder())
          import java.util.ArrayList;
import java.util.Comparator;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li2 = new ArrayList();
        li2.add(5);
        li2.add(3);
        li2.add(4);
        System.out.println("li2 = " + li2);
        li2.sort(Comparator.naturalOrder());
        System.out.println("li2 = " + li2);

    }
}

      • 내림차순 형태
        • import java.util.Comparator; 해줘야 함
        • 리스트명.sort(Comparator.reverseOrder())
          import java.util.ArrayList;
import java.util.Comparator;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li2 = new ArrayList();
        li2.add(5);
        li2.add(3);
        li2.add(4);
        System.out.println("li2 = " + li2);
        li2.sort(Comparator.reverseOrder());
        System.out.println("li2 = " + li2);

    }
}

      • 여기서는 sort함수 도움을 받아서 정렬을 하였는데, 이 정렬에 대한거는 나중에 알고리즘 파트에서 다양한 정렬 알고리즘을 사용해보고 각각의 복잡도같은 것이 어떻게 되는지 살펴볼것임.
    • contains ⇒ 데이터가 리스트에 들어있는지 확인하는 메소드
      • boolean 자료형으로 반환됨.
      • 리스트명.contains(확인해보려하는 데이터값)
        import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList li2 = new ArrayList();
        li2.add(5);
        li2.add(3);
        li2.add(4);
        System.out.println("li2 = " + li2);
        System.out.println(li2.contains(1));
        System.out.println(li2.contains(3));

    }
}

자료형 - 맵

  • 맵자료형⇒HashMap 제네릭스형태 Map명 = new HashMap 제네릭스형태 ();
  • 맵(Map)생성
    • 쌍을 이뤄 저장하는 데이터 자료형(key,value)
    • import java.util.HashMap; 해줘야 함
      import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
    }
}
  • 맵(Map) 메소드
    • put ⇒ 데이터 추가하는 메소드
      • 맵명.put(key⇒키값,value⇒데이터값)
        import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
    }
}
        • 주의
          • map은 index가 적용되지 않아 코드기입 순서대로 출력결과가 나오지 않음.
    • get ⇒ value⇒데이터값 꺼내오는 메소드
      • 맵명.get(key ⇒ 키값)
        import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.get("kiwi"));
    }
}

      • map자료형에 없는 value⇒데이터값을 호출할 경우
        • null값이 반환됨.
          import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.get("mandarin"));
    }
}

    • size ⇒ 몇 개의 원소(데이터)가 들어있는지 알려주는 메소드
      • 숫자자료형으로 반환
      • 맵명.size()
        import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.size());
    }
}

    • remove ⇒ 데이터를 지우는 메소드
      • 맵명.remove(지우려는 key⇒키값)
        • 지우려는 데이터값을 출력하고 key와 value가 지워짐
          import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.remove("kiwi"));
        System.out.println("map = " + map);

    }
}

      • map자료형에 없는 데이터쌍을 지울 경우
        • null값이 반환됨
          import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.remove("mandarine"));
        System.out.println("map = " + map);

    }
}

    • containsKey ⇒ 찾으려는 키값이 맵에 있는지 확인하는 메소드
      • boolean자료형으로 반환
      • 맵명.containsKey(확인하려는 key⇒키값)
        import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("kiwi", 9000);
        map.put("apple", 10000);
        map.put("mango", 12000);
        System.out.println("map = " + map);
        System.out.println(map.containsKey("kiwi"));
        System.out.println(map.containsKey("peach"));

    }
}

자료형 - 제네릭스

  • 자료형<명시할 자료형> 자료형암시하는 이름 = 자료형 관련 데이터값;
  • 자료형<명시할 자료형, 명시할 자료형> 자료형 암시하는 이름 = 자료형 관련 데이터값;
  • 제네릭스(Generics)생성
    • 리스트(List)형으로 생성
      • Generics 사용하지 않는 경우
        • 문자, 숫자 가리지 않고 즉, 모든 자료형 다 받을 수 있다.
          import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList l3 = new ArrayList();
        l3.add(1);
        l3.add("hello");
        System.out.println("l3 = " + l3);
    }
}

      • Generics 사용하는 경우
        • 문자열만 받는다고 Generics를 통해 제한 했으므로 그 외의 자료형은 받을 수 없음
          import java.util.ArrayList;

public class MyPrac {
    public static void main(String[] args) {
        ArrayList<String> l4 = new ArrayList<String>();
        l4.add("bye");
        System.out.println("l4 = " + l4);
    }
}

    • 맵(Map)형으로 생성
      • Generics 사용하지 않는 경우
        import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap map1 = new HashMap();
        map1.put(123, "id");
        map1.put("apple", 10000);
        System.out.println("map1 = " + map1);
    }
}

      • Generics 사용하는 경우
        • Generics를 앞에 선언 이후 뒤 재선언 부분에서는 암묵적으로 생략가능
          import java.util.HashMap;

public class MyPrac {
    public static void main(String[] args) {
        HashMap<String, Integer> map2 = new HashMap();
        map2.put("apple", 10000);
        map2.put("kiwi", 20000);
        System.out.println("map2 = " + map2);
    }
}
[프로그래머스] - 콜라츠 추측(Java)
[Spring] 기본편 05. 싱글톤 컨테이너

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage