## 5/3(수) 보강 => 5/2(화) 5-8시 512호

5/3(수) 부처님오신날 보강 => 5/2(화) 5-8시 512호에 합니다.

## Arrays stream

Arrays.asList(5,3,4,7,2).stream(); // 스트림 생성
Arrays.asList(5,3,4,7,2).stream().forEach(System.out::println);
Arrays.asList(5,3,4,7,2).stream().map(i-> i*i).forEach(System.out::println);
Arrays.asList(5,3,4,7,2).stream().filter(i-> i>3).forEach(System.out::println);
int sum = Arrays.asList(5,3,4,7,2).stream().reduce((i, j) -> i+j).get(); // ((((5+3)+4)+7)+2)
System.out.println(“sum=” + sum);
List<Integer> intList = Arrays.asList(5,3,4,7,2).stream().filter(i-> i>3).collect(Collectors.toList());
intList.forEach(System.out::println);
int result = Arrays.asList(5,3,4,7,2).stream().filter(i-> i>3).findFirst().orElse(null); // 3보다 큰 첫번째 요소 반환
System.out.println(“result=” + result);
Arrays.asList(5,3,4,7,2).stream().filter(i-> i>3).findAny().ifPresent(System.out::println); // 3보다 큰 요소 반환
boolean result2 = Arrays.asList(5,3,4,7,2).stream().allMatch(i-> i>0); // 모두다 0보다 큰지
System.out.println(“result2=” + result2);

## Lan4_2 Photo

// Object equals method override – equality (Java7 or higher)
@Override
public boolean equals(Object other)
{
if (other == this) return true;
if (other instanceof Photo) {
Photo that = (Photo)other;
return Objects.equals(this.fullPath, that.fullPath) &&
Objects.equals(this.extension, that.extension) &&
this.width == that.width &&
this.height == that.height;
}
return false;
}

// Object hashCode method override – identity (Java7 or higher)
@Override
public int hashCode()
{
return Objects.hash(this.fullPath, this.extension, this.width, this.height);
}

## == vs equal vs hashCode

public static void main(String[] args) {
///////////////////////////////////////////////////////////////////////

Person jason1 = new Person(“Jason”, 10);
System.out.println(“jason1 hashCode=” + jason1.hashCode());
Person jason2 = new Person(“Jason”, 10);
System.out.println(“jason2 hashCode=” + jason2.hashCode());
Person jason3 = jason1;
System.out.println(“jason3 hashCode=” + jason3.hashCode());
Person jason4 = new Person(“Jason”, 20);
System.out.println(“jason4 hashCode=” + jason4.hashCode());

if (jason1 == jason2)
System.out.println(“jason1 == jason2”);
else
System.out.println(“jason1 != jason2”); //동일한 reference를 가리키지 않으므로 jason1 != jason2
if (jason1 == jason3)
System.out.println(“jason1 == jason3”); // 동일한 reference이므로 jason1 == jason3
else
System.out.println(“jason1 != jason3”);
if (jason1.equals(jason4))
System.out.println(“jason1 == jason4”);
else
System.out.println(“jason1 != jason4”); //동일한 reference를 가리키지 않으므로 jason1 != jason4

if (jason1.equals(jason2))
System.out.println(“jason1 equals to jason2”); // 내용이 같으므로 jason1 equals to jason2
else
System.out.println(“jason1 is not equal to jason2”);
if (jason1.equals(jason3))
System.out.println(“jason1 equals to jason3”); // 내용이 같으므로 jason1 equals to jason3
else
System.out.println(“jason1 is not equal to jason3”);
if (jason1.equals(jason4))
System.out.println(“jason1 equals jason4”);
else
System.out.println(“jason1 is not equal to jason4”); // 내용이 다르므로 jason1 is not equal to jason4

///////////////////////////////////////////////////////////////////////

Student john1 = new Student(“John”, 10, 100);
Student john2 = new Student(“John”, 10, 100);
Student john3 = john1;
Student john4 = new Student(“John”, 20, 100);
if (john1.equals(john2))
System.out.println(“john1 equals to john2”); // 내용이 같으므로 john1 equals to john2
else
System.out.println(“john1 is not equal to john2”);

if (john1.equals(john3))
System.out.println(“john1 equals to john3”); // 내용이 같으므로 jogn1 equals to john3
else
System.out.println(“john1 is not equal to john3”);

if (john1.equals(john4))
System.out.println(“john1 equals to john4”);
else
System.out.println(“john1 is not equal to john4”); // 내용이 다르므로 john1 is not equal to john4

System.out.println(“HashSet~~~~~~~~~~~~~~~~~~~~~~”); // hashCode가 일치하면 동일한 것으로 간주
Set sList5 = new HashSet();
sList5.forEach((s) -> System.out.println(s));
System.out.println(“sList5 contains john1 Student(\”John\”, 10, 100): ” + sList5.contains(john1));
System.out.println(“sList5 contains john2 Student(\”John\”, 10, 100): ” + sList5.contains(john2));
System.out.println(“sList5 contains john3 Student(\”John\”, 10, 100): ” + sList5.contains(john3));
System.out.println(“sList5 contains john4 Student(\”John\”, 20, 100):: ” + sList5.contains(john4));
System.out.println(“sList5 contains Student(\”John\”, 20, 100): ” + sList5.contains(new Student(“John”, 20, 100)));
System.out.println(“sList5 contains Student(\”John\”, 20, 200): ” + sList5.contains(new Student(“John”, 20, 200)));

System.out.println(“HashTable~~~~~~~~~~~~~~~~~~~~~~”); // HashTable의 경우 key 값은 hashCode가 일치하면 동일한 것으로 간주하여 replace함
Hashtable<Student, Integer> sList6 = new Hashtable<Student, Integer>();
sList6.put(john1, 1);
sList6.put(john2, 2);
sList6.put(john3, 3);
sList6.put(john4, 4);
sList6.forEach((s, i) -> System.out.println(s + ” ” + i));
}

