힘내보자

Math.random을 이용하여 난수를 생성하여 

임시 저장 공간인 변수 tmp에 넣고

이 tmp변수를 배열의 인덱스번호에 넣고 해당 인덱스번호의 가위바위보 중 하나를 선택하게 된다

       // 가위바위보 하기
        // index : 0~3-1 = 0~2
        String[] strArr = {"가위","바위","보"};
        System.out.println(Arrays.toString(strArr));

        for(int i=0; i<5; i++){
            int tmp = (int)(Math.random()*3);
            System.out.println(strArr[tmp]); // 0~2
        }


        System.out.println("매개변수의 개수 : "+args.length);
        for(int i=0; i < args.length; i++){
            System.out.println("args["+i+"] = \""+args[i]+"\"");
        }

백준 단계별 문제 풀이

1단계 5,6번

스캐너 + 연산

소수점 계산이라 double 사용

 double로 안하고 float로하면 소수점 아래 계산에서 오차가 생겨서 문제가 오답처리됨

// Step1-5 10998번 A*B
    public void method03(){
        // import java.util.*;
        int a = 0;
        int b = 0;

        Scanner sc = new Scanner(System.in);
        a = sc.nextInt();
        b = sc.nextInt();

        System.out.println(a*b);

    }

    // Step1-6 1008번 A/B
    public void method04(){
//        import java.util.*;

        double a = 0;
        double b = 0;

        Scanner sc = new Scanner(System.in);

        a = sc.nextDouble();
        b = sc.nextDouble();

        System.out.printf("%.10f",a/b);
//        System.out.printf("%.9f",a/b); 이것도 .11f도 정답. 8이하로는 오답.
        // double로 안하고 float로하면 소수점 아래 계산에서 오차가 생겨서 문제가 오답처리됨


//        float aa = 0.11111f;
//
//        System.out.printf("%.2f",aa);

    }

백준 단계별 풀이

3,4번

사용언어 : 자바

스캐너 사용

    // Step1-3 A+B
    public void method01(){

        int a=0;
        int b=0;
        Scanner sc = new Scanner(System.in);
        a=sc.nextInt();
        b=sc.nextInt();
        System.out.println(a+b);
    }

    // Step1-4 1001번 A-B
    public void method02(){
        // import java.util.*;
        int a = 0;
        int b = 0;

        Scanner sc = new Scanner(System.in);
        a = sc.nextInt();
        b = sc.nextInt();

        System.out.println(a-b);

    }

다른 사람들은 평범하게 인텔리제이 잘 사용하는데

내가 문제인지 노트북이 문제인건지 뭔가 자꾸 엄청 irregular한 문제들이 발생하는데

4-5년차분들도 갸우뚱하시고

상황은 일단 아래처럼 본래의 Run파일이 있는데, 런했을 때

빌드한 파일들이 바로 아래 생성되고 있는 상태이다(빨간폴더)

알아보니 저  빨간 폴더들은 .java파일을 자바 컴파일러(javac)가 컴파일하고 나서 .class파일(java Byte Code)를 만드는데 바로 이 자바 바이트코드 파일들이라는 것이다. 갑자기 왜 저기에 생성되는지 의문인데

일단 상황은 본래 이클립스에서 만들었던 프로젝트 파일을 인텔리제이에서 읽을 수 없어서 이클립스 키고 보면서 인텔리제이로 코드 작성하는 중이었는데 이클립스에 코드만 긁어서 인텔리제이에서 새로 파일 생성하고 코드를 붙여넣었는데 이 과정에서 이름이 같아서 이름도 변경시키고 했는데 빨간줄 뜨면서 

원래  풀네임에서

com.prac01.collection.set.model.vo.Dog;

원아래처럼 src.main.java.를 새로 붙이라고 추천이 떠서 바꾸니까 에러도 사라지고 했는데 이때부터 꼬인 걸 느끼기 시작

import src.main.java.com.prac01.collection.set.model.vo.Dog;

코드만 살리고 폴더까지 다지워서 새로 만들고 난 후 제대로 작동하는데

만들어진 구조를 살펴보았다

자바 바이트 코드가 src랑 동레벨의 폴더에 생성되었고, 폴더 생성된 레벨도 풀네임에 따라 하나씩 생성된 것을 확인 할 수 있었다. 아까는 뭐 때문에 꼬인걸까

