* 자바의 자료타입
|
값 유형 |
자료 타입 |
디폴트값 |
크기 |
최소값 |
최대값 |
|
정수 |
byte |
0 |
8bit |
-128 |
127 |
|
short |
0 |
16bit |
-32758 |
32768 |
|
|
int |
0 |
32bit |
-2147483648 |
2147473647 |
|
|
long |
0 |
64bit |
-9223372036854775808 |
9223372036854775807 |
|
|
실수 |
float |
0.0 |
32bit |
-3.4 * 10 -38 |
3.4 * 10 38 |
|
double |
0.00 |
64bit |
-1.7 * 10 -308 |
1.7 * 10 308 |
|
|
true/false |
boolean |
false |
1bit |
없음 |
없음 |
|
유니코드 문자 |
char |
u0000 |
16bit |
‘\u0000' |
'\uFFFF' |
* char형: 2byte, 16진수 0000~ffff(65536개의 코드 사용, 0~65535)
* 유니코드
널 -> 0
공백 -> 32
0 -> 48, 9 -> 57
a -> 97, z -> 122
A -> 65, Z -> 90
* 접근 제어자와 접근 허용 범위
|
접근 제어자 |
자신의 클래스 |
같은 패키지 |
하위 클래스(상속) |
다른 패키지 |
|
private |
O |
X |
X |
X |
|
(default) |
O |
O |
X |
X |
|
protected |
O |
O |
O |
X |
|
public |
O |
O |
O |
O |
* 접근 제어자 사용 대상
|
대상 |
사용 가능한 접근 제어자 |
|
클래스 |
(default), public |
|
필드, 메소드 |
private, (default), protected, public |
|
지역변수 |
아무것도 사용할 수 없다 |
* Car car01 = new Car();
래퍼런스 변수 인스턴스 생성(힙 영역)
* (인스턴스) 필드 초기화(힙 영역)
정수형-0, 실수형-0.0, 클래스형-null
new 연산자는 힙 영역에 메모리 할당하는 일과 더불어 할당된 메모리를 참조할 수 있는 주소값을 되돌려준다. new 연산의 결과값을 따로 저장해 두어야만 인스턴스를 참조할 수 있다.
객체를 참조하기 위해 new 연산의 결과 값을 저장하는 변수를 래퍼런스 변수라고 한다.
래퍼런스 변수 car01은 대입(=) 연산자 오른쪽의 new에 의해서 생성된 인스턴스의 주소를 넘겨받아 관리하므로 생성된 인스턴스에 접근할 수 있게 된다.
new에 의한 인스턴스 생성이란 필드 값들을 저장할 수 있는 별도의 공간을 힙 영역에 배정받는 것을 의미하며, 래퍼런스 변수는 생성된 인스턴스의 주소를 저장하기 위해 스택 영역에 메모리 할당을 한다.
클래스로 생성된 인스턴스는 프로그램을 작성하는 동안 인스턴스 자체가 직접 사용되기보다 인스턴스를 구성하는 멤버가 사용된다. 멤버를 사용하기 위해서는 닷(.) 연산자를 사용한다.
대입(=) 연산자의 오른쪽 문장인 new Car() 가 수행되어 인스턴스가 힙 영역에 할당된 후에 그 주소값을 래퍼런스 변수 car01에 저장한다. 그러면 이제 래퍼런스 변수 car01을 통해 Car 인스턴스에 접근할 수 있게 된다.
인스턴스를 다루기 위해서는 래퍼런스 변수가 반드시 필요하고, 래퍼런스 변수의 타입은 반드시 인스턴스 타입과 일치해야 한다. 또한 생성된 객체는 래퍼런스 변수로 접근하여 필드의 값을 바꿀 수도 있다.
* 하나의 자바 소스 파일에 클래스를 여러 개 정의할 수 있지만, public 클래스는 단 한 개만 존재해야 한다.
* this 래퍼런스
인스턴스 메소드 내부에 선언하지 않고 지역변수처럼 사용된다.
자기 자신만을 가리키는 래퍼런스로서 메소드 내부의 모든 인스턴스 필드와 메소드 앞에 암시적으로 사용된다.
필요에 따라 명시적으로 사용할 수 있다
* this가 암시적으로 사용된 예
int getSpeed() {return (this.)speed;}
* this에는 인스턴스 자신의 주소가 저장되어 있고 인스턴스 메소드 내부의 모든 필드 앞에 숨겨진 채 붙어서 자신의 필드에 접근할 수 있도록 한다.
* this 명시적 사용 예
① 매개변수의 이름이 필드와 다를 경우
void setSpeed(int sp) {speed = sp; // 필드에 매개변수 값을 저장}
② 매개변수의 이름이 필드와 같은 경우
void setSpeed(int speed) {speed = speed; //매개변수에 매개변수 값을 저장}
① 매개변수로 선언된 지역변수 sp의 값을 필드인 speed에 저장한다. 클래스 Car의 메소드인 setSpeed(0 내부에 speed란 이름의 변수가 선언되지 않았기 때문에 먼저 클래스 Car에 speed란 필드가 존재하는지를 살펴보고, 존재한다면 지역변수 sp의 값을 필드에 저장한다.
② 매개변수의 이름이 필드명과 동일하게 선언된 경우, 메소드 내부에 speed란 이름의 변수가 지역변수 형태(매개변수도 지역변수이다)로 선언되어 있는지 살펴보고, 존재한다면 메소드 내부에 선언된 speed 변수가 사용된다. 지역변수가 필드보다 우선순위가 높다.
그렇기 때문에 오른쪽의 setSpeed() 메소드를 호출해 봤자, 매개변수로 받은 값을 매개변수에 저장하기 때문에 외부에서 들어온 데이터로 필드 값을 변경할 수는 없는 것이다.
③ 매개변수의 이름이 필드와 같은 경우 this로 필드와 매개변수를 구분해야 한다.
void setSpeed(int speed) {this.speed = speed;}
this는 해당 인스턴스의 멤버임을 알리는 표시 방법으로 사용된다.
* getter/setter 자동으로 생성하기(이클립스)
클래스 Car를 생성한 후 speed와 direction을 private 필드로 선언한다.
그리고 클래스 Car 정의부 안에서 마우스 오른쪽 버튼을 클릭하여 [Source - Generate Getters and Setter]를 선택한다.
* 생성자
초기화는 변수가 메모리 할당을 진행하는 동시에 값을 설정하는 것이다.
변수의 초기화처럼 인스턴스 역시 초기화할 수 있다. 즉, 인스턴스를 생성할 때 값을 설정할 수 있는데, 그러려면 생성자라는 멤버가 필요하다. 생성자는 인스턴스를 생성할 때 자동으로 호출되어 인스턴스를 초기화한다. 생성자 내부에서는 주로 클래스를 구성하는 필드들의 초기화 작업을 하거나 인스턴스 생성시 실행되어야 할 작업을 하기 위해서 초기화가 사용된다.
생성자는 메소드의 일종이므로 클래스 내부에서 선언되며, 그 구조 역시 메소드와 유사하지만 리턴값이 없다. 그렇기 때문에 메소드 이름 앞에 붙였던 메소드의 리턴 타입을 적지 않는다.
생성자의 가장 큰 특징은 반드시 메소드의 이름이 클래스의 이름과 동일해야 한다는 점이다.
* 디폴트 생성자
자바 컴파일러가 제공해 주는 생성자. 매개변수도 없고 아무런 일도 하지 않는다.
class Car {public Car() {// 생성자를 명시적으로 만들지 않아도 자바 컴파일러가 자동으로 디폴트 생성자 제공}Car car01 = new Car(); // 디폴트 생성자가 호출됨.}
class CarA {private int speed;public CarA(int speed) {this.speed = speed;}}
프로그래머가 매개변수가 있는 생성자를 만들어 주면 더 이상 디폴트 생성자는 제공되지 않는다.
매개변수를 갖는 생성자를 호출하기 위해서는 인스턴스를 생성할 때 new 클래스이름 다음의 소괄호 안에 필드에 넘길 초기값을 기술해야 한다.
CarA car02 = new CarA(10);
클래스 Car에 매개변수를 갖는 생성자를 정의해 두면 인스턴스마다 서로 다른 초기값을 가질 수 있다.
CarA car03 = new CarA(); // 에러 발생
자바 컴파일러가 매개변수가 없는 형태의 디폴트 생성자를 더 이상 제공하지 않는데 인스턴스 생성자는 매개변수 없는 생성자를 호출하기 때문에 에러가 발생한다.
프로그래머는 매개변수를 갖는 생성자를 만들 때 매개변수 없는 생성자도 반드시 만들어 주어야 한다.
* this 생성자
this 다음에 ()를 붙여서 같은 클래스 내의 생성자가 다른 형태의 생성자를 호출할 때 사용하도록 한다.
생성자 내에서 this()로 생성자를 호출할 때에는 그 어떤 메소드보다도 제일 먼저 호출해 주어야 한다.
this()는 생성자에서만 사용할 수 있다.
class Car {
private int speed;
private int direction;
public Car(int speed, int direction) {
this.speed = speed;
this.direction = direction;
}
public Car(int speed) {
this(speed,30);
}
public Car() {
this(100,30);
}
public void prnCar() {
System.out.print("속도: " + speed + "\t");
System.out.print("방향: " + direction + "\n");
}
}
public class CarTest {
public static void main(String[] args) {
Car car01 = new Car(40,50);
car01.prnCar();
Car car02 = new Car(60);
car02.prnCar();
Car car03 = new Car();
car03.prnCar();
}
}
속도: 40 방향: 50
속도: 60 방향: 30
속도: 100 방향: 30
* static
자바 멤버: ①인스턴스 단위, ②클래스 단위
클래스 내부에 선언한 모든 필드와 메소드는 인스턴스 멤버이다.
인스턴스 필드들은 서로 다른 값을 가질 수 있도록 인스턴스를 생성할 때마다 매번 독립적인 저장 공간을 할당받는다.
클래스 필드는 클래스 내부의 필드를 선언할 때 static을 덧붙여서 만들 수 있는데, 클래스 변수는 클래스 단위당 단 하나의 저장 공간을 할당받고 이 공간을 여러 인스턴스들이 공유하게 된다.
클래스 필드는 인스턴스를 생성하지 않고도 클래스가 로딩될 때 클래스 이름으로 바로 참조해서 사용할 수 있다.
* 자바의 메모리 구조
|
클래스(메소드) 영역 |
static 변수(상수), static 메소드 저장 |
모든 프로그램에 의해 공유 |
|
힙 영역 |
new 연산자로 생성된 객체와 배열 저장 |
인스턴스 생성 시 자동초기화 됨 |
|
스택 영역 |
호출된 메소드의 지역변수, 매개변수, 리턴 값 및 연산시 일어나는 값들을 임시로 저장. 래퍼런스 변수 |
자동초기화 안됨.메소드 처리가 끝나면 메모리가 자동으로 회수됨 |
|
PC 래지스터 |
현재 수행할 명령어의 주소를 저장 |
쓰레드 시작 시 생성됨 |
|
Native 메소드 스택 |
자바 외의 다른 언어에서 제공되는 메소드의 매개변수,지역변수를 저장 |
|
클래스영역: 실행 중인 프로그램에서 어떤 클래스가 사용되면 JVM은 해당 클래스의 클래스파일(*.class)을 읽어서 분석하여 해당 클래스에 대한 정보를 클래스 영역에 저장한다. 모든 프로그램에 의해 공유된다.
힙영역: 인스턴스 내의 인스턴스 필드가 저장되는 공간으로, 인스턴스 필드는 프로그램 실행 중 new를 이용해서 인스턴스가 생성될 때 메모리 할당을 한다.
힙 영역은 자바에서 인스턴스를 저장할 때 사용하는 메모리 공간으로서, 힙 영역의 메모리에 할당되는 필드는 클래스가 인스턴스화 되면서 자동 초기화되기 때문에 값을 지정하지 않아도 사용할 수 있다.
해당 인스턴스가 더 이상 사용되지 못할 경우에는 가비지 콜렉터에 의해서 수거된다.
스택영역: 메소드가 호출되어 수행될 때 메소드 내에 선언된 지역변수를 저장하기 위한 저장공간이다.
메소드가 갖는 매개변수 역시 지역변수이기에 이곳에서 메모리 할당을 한다.
이들은 메소드가 호출되어 수행될 때만 필요하므로 메소드 호출과 함께 이들을 저장하기 위한 메모리 공간(스택)이 할당되고, 메소드의 수행을 마치고 호출한 쪽으로 되돌아갈 때는 더 이상 필요하지 않으므로 할당되었던 스택을 다시 시스템에 반환한다.
void method() {
int localA;
int localB = localA; // 컴파일 에러
}
스택에 할당되는 지역변수는 자동 초기화되지 않기 때문에 값을 지정하지 않고 사용하면 컴파일 에러가 발생한다.
* 클래스 필드를 갖는 클래스
클래스로 인스턴스를 생성하면 인스턴스의 개수만큼 인스턴스 필드가 생성된다.
하지만 모든 인스턴스들이 하나의 필드를 공유할 필요성이 생긴다면 static 예약어를 사용하여 필드를 선언한다.
class StaticTest
{
static int a; // 클래스 필드
int b; // 인스턴스 필드
}
인스턴스 필드는 모든 객체들이 개별적으로 힙 영역에 메모리를 할당받게 된다. static으로 선언한 필드는 힙 영역이 아닌 클래스 영역에 기억 공간이 할당되며, 클래스 영역에 할당된 클래스 필드는 몇 개의 인스턴스를 생성하던지 상관없이 프로그램이 끝날 동안 클래스 단위당 한 번만 메모리 할당을 한다.
클래스 필드는 인스턴스 생성 없이도 클래스 이름으로 필드에 접근할 수 있다.
StaticTest.a;
* 클래스 메소드(static이 붙은 메소드)
클래스 필드나 지역변수만 사용할 수 있다.
this를 사용할 수 없다.
인스턴스 필드를 사용할 수 없다.
public class StaticTest {
static int a;
int b;
StaticTest(int b)
{
a+=b;
this.b+=b;
}
static void prn() {
System.out.print("StaticTest.a :" + a);
}
public static void main(String[] args) {
StaticTest.prn();
}
}
this는 인스턴스가 생성될 때 자신을 참조하기 위해서 생성되는 래퍼런스이다.
this는 인스턴스 메소드 내에서 사용되는 인스턴스 필드가 어떤 인스턴스의 필드인지를 구분하기 위해서 사용된다. 클래스 메소드는 모든 인스턴스에서 공유하는 메소드이기에 인스턴스를 구별할 필요가 없다.
그러므로 this를 사용할 수 없으며, 인스턴스 필드 역시 사용하지 못한다.
* 메소드 오버라이딩과 super 래퍼런스
슈퍼 클래스의 메소드가 protected라면 서브 클래스는 protected나 public 이어야 한다.
static, final, private 메소드는 오버라이딩할 수 없다.
슈퍼 클래스의 메소드가 서브 클래스에서 오버라이딩되었다면 super 래퍼런스를 사용하여 슈퍼 클래스의 메소드를 호출할 수 있다.
super는 슈퍼 클래스를 가리키는 래퍼런스로 클래스가 인스턴스될 때 기본적으로 제공되는 것으로서 메소드 내부에서 사용 가능하다.
class Car {
String model;
String color;
public void prn() {
System.out.print("모델명 : " + model + "\n");
System.out.print("색상 : " + color + "\n");
}
}
class Taxi extends Car {
Boolean taxiMeter;
int taxiFare = 2000;
public void prn() {
super.prn(); //메소드 오버라이딩으로 은닉되어버린 슈퍼 클래스 Car의 메소드 호출
if(taxiMeter == true)
System.out.print("요금 : " + taxiFare + "\n");
else
System.out.print("미터기가 꺼져 있습니다.");
}
}
public class TaxiTest {
public static void main(String[] args) {
Taxi ta = new Taxi();
ta.model = "소나타";
ta.color = "레드";
ta.taxiMeter = true;
ta.prn(); // 오버라이딩한 서브 클래스의 메소드 호출
}
}
모델명 : 소나타
색상 : 레드
요금 : 2000
* super() 생성자
this()는 같은 클래스 내의 다른 생성자를 호출하기 위해 사용되고,
super()는 슈퍼 클래스의 생성자를 호출하는데 사용한다.
서브 클래스의 인스턴스가 생성될 때 슈퍼 클래스 내의 필드들에 대한 초기화 작업이 수행되어야만 이들을 제대로 사용할 수 있다.
때문에 서브 클래스의 생성자에서는 슈퍼 클래스의 생성자가 자동으로 먼저 호출되어 실행되어야 하므로 Object 클래스를 제외한 모든 클래스의 생성자에는 super();를 자동적으로 추가한다.
class Car {
String model;
String color;
public Car(String model, String color) {
// super();
this.model = model;
this.color = color;
System.out.println("Car 클래스의 매개변수 있는 생성자");
}
public Car() {
// super();
System.out.println("Car 클래스의 매개변수 없는 생성자");
}
}
class Taxi extends Car {
Boolean taxiMeter;
int taxiFare = 3000;
public Taxi(String model, String color, Boolean taxiMeter, int taxiFare) {
super(model, color);
this.taxiMeter = taxiMeter;
this.taxiFare = taxiFare;
System.out.println("Taxi 클래스의 매개변수 4개 있는 생성자");
}
public Taxi(Boolean taxiMeter, int taxiFare) {
// super();
this.taxiMeter = taxiMeter;
this.taxiFare = taxiFare;
System.out.println("Taxi 클래스의 매개변수 2개 있는 생성자");
}
public Taxi() {
// super();
System.out.println("Taxi 클래스의 매개변수 없는 생성자");
}
}
public class TaxiTest {
public static void main(String[] args) {
Taxi t1 = new Taxi();
}
}
* final 변경자
|
대상 |
설명 |
|
필드 |
값을 변경할 수 없는 상수로 사용 |
|
메소드 |
오버라이딩 금지 |
|
클래스 |
상속 불가능. 다른 클래스의 슈퍼 클래스가 될 수 없다. |
* 추상 클래스(abstract)
추상 클래스는 인스턴스는 생성하지 못하지만, 래퍼런스 변수는 선언할 수 있다.
추상 클래스로 선언된 래퍼런스 변수는 자신의 서브 클래스로 선언된 인스턴스들을 가리킬 수 있다.
abstract class Shape {
protected double area;
public double getArea() {
return area;
}
abstract public void calcuArea(); // 도형의 면적을 구하기 위한 추상 메소드
}
class Circle extends Shape {
protected int radius;
public Circle(int radius) {
this.radius = radius;
}
public Circle() {
}
public void calcuArea() { // 메소드 오버라이딩
area = readius * radius * Math.PI;
}
}
class Rectangle extends Shape {
protected int width;
protected int height;
public Rectangle(int width, int height) {
this.width = width;
this.height = height;
}
public Rectangle() {
}
public void calcuArea() { // 메소드 오버라이딩
area = width * height;
}
}
public class AbstractTest {
public static void main(String[] args) {
Shape[] sa = new Shape[2];
sa[0] = new Circle(5);
sa[1] = new Rectangle(4,8);
for(int I=0; i<sa.length; I++) {
sa[i].calcuArea();
System.out.println(“도형의 넓이 :” + sa[i].getArea());
}
}
}
* 인터페이스(interface)
상수 또는 추상 메소드들만 포함.
- public static final 상수
- public abstract 메소드
인스턴스를 생성할 수는 없지만, 래퍼런스 변수는 선언이 가능하다.
|
추상 클래스 |
인터페이스 |
|
클래스(abstract class) |
클래스가 아님(interface) |
|
일반 메소드와 추상 메소드를 모두 가짐 |
추상 메소드만 가짐(public abstract) |
|
단일상속(extends) |
다중상속(implements) |
|
변수와 상수 모두 가짐 |
상수만 가짐(public static final) |
* 내부 무명 클래스
메소드( new 상위/슈퍼 클래스 이름(생성자의 매개변수){ })
* Object 클래스의 주요 메소드
|
Class getClass() |
객체의 클래스 이름을 class 형으로 반환 |
|
Object clone() |
객체를 복사 |
|
boolean equals(Object ob) |
두 객체의 내용이 동일한지 알아볼 때 사용 |
|
int hashCode() |
객체를 유일하게 식별하는 정수값을 리턴 |
|
String toString() |
객체의 정보를 문자열로 반환 |
* equals() 메소드
String str1 = "java";
String str2 = "java";
String str3 = new String("java")
str1 == str2 : true
str1.equals(str2) : true
str1 == str3 : false
str1.equals(str3) : true
-> == 두 래퍼런스 변수가 같은 인스턴스를 가리키는지 물어봄
equals 내용(hashcode)을 비교
-> str1: 문자열 상수는 컴파일하면 자동으로 힙 영역에 String 객체가 생성된다
str2: 이미 존재하는 문자열 상수로 다시 사용한다면 이미 생성된 문자열 상수를 공유하게 된다.
str3: new로 String 객체를 생성하면 별도의 기억공간(힙 영역)이 할당된다.
* 예외 처리
java.lang.object - java.lang.Throwable - java.lang.Exception - java.lang.RuntimeException
- java.lang.Error
1. Error 클래스
- 복구가 어렵거나 불가능한 예외 상황으로 일반적으로 오류메시지를 출력하고 실행이 중단된다
- OutOfMemoryError, StackOverflowError, LinkageError
2. Exception 클래스
- 예외처리를 반드시 하여야 한다
- ClassNotFoundException, IOException, InterruptedException
3. RuntimeException
- 실행중에 발생할 수 있는 예외클래스로 예외 처리를 하지 않아도 무방하다
- IllegalArgumentException, IndexOutOfBoundException, NullPointerEXception
* collection
|
인터페이스 |
특 징 |
|
List |
순서가 있는 데이터의 집합. 데이터의 중복 허용 예) 대기자 명단 구현 클래스: ArrayList, LinkedList, Vector, Stack |
|
Set |
순서를 유지하지 않는 데이터의 집합. 데이터의 중복을 허용 않음 예) 양의 정수집합, 소수의 집합 구현 클래스 : HashSet, TreeSet |
|
Queue |
JDK 5.0부터 추가 구현 클래스: LinkedList |
|
Map |
키(key)와 값(value)의 쌍(pair)으로 이루어진 데이터의 집합. 순서는 유지 되지 않으며, 키는 중복을 허용하지 않고, 값은 중복을 허용 입력된 순서와 상관없이 값이 출력 구현 클래스 : HashMap, Hashtable, TreeMap, Properties |
※ 동기화 보장: Vector, Hashtable
hashSet - String형의 데이터만 저장
* Vector
java 5.0 이후 AutoBoxing 지원
Vector v = new Vector()
v.addElement(new Integer(100)); -> v.addElement(100);
* ArrayList
ArrayList 객체를 선언할 때 매개 변수를 넣지 않으면 기본 초기 크기는 10이다.
따라서 10개 이상의 데이터가 들어가면 크기를 늘이는 작업이 ArrayList 내부에서 자동으로 수행된다.
배열.length는 배열의 저장 공간 개수를 의미하지만, ArrayList.size() 메소드의 결과는 ArrayList의 저장 공간 개수를 말하는 것이 아니다. 들어가 있는 데이터 개수를 의미한다.
ArrayList 객체에 있는 데이터들을 배열로 뽑아낼 때에는 toArray() 메소드를 사용한다.
|
리턴 타입 |
메소드 이름 및 매개 변수 |
설명 |
|
Object[] |
toArray() |
ArrayList 객체에 있는 값들을 Object[] 타입의 배열로 만든다. |
|
<T> T[] |
toArray(T[] a) |
ArrayList 객체에 있는 값들을 매개 변수로 넘어온 T 타입의 배열로 만든다. |
* 확장 for 문
확장 for 문은 배열이나 컬렉션과 같이 여러 개체가 모여 있는 경우에 개체의 끝을 체크하지 않고도 하나씩 차례대로 접근할 수 있도록 한다.
for (①자료형 ②접근 변수명 : ③배열이나 컬렉션 변수명) {
반복코드
}
②접근 변수의 ①자료형은 ③배열이나 컬렉션 변수의 자료형과 동일해야 한다.
import java.util.Iterator;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
String[] arr = {"진달래","백합","해바라기","개나리","장미"};
Vector<String> ve = new Vector<String>(4,3);
System.out.println("vector size :" + ve.size());
System.out.println("vertor capacity :" + ve.capacity() + "\n");
for(int i=0; i<arr.length i++) ve.add(arr[i]);
for(String item : ve) System.out.print(item + "\t");
System.out.println("\n");
System.out.println("ve.size() :" + ve.size());
System.out.println("ve.capacity() :" + ve.capacity());
Iterator<String> it = ve.iterator(); // 인터페이스 이기 때문에 객체 생성 불가능
while(it.hasNext()) System.out.print(it.next() + "\t");
System.out.println("\n");
Enumeration<String> en = ve.elements();
while(en.hasMoreElements())System.out.print(en.nextElement() + "\t");
}
}
* Map 인터페이스의 메서드
|
메소드 |
설 명 |
|
Object put(Object key, Object value) |
value 객체를 key 객체에 연결하여 저장 |
|
Object get(Object key) |
지정한 key 객체에 대응하는 value 객체를 찾아서 반환 |
|
Object remove(Object key) |
지정한 key 객체와 일치하는 key-value 객체를 삭제 |
|
void clear() |
모든 객체를 삭제 |
|
boolean containsKey(Object key) boolean containsValue(Object value) |
지정된 key 객체와 일치하는 key 객체가 있는지 확인 지정된 value 객체와 일치하는 value 객체가 있는지 확인 |
|
Set entrySet() |
저장되어 있는 key-value 쌍을 (Map.Entry 타입의 객체로 저장한) Set으로 반환 |
|
Set keySet() |
저장된 모든 key 객체를 반환 키는 중복을 허용하지 않기 때문에 Set 타입으로 반환 |
|
Collection values() |
저장된 모든 value 객체를 반환 값은 중복을 허용하기 때문에 Collection 타입으로 반환 |
|
int size() |
저장된 key-value 쌍의 개수를 반환 |
|
boolean isEmpty() |
비어있는지 확인 |
|
void putAll(Map t) |
지정된 Map의 모든 key-value 쌍을 추가 |
* Map과 Hashtable 비교
|
기능 |
HashMap |
Hashtable |
|
|
컬렉션 뷰를 사용 |
Enumeration 객체를 통해서 데이터 처리 |
|
|
키, 값, 키-값 쌍으로 데이터를 순환하여 처리 |
키-값 쌍으로 데이터를 순환하여 처리할 수 없음 |
|
|
Iteration을 처리하는 도중에 데이터를 삭제하는 안전한 방법을 제공 |
제공하지 않음 |
|
키나 값에 null 저장 가능 여부 |
가능 |
불가능 |
|
여러 쓰레드에서 동시 접근 가능 여부 |
불가능 |
가능 |
* HashMap 객체에 값 넣기
public void checkHashMap() {
HashMap<String, String> map = new HashMap<String, String>();
map.put("A", "a");
System.out.println(map.get("A"));
System.out.println(map.get("B"));
}
a
null
Collection에서 get() 메소드를 사용할 때 해당 위치에 값이 없을 때에는 ArrayIndexOutOfBoundsException 이라는 예외가 발행한다.
Map에서는 없는 키로 get()을 할 경우에 null을 리턴한다.
HashMap 객체에 put()메소드를 사용하여 이미 존재하는 키로 값을 넣을 때에는 기존의 값을 새로운 값으로 대치한다.
* 문자열을 여러 개의 String 배열로 나누는 split 메소드
String[] split(String regex)
String[] split(String regex, int limit)
- 정규 표현식을 사용하여 문자열을 나누는 경우: java.lang.String 클래스의 split() 메소드 사용
- 특정 String으로 문자열을 나누는 경우: java.util.StringTokenizer 클래스 사용
- 특정 알파뱃이나 기호 하나로 문자열을 나누는 경우: 둘 다 사용
* 문자열 더하기
String text = "Hello";
text = text+ " world";
String 문자열을 더하면 새로운 String 객체가 생성되고, 기존 객체는 버려진다.
계속 하나의 String을 만들어 계속 더하는 작업을 한다면, 계속 쓰레기를 만들게 된다.
"Hello"라는 단어를 갖고 있는 객체는 더 이상 사용할 수 없다.
즉, 쓰레기가 되며 나중에 GC(가비지 컬렉션)의 대상이 된다.
StringBuffer, StringBuilder: 두 클래스에서 제공하는 메소드는 동일하다.
이 두 클래스는 문자열을 더하더라도 새로운 객체를 생성하지 않는다.
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" world");
// sb.append("Hello").append(" world"); // append() 메소드를 수행한 후에 해당 StringBuilder 객체가 리턴되므로 계속 append() 메소드를 붙여도 상관없다.
append() 메소드는 매개 변수로 모든 기본 자료형과 참조 자료형을 모두 포함한다.
- StringBuffer(쓰레드 동기화 지원), StringBuilder(속도 빠름)
공통점: 모두 문자열을 다룬다. Serializable, CharSequence 인터페이스를 구현한다.
jdk 5.0 이상: String 더하기 연산을 할 경우, 컴파일할 때 자동으로 해당 연산을 StringBuilder로 변환해 준다.
어떤 클래스에 문자열을 생성하여 더하기 위한 문자열을 처리하기 위한 인스턴스 변수가 선언되었고, 여러 쓰레드에서 이 변수를 동시에 접근하는 일이 있을 경우에는 반드시 StringBuffer를 사용해야 한다.
* Math 클래스
|
메소드 이름 |
용도 |
매개변수 타입 |
리턴 타입 |
|
round() |
반올림 |
float |
int |
|
double |
long |
||
|
rint() |
반올림 |
double |
double |
|
ceil() |
올림 |
double |
double |
|
floor() |
버림 |
double |
double |
'와사비크래커 IT Tip > 언어' 카테고리의 다른 글
| [JAVA] 조건문과 반복문 (0) | 2020.08.31 |
|---|---|
| [JAVA] 연산자 (0) | 2020.08.31 |
| [JAVA] 변수 (0) | 2020.08.27 |
| [JAVA] JAVA의 소개 (0) | 2020.08.27 |
| Java란 (0) | 2020.07.28 |