## Comparable & Comparator Interface

PersonStudentInterface

/////////////////////////////////

import java.util.*;

class Person implements Comparable<Person>
{
private static int count = 0; // static (class) variables

protected String name; // instance variables
protected int age; // instance variables

public Person()
{
//System.out.println(“Person Constructor”); // this(“”, 0); error: call to this must be first statemenht in constructor
this(“”, 0);
}

public Person(String name, int age)
{
count++;
this.name = name;
this.age = age;
}

public Person(Person other)
{
this(other.name, other.age);
}

public String getName()
{
return name;
}

public void setName(String name)
{
this.name = name;
}

public int getAge()
{
return age;
}

public void setAge(int age)
{
this.age = age;
}

@Override
public boolean equals(Object other) // Object.equals overriding
{
if (other instanceof Person) {
Person that = (Person) other;
return that.canEqual(this) && this.getName().equals(that.getName()) && this.getAge() == that.getAge();
}
return false;
}

@Override
public int hashCode() {
return (41 * getName().hashCode() + getAge());
}

public boolean canEqual(Object other) {
return (other instanceof Person);
}

@Override
public String toString() // Object.toString() overriding
{
return “Person Name: ” + name + ” Age: ” + age;
}

public void print() // instance methods
{
System.out.println(“Person Name: ” + name + ” Age: ” + age);
}

public void set(String name, int age)
{
this.name = name;
this.age = age;
}

public void set(Person other)
{
this.name = other.name;
this.age = other.age;
}

public Person clone()
{
Person p = new Person(this.name, this.age);
return p;
}

public static void printCount() // static (class) methods
{
System.out.println(“Person Count: ” + count);
}

public static int getCount() { return count; } // static (class) methods
public static void setCount(int value) { count = value; } // static (class) methods

public int compareTo(Person other)
{
String thisName = this.getName().toUpperCase();
String otherName = ((Person)other).getName().toUpperCase();

//ascending order
return thisName.compareTo(otherName);
//descending order
//return otherName.compareTo(thisName);
}

public static Comparator<Person> AgeComparator
= new Comparator<Person>() {

public int compare(Person p1, Person p2) {

int age1 = p1.getAge();
int age2 = p2.getAge();

//ascending order
return age1 – age2;

//descending order
//return age2 – age1;
}

};

}

///////////////////////////////////////////////////////////////////////////////////////