오버라이딩으로 Object의 equals()를 재정의한 vo class의 equals() 와 hashCode()가 있어야 set이 중복저장 안됨

만들어 놓은 위의 두 메소드를 주석처리하면 중복저장이 가능해짐

HashSet<Dog> hSet = new HashSet<Dog>();
hSet.add(new Dog("풍이",10));
hSet.add(new Dog("해피",10));
hSet.add(new Dog("해피",10));
System.out.println(hSet); // [풍이(10.0kg), 해피(10.0kg)]
// equals(),hashCode() 주석처리 하면, 중복 저장o
System.out.println(hSet); // [해피(10.0kg), 해피(10.0kg), 풍이(10.0kg)]

변수에 넣어서 재사용성 늘리기

int num = hSet.size();
System.out.println(num); // 1

해당 메소드마다 ctrl+click으로 내부 로직이 뭘로 구성되어있는지 체크해보자 HashSet 같은 경우 HashMap으로 구성되어있는 걸 알 수 있었다 equals() 같은 경우에는 object 비교 후 instanceof로 Set인지 비교하기도 했음

// HashSet
HashSet<Dog> hSet = new HashSet<Dog>();
hSet.add(new Dog("풍이",10));
hSet.add(new Dog("해피",10));
hSet.add(new Dog("해피",10));
System.out.println(hSet); // [풍이(10.0kg), 해피(10.0kg)]
// equals(),hashCode() 주석처리 하면, 중복 저장o
System.out.println(hSet); // [해피(10.0kg), 해피(10.0kg), 풍이(10.0kg)]


System.out.println(hSet.contains(new Dog("풍이",10))); // true
// contains는 equals(), hashCode() 둘 다 필요

boolean isTrue = false; // flag variable 플래그 변수
isTrue = hSet.contains(new Dog("해피",10));
System.out.println(isTrue); // false

hSet.remove(new Dog("해피",10));
System.out.println(hSet); // [풍이(10.0kg)]
System.out.println(hSet.size()); // 1
// 변수에 넣어서 재사용성 늘리기
int num = hSet.size();
System.out.println(num); // 1
isTrue=hSet.equals(new Dog("해피",10));
System.out.println(isTrue); // false
isTrue = hSet.equals(new Dog("풍이",10));
System.out.println(isTrue); // false

System.out.println(hSet.equals(new Dog("풍이",10)));
// 순서x 중복x HashSet, add하면 어디에 추가될까?
// 맨 앞에 추가됨

// set 중복 저장안되는데 중복 저장 되는 이유 : equals() 오버라이딩 안되어있어서
HashSet<String> hSetStr = new HashSet<>();
hSetStr.add("리트리버");
hSetStr.add("리트리버");
hSetStr.add("진돗개");

System.out.println(hSetStr);    // [리트리버, 진돗개]
System.out.println(hSetStr.equals("강하게")); // false
System.out.println(hSetStr); // [리트리버, 진돗개]
System.out.println(hSetStr.equals("강하게")); // false

// 해당 메소드마다 ctrl+click으로 내부 로직이 뭘로 구성되어있는지 체크해보자
// HashSet 같은 경우 HashMap으로 구성되어있는 걸 알 수 있었다
// equals() 같은 경우에는 object 비교 후 instanceof로 Set인지 비교하기도 했음

코딩이 손발처럼 익숙해지기!

익숙 -> 응용 -> 실력up

객체배열 길이 지정은 대괄호 []

객체배열 안에 객체에 값을 넣는거는 소괄호 ()

객체배열타입(클래스)[] 변수명 = new 객체배열클래스명[배열길이];

c언어 형식으로 변수명 뒤에 [] 배열 표시를 붙여줘도 된다

자바에서는 데이터타입 뒤에 붙이는 방법을 선호함

객체배열타입(클래스) 변수명[] = new 객체배열클래스명[배열길이];

// 객체배열
//
// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
	Person[] objArr040;
	
// 배열 할당 : heap 영역에 공간 생성
	Person[] objArr041 = new Person[2];
	Person[] objArr042 = new Person[2];
	
// 배열 초기화 : 인덱스,중괄호,for문
//	방법1 : 인덱스
	objArr041[0] = new Person("a",22,'m',11,111);
	objArr041[1] = new Person("b",22,'m',11,111);
	System.out.println(objArr041); // [Lchap06_objectArray.model.vo.Person;@4aa298b7
	System.out.println(objArr041[0].personInfo()); // a, 22, m, 11.0, 111.0
	System.out.println(objArr041[1].personInfo()); // b, 22, m, 11.0, 111.0
	
//	방법2 : 중괄호
// 	선언과 동시에 초기화
	Person[] objArr043 = {new Person("c",22,'m',11,111),
						  new Person("d",22,'m',11,111)
						};
	System.out.println(objArr043[0].personInfo()); // c, 22, m, 11.0, 111.0
	System.out.println(objArr043[1].personInfo()); // d, 22, m, 11.0, 111.0
	
	
//	방법3 : for문
	for(int i=0; i < objArr042.length; i++) {
		objArr042[i] = new Person("e",30+i,'M',100,100+i);
		System.out.println(objArr042[i].personInfo());
		// e, 30, M, 100.0, 100.0
		// e, 31, M, 100.0, 101.0
	}
	
	
// 배열 삭제 : null
// 배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드
	objArr042 = null;
	System.out.println(objArr042); // null
		
	Person[] test000 = new Person[3];
	for(int i=0; i < test000.length; i++) {
		test000[i] = new Person("ㄱ",20-i,'ㅡ',100,100-i);
		System.out.println(test000[i].personInfo());
//		ㄱ, 20, ㅡ, 100.0, 100.0
//		ㄱ, 19, ㅡ, 100.0, 99.0
//		ㄱ, 18, ㅡ, 100.0, 98.0
	}

 MERGE INTO 코드

https://gent.tistory.com/406

일단 대강 명령어들 위치는 이해됬는데 구체적으로 안에서 어떻게 작동하는지는 

이번 한번으로는 이해가 안되서 또 봐야할 것 같다

ALTER로 DEFAULT값을 지정해줬어도 해당 컬럼값에 NULL을 넣는다고 하면 
DEFAULT가 안들어가고 NULL값이 그대로 들어가며, 

(CO1)처럼 값 하나만 지정하고 다른 컬럼값을 지정안하면 이때 DEFAULT값이 들어간다

--------------------------------------------------------------------
---------------------- SQLD 30회 기출  42번 -------------------------

-- MERGE INTO 코드
CREATE TABLE SQLD_30_42_01(
COL1   VARCHAR2(10),
COL2   VARCHAR2(10),
COL3   NUMBER
);

CREATE TABLE SQLD_30_42_02(
COL1   VARCHAR2(10),
COL2   VARCHAR2(10),
COL3   NUMBER
);

INSERT INTO SQLD_30_42_01 VALUES('A', 'X', 1);
INSERT INTO SQLD_30_42_01 VALUES('B', 'Y', 2);
INSERT INTO SQLD_30_42_01 VALUES('C', 'Z', 3);
INSERT INTO SQLD_30_42_01 VALUES('X', 'T', 1);

SELECT * FROM SQLD_30_42_01;

INSERT INTO SQLD_30_42_02 VALUES('A', 'X', 1);
INSERT INTO SQLD_30_42_02 VALUES('B', 'Y', 2);
INSERT INTO SQLD_30_42_02 VALUES('C', 'Z', 3);
INSERT INTO SQLD_30_42_02 VALUES('D', '가', 4);
INSERT INTO SQLD_30_42_02 VALUES('E', '나', 5);

SELECT * FROM SQLD_30_42_02;

MERGE INTO SQLD_30_42_01 A
    USING SQLD_30_42_02 B
        ON(A.COL1 = B.COL1)
    WHEN MATCHED THEN 
        UPDATE SET A.COL3 = 4
            WHERE A.COL3 = 2
        DELETE WHERE A.COL3 <= 2
    WHEN NOT MATCHED THEN
        INSERT(A.COL1, A.COL2, A.COL3)
        VALUES(B.COL1, B.COL2, B.COL3);






--------------------------------------------------------------------
---------------------- SQLD 30회 기출  47번 -------------------------