class Student extends Person
{
private static int count = 0; // static (class) variables
protected int id;

public Student()
{
id = 5208;
}

public Student(String name, int age, int id)
{
super(name, age);
this.id = id;
count++;
}

public int getID()
{
return id;
}

public void setID(int id)
{
this.id = id;
}

@Override
public boolean equals(Object other) // Object.equals overriding
{
if (other instanceof Student) {
Student that = (Student) other;
return that.canEqual(this) && this.getName().equals(that.getName()) && this.getAge() == that.getAge() && this.getID() == that.getID();
}
return false;
}

@Override
public int hashCode() {
return (41 * super.hashCode() + getID());
}

public boolean canEqual(Object other) {
return (other instanceof Student);
}

@Override
public String toString() // Object.toString() overriding
{
return “Student Name: ” + name + ” Age: ” + age + ” ID: ” + id;
}

public void superPrint()
{
super.print();
}

public void print() // Person class print() method overriding
{
System.out.println(“Student Name: ” + name + ” Age: ” + age + ” ID: ” + id);
}

public void set(String name, int age, int id)
{
super.set(name, age);
this.id = id;
}

public void set(String name, int age)
{
super.set(name, age);
}

public void set(Student other)
{
this.set(other.name, other.age, other.id);
}

public void set(Person other)
{
if (other instanceof Person)
super.set(other);
else
this.set((Student)other);
}

public Student clone()
{
Student s = new Student(this.name, this.age, this.id);
return s;
}

public static void printCount() // static (class) methods
{
System.out.println(“Student Count: ” + count);
}

public static int getCount() { return count; } // static (class) methods
public static void setCount(int value) { count = value; } // static (class) methods

public int compareTo(Student other)
{
String thisName = this.getName().toUpperCase();
String otherName = ((Student)other).getName().toUpperCase();

//ascending order
return thisName.compareTo(otherName);
//descending order
//return otherName.compareTo(thisName);
}

public static Comparator<Student> AgeComparator
= new Comparator<Student>() {
public int compare(Student p1, Student p2) {
int age1 = p1.getAge();
int age2 = p2.getAge();

//ascending order
return age1 – age2;

//descending order
//return age2 – age1;
}

};

public static Comparator<Student> IDComparator
= new Comparator<Student>() {
public int compare(Student p1, Student p2) {
int id1 = p1.getID();
int id2 = p2.getID();

//ascending order
return id1 – id2;

//descending order
//return id2 – id1;
}

};
}

class PersonStudentTest
{

public static void print(Object[] array) {
for(Object o : array) {
System.out.println(o);
}
}

public static void main(String[] args)
{

///////////////////////////////////////////////////////////////////////

Student[] sList = new Student[3];
sList[0] = new Student(“Kevin”, 0, 222);
sList[1] = new Student(“Jason”, 1, 333);
sList[2] = new Student(“John”, 2, 111);

System.out.println(“STUDENT SORT BY NAME (DEFAULT)!!!”);
Arrays.sort(sList);
print(sList);

System.out.println(“STUDENT SORT by AGE!!!”);
Arrays.sort(sList, Student.AgeComparator);
print(sList);

System.out.println(“STUDENT SORT by ID!!!”);
Arrays.sort(sList, Student.IDComparator);
print(sList);

///////////////////////////////////////////////////////////////////////
Student[] sList2 = new Student[3];
sList2[0] = new Student(“Kevin”, 0, 222);
sList2[1] = new Student(“Jason”, 1, 333);
sList2[2] = new Student(“John”, 2, 111);

System.out.println(“STUDENT SORT BY NAME (anonymous method)!!!”);
Arrays.sort(sList2, new Comparator<Student>() {
public int compare(Student s1, Student s2) {
return s1.getName().toUpperCase().compareTo(s2.getName().toUpperCase());
}
});
print(sList2);

System.out.println(“STUDENT SORT by AGE (anonymous method)!!!”);
Arrays.sort(sList2, new Comparator<Student>() {
public int compare(Student s1, Student s2) {
return s1.getAge() – s2.getAge();
}
});
print(sList2);

System.out.println(“STUDENT SORT by ID (anonymous method)!!!”);
Arrays.sort(sList2, new Comparator<Student>() {
public int compare(Student s1, Student s2) {
return s1.getID() – s2.getID();
}
});
print(sList2);

///////////////////////////////////////////////////////////////////////
Student[] sList3 = sList2;

System.out.println(“STUDENT SORT BY NAME (lambda)!!!”);
Arrays.sort(sList3, (Student ss1, Student ss2) ->
ss1.getName().compareTo(ss2.getName())
);
Arrays.stream(sList3).forEach((s) -> System.out.println(s));

System.out.println(“STUDENT SORT by AGE (lambda)!!!”);
Arrays.sort(sList3, (Student ss1, Student ss2) ->
Integer.compare(ss1.getAge(), ss2.getAge())
);
Arrays.stream(sList3).forEach((s) -> System.out.println(s));

System.out.println(“STUDENT SORT by ID (lambda)!!!”);
Arrays.sort(sList3, (Student ss1, Student ss2) ->
Integer.compare(ss1.getID(), ss2.getID())
);
Arrays.stream(sList3).forEach((s) -> System.out.println(s));

///////////////////////////////////////////////////////////////////////
List<Student> sList4 = new ArrayList<Student>();

System.out.println(“STUDENTLIST SORT BY NAME (lambda)!!!”);
sList4.sort((Student ss1, Student ss2) ->
ss1.getName().compareTo(ss2.getName())
);
sList4.forEach((s) -> System.out.println(s));

System.out.println(“STUDENTLIST SORT by AGE (lambda)!!!”);
sList4.sort((Student ss1, Student ss2) ->
ss1.getAge() – ss2.getAge()
);
sList4.forEach((s) -> System.out.println(s));

System.out.println(“STUDENTLIST SORT by ID (lambda)!!!”);
sList4.sort((Student ss1, Student ss2) ->
ss1.getID() – ss2.getID()
);
sList4.forEach((s) -> System.out.println(s));

}

}