/*
ALTER로 DEFAULT값을 지정해줬어도 해당 컬럼값에 NULL을 넣는다고 하면 
DEFAULT가 안들어가고 NULL값이 그대로 들어가며, 

(CO1)처럼 값 하나만 지정하고 다른 컬럼값을 지정안하면 이때 DEFAULT값이 들어간다

*/

CREATE TABLE SQLD_47(
COL1   VARCHAR2(30),
COL2   NUMBER
);

INSERT INTO SQLD_47(COL1, COL2) VALUES('BC',NULL); 
ALTER TABLE SQLD_47 MODIFY COL2 DEFAULT 10;
INSERT INTO SQLD_47(COL1, COL2) VALUES('XY',NULL); 
INSERT INTO SQLD_47(COL1) VALUES('EXD');
SELECT * FROM SQLD_47;
SELECT SUM(COL2) FROM SQLD_47;
SELECT * FROM SQLD_47;
rollback;

--------------------------------------------------------------------
-------------- SQLD 34회 기출  26번 -----------------------
DROP TABLE T1;
DROP TABLE T2;
DROP TABLE T3;
DROP TABLE T4;

CREATE TABLE T1(
COL1 NUMBER
);
CREATE TABLE T2(
COL1 NUMBER
);
CREATE TABLE T3(
COL1 NUMBER
);
CREATE TABLE T4(
COL1 NUMBER
);

INSERT INTO T1 VALUES(1);
INSERT INTO T1 VALUES(2);
INSERT INTO T1 VALUES(3);
INSERT INTO T1 VALUES(4);
SELECT * FROM T1;
INSERT INTO T2 VALUES(1);
INSERT INTO T2 VALUES(2);
INSERT INTO T2 VALUES(3);
INSERT INTO T2 VALUES(NULL);
SELECT * FROM T2;
INSERT INTO T3 VALUES(1);
INSERT INTO T3 VALUES(NULL);
INSERT INTO T3 VALUES(3);
INSERT INTO T3 VALUES(5);
SELECT * FROM T3;
INSERT INTO T4 VALUES(1);
INSERT INTO T4 VALUES(2);
INSERT INTO T4 VALUES(5);
INSERT INTO T4 VALUES(6);
SELECT * FROM T4;

SELECT *
FROM T1 ,T2, T3
WHERE T1.COL1 = T2.COL1(+)
AND T2.COL1 = T3.COL1(+);
SELECT COUNT(*)
FROM T1 ,T2, T3
WHERE T1.COL1 = T2.COL1(+)
AND T2.COL1 = T3.COL1(+);

SELECT *
FROM T2, T3
WHERE T2.COL1 = T3.COL1(+);

SELECT COUNT(*)
FROM T1 ,T2, T3, T4
WHERE T1.COL1 = T2.COL1(+)
AND T2.COL1 = T3.COL1(+)
AND T3.COL1 = T4.COL1;
SELECT *
FROM T1 ,T2, T3, T4
WHERE T1.COL1 = T2.COL1(+)
AND T2.COL1 = T3.COL1(+)
AND T3.COL1 = T4.COL1;

컬렉션이랑 하다보니 

대괄호 소괄호 중괄호 너무 헷갈리.... 또르르

 처음에는 객체명 쓰는 것도 순간 까먹어서 당황...ㄷㄷ

역시 반복반복... input again!!

/******************************** Object Array practice 6th ***************************************/	


// 객체배열
//
// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
// 배열 할당 : heap 영역에 공간 생성
// 배열 초기화 : 인덱스,중괄호,for문
// 배열 삭제 : null
// 배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드

	//배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
	Person02[] person00;
	//배열 할당 : heap 영역에 공간 생성
	Person02[] person01 = new Person02[2];
	Person02 person02[] = new Person02[2];

	//배열 초기화 : 인덱스,중괄호,for문
	//	방법1 : 인덱스
	person01[0] = new Person02("a",22,'M',70,171);
	person01[1] = new Person02("b",22,'M',70,171);
	System.out.println(person01[0].personInfo()); // a, 22, M, 70.0, 171.0
	
	//	방법2 : 중괄호
	Person02[] objArr030 = {new Person02("a",22,'M',69,181),
							new Person02("b",22,'M',69,181),
							new Person02("a",22,'M',69,181)
							};
	//	방법3 : for문
	for(int i=0; i < person02.length; i++) {
		person02[i] = new Person02("for",20+i,'M',170+i,70+i);
		// for, 20, M, 170.0, 70.0
		// for, 21, M, 171.0, 71.0
	}
	
	
	//배열 값 출력하는 방법 2가지 : for문 + vo클래스 toString메소드
	for(int i=0; i<person01.length; i++) {
		System.out.println(person01[i]); // chap06_objectArray.model.vo.Person02@232204a1
										// chap06_objectArray.model.vo.Person02@4aa298b7
		System.out.println(person01[i].personInfo()); // a, 22, M, 70.0, 171.0
													  // b, 22, M, 70.0, 171.0
	}
	
	//배열 삭제 : null
	person01 = null;
	System.out.println(person01); // null