## Person Array

Person[] pArray = new Person[5];

// 만약 Person 객체를 하나만 생성한 후 for문에서 공유해 사용할 경우
// 마지막으로 입력된 데이터로 모든 데이터값이 치환됨
Person p = new Person();
for (int i = 0; i < 5; i++) {
System.out.print(“\n\nEnter Person name : “);
Scanner input = new Scanner(System.in);
p.setName(input.nextLine()); // 입력정보
System.out.print(“\n\nEnter Person age [int] : “);
p.setAge(input.nextInt()); // 입력정보
p.Print();
pArray[i] = p; // 리스트에 들어간 모든 원소는 동일한 p
}

System.out.println(“pArray : ” + Arrays.toString(pArray));

Person[] pArray = new Person[5];
// 아래와 같이 for문 안에 Person p = new Person()와같이
// 새로운 객체를 생성해야 각자 다르게 입력된 정보가 들어가게 됨
for (int i = 0; i < 5; i++) {

Person p = new Person();

System.out.print(“\n\nEnter Person name : “);
Scanner input = new Scanner(System.in);
p.setName(input.nextLine()); // 입력정보
System.out.print(“\n\nEnter Person age [int] : “);
p.setAge(input.nextInt()); // 입력정보
p.Print();

pArray[i] = p; // 이때 p는 새로운 Person객체

}

System.out.println(“pArray2 : ” + Arrays.toString(pArray2));

## Array vs ArrayList

int[] integerArray = new int[3];

integerArray[0] = 1;

integerArray[1] = 2;

integerArray[2] = 3;

for (int i : integerArray) System.out.println(i);

for (int j=0; j<integerArray.length; j++) System.out.println(integerArray[ j ]);

int k = 0;

while (k < integerArray.length) System.out.println(integerArray[k++]);

ArrayList<Integer> integerList = new ArrayList<Integer>();

integerList.add(1); //cannot store primitive in ArrayList, instead autoboxing will convert int to Integer object

integerList.add(2); //cannot store primitive in ArrayList, instead autoboxing will convert int to Integer object

integerList.add(3); //cannot store primitive in ArrayList, instead autoboxing will convert int to Integer object

for (int m : integerList) System.out.println(m);

for (int n=0; n<integerList.size(); n++) System.out.println(integerList.get(n));

Iterator<Integer> itr = integerList.iterator();

while (itr.hasNext()) System.out.println(itr.next());