Array

배열 출력 방법1 : for문 - 대괄호 없이 일반으로 출력됨

배열 출력 방법2: Arrays.toString() - 배열 형태로 반환 -> []

// 배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
// 방법1 for문
// 방법2 Arrays.toString
for(int i=0; i < fNum2.length; i++) {
	System.out.print(fNum2[i]+" "); // 1.0 1.5 1.8 
}
System.out.println(Arrays.toString(fNum2)); // [1.0, 1.5, 1.8]

/******************************practice 8th ************************************/		
		// 다음 연습 내용 char나 byte, long
		// long타입은 Arrays.toString()에 에러나면서 작동 안하는 것 발견
		
		
//배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
//배열 할당 : heap 영역에 공간 생성
//배열 초기화 : 인덱스,중괄호,for문
//배열 삭제 : null
//배열 값 출력하는 방법 2가지 : for문, Arrays.toString()

//
//		배열 크기 변경 불가(삭제하고 새로 만들기에 주소값이 변경됨)
//		배열 안 값이 최대길이보다 짧으면 값만큼만 출력되서 나옴(여분공간에 다른값x)
//		dArr[3] = 3;	// 3.0으로 출력 -> 자동형변환(int to double) 
//		초기화 for문 방법은 int만 가능하나, 실수로 형변환 가능한 int면 for문 가능 -> int인 i가 실수로 변환 가능한 수이기에 
//		null인 배열값 확인 시, for문방법은 널포인트익셉션 쓰므로 Arrays.toString() 사용해야함

		
		

		// 배열 선언 : Stack 영역에 공간 생성(변수의 선언 : stack에 공간 차지)
		double[] dNum;
		float fNum[];
		
		// 배열 할당 : heap 영역에 공간 생성
		double[] dNum2 = new double[2];
		float fNum2[] = new float[3];
		
		
		// 배열 초기화 : 인덱스,중괄호,for문
		// 방법1 : 인덱스
		fNum2[0] = 1;
		fNum2[1] = 1.5f;
		fNum2[2] = (float)1.8; // 1.8 == 1.8d // 강제형변환
		System.out.println(fNum2);	// [F@14ae5a5
		System.out.println(Arrays.toString(fNum2)); // [1.0, 1.5, 1.8]
		
		
		// 방법2 : 중괄호
		// 선언과 동기에 초기화
		String[] sArr01 = {"a","b","c"};
		char[] cArr01 = {'a','b','c'};
		
		// 방법3 : for문
		for(int i=0; i < dNum2.length; i++) {
			dNum2[i] += i;
			System.out.println(dNum2[i]); // 0.0 1.0
		}
		
		// 배열 삭제 : null
		dNum2 = null;
		System.out.println(dNum2);					// null
		System.out.println(Arrays.toString(dNum2));	// null
		
		// 배열 값 출력하는 방법 2가지 : for문, Arrays.toString()
		// 방법1 for문
		// 방법2 Arrays.toString
		for(int i=0; i < fNum2.length; i++) {
			System.out.print(fNum2[i]+" "); // 1.0 1.5 1.8 
		}
		System.out.println(Arrays.toString(fNum2)); // [1.0, 1.5, 1.8]

addAll로 객체를 통째로 넣어서 같게 만들면, 얇은 복사(shallow copy)

ArrayList<Student> al2 = new ArrayList<>();
al2.addAll(al);

System.out.println(al.hashCode());	// 346539999 <- 주소값 같음
System.out.println(al2.hashCode()); // 346539999 <- shallow copy
// addAll로 객체를 통째로 넣어서 같게 만들면, shallow copy

ArrayList의 전체길이에서 마지막 값 빼오기 : .size() -1

ArrayList<String> alStr = new ArrayList<>();
System.out.println(alStr); // [추가1, 추가의 추가를 바꾸기]
System.out.println(alStr.get(alStr.size()-1)); // 추가의 추가를 바꾸기

		// add(E e):boolean
		// add(int index, E element) 
		// Object의 toString()를 오버라이딩 때문에 주소값이 아닌 객체값이 바로나옴
		ArrayList<Student> al = new ArrayList<>();
		al.add(new Student("a",100));
		al.add(new Student("b",100));
		System.out.println(al);
		
		al.add(0, new Student("0",0));
		al.add(1,new Student("delimeter",000));
		System.out.println(al); // [0(0점), delimeter(0점), a(100점), b(100점)]
		if(al.add(new Student("c",100))) {
			System.out.println(al+" : c 출력성공"); // [0(0점), delimeter(0점), a(100점), b(100점), c(100점)] : c 출력성공
		}
		

		// addAll(Collection<? extends E> c) : boolean
		// addAll(int index, Collection c) : boolean
		// .size() : 인덱스 길이 반환
		// toString() 오버라이딩 주석 후
		ArrayList<Student> al2 = new ArrayList<>();
		al2.addAll(al);
		System.out.println(al2); // [0(0점), delimeter(0점), a(100점), b(100점), c(100점)]
		System.out.println(al2.size()); // 5
		System.out.println(al.hashCode());	// 346539999 <- 주소값 같음
		System.out.println(al2.hashCode()); // 346539999 <- shallow copy
		// addAll로 객체를 통째로 넣어서 같게 만들면, shallow copy
		
		// 삭제
		// remove(int index):E
//		// remove()의 return은 삭제한 값을 돌려준다
		
		System.out.println(al.remove(4)); // c(100점)
		al.remove(0);
		System.out.println(al); // [delimeter(0점), a(100점), b(100점)]
		
		
		// remove(Object o):boolean
		// 같은 데이터라면 앞에 있는거부터 삭제
		// equals()가 오버라이딩이 안되어 있어서 값 비교가 아니라 주소값 비교라 삭제 못한 것.
		al.remove(al);
		System.out.println(al.hashCode());
		
		
		// 지네릭 추가 : <String> 
		// toString() 오버라이딩 삭제 -> 삭제해도 String Class자체에서 가능해서 값 출력이 됨
		// equals랑 hashCode가 잘 오버라이딩이 되어있기 때문에 삭제 가능
		ArrayList<String> alStr = new ArrayList<>();
		alStr.add("추가1");
		alStr.add("추가2");
		System.out.println(alStr); // [추가1, 추가2]
		
		
		// set(int index, E e) : 바꾸기 전 값 반환
		// 해당 인덱스 번호에 값  교체
		// equals(),hashCode() 필요x
		alStr.set(1, "추가의 추가");
		System.out.println(alStr); // [추가1, 추가의 추가]
		System.out.println(alStr.set(1, "추가의 추가를 바꾸기")); // 추가의 추가
		System.out.println(alStr); // [추가1, 추가의 추가를 바꾸기]
		
		
		//get(int index):E
		// 인덱스번호의 엘리먼트 값을 가져온다
		
		// ArrayList의 전체길이에서 마지막 값 빼오기
		System.out.println(alStr.get(alStr.size()-1)); // 추가의 추가를 바꾸기
		
		
		// contains(Object) : boolean
		// indexObject : int 
		System.out.println(al.contains(new Student("a",100))); // false
		// equals() on
		System.out.println(al.contains(new Student("a",100))); // true
		// equals() off
		System.out.println(alStr.contains("추가1")); // true
		// 		-> String class는 자동 오버라이딩이 되어 있어서 equals()가 필요없음
		
		System.out.println(al.indexOf(new Student("b",100))); // -1
		// equals() on
		System.out.println(al.indexOf(new Student("b",100))); // 2
		
		
		// clear():void
		al2.clear();
		System.out.println(al2); // []
		// isEmpty():boolean
		System.out.println(al2.isEmpty());  // true
		System.out.println(al.isEmpty());	// false

		
		
		
	}