●HashSet
Set<String> set = new HashSet<>(); // 순서 없이 중복 불가
// List<String> list = new LinkedList<>();
// list.add("test");
// String itme = list.get(0);
set.add(new String("box"));
set.add("robot");
set.add(new String("box"));
set.add("toy");
System.out.println(set);
Iterator<String> itr = set.iterator();
while(itr.hasNext()){
String temp = itr.next();
System.out.println(temp);
}
System.out.println();
for(String temp : set){
System.out.println(temp);
}
}
}
Iterator 을 사용해도 for 구문을 사용해도 HashSet 이랑 똑같은 결과값을 얻을 수 있다.
● hashcode 메서드
package org.example;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
class Car{
private String color ;
private String model;
public Car(String color, String model) {
this.color = color;
this.model = model;
}
@Override
public String toString() {
return "Car{" +
"color='" + color + '\'' +
", model='" + model + '\'' +
'}';
}
@Override
public int hashCode() {
return Objects.hash(color,model);
}
@Override
public boolean equals(Object obj) {
return this.color.equals( ((Car)obj).color ) && this.model.equals( ((Car)obj).model );
}
}
public class Main2 {
public static void main(String[] args) {
Set<Car> set = new HashSet<>();
set.add(new Car("빨강","k3"));
set.add(new Car("하얀","k3"));
set.add(new Car("빨강","k3"));
System.out.println(set);
}
}
tostring 을 써서 string 값으로 나타난다.
hashset 을 써서 중복 제거를 한다.
boolean equals 를 사용해서 내용이 같은지 확인한다.
●TreeSet
package org.example;
import java.util.TreeSet;
public class Main3 {
public static void main(String[] args) {
TreeSet<Integer> treeSet1 = new TreeSet<>();
treeSet1.add(10);
treeSet1.add(20);
treeSet1.add(50); //자동으로 오름차순으로 된다.
treeSet1.add(5);
System.out.println(treeSet1);
TreeSet<String> treeSet2 = new TreeSet<>();
treeSet2.add("aa"); //자동으로 순서대로 된다.
treeSet2.add("bb");
treeSet2.add("cc");
treeSet2.add("dd");
System.out.println(treeSet2);
}
}
package org.example;
import java.util.Comparator;
import java.util.TreeSet;
class Person implements Comparable<Person> { // 제네릭을 사용하게 되면
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// @Override
// public int compareTo(Object o) {
// return this.age - ((Person)o).age;
//
// }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) { //o 안에 age가 들어가기때문에 형변환을 안해줘도 된다.
return this.age - o.age;
}
//
// @Override
// public int compare(Object o1, Object o2) {
// return o1.age - o2.age; 제네릭을 사용하지 않으면 형변환을 해줘야 한다.
// 오브젝트안에는 age가 없기 때문에
// }
}
public class Main4 {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("홍길동",100));
ts.add(new Person("김길동",20));
ts.add(new Person("이길동",30));
System.out.println(ts);
}
}
package org.example;
import java.util.Comparator;
import java.util.TreeSet;
class Person implements Comparable<Person> { // 제네릭을 사용하게 되면
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// @Override
// public int compareTo(Object o) {
// return this.age - ((Person)o).age;
//
// }
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) { //o 안에 age가 들어가기때문에 형변환을 안해줘도 된다.
return this.age - o.age;
}
//
// @Override
// public int compare(Object o1, Object o2) {
// return o1.age - o2.age; 제네릭을 사용하지 않으면 형변환을 해줘야 한다.
// 오브젝트안에는 age가 없기 때문에
// }
}
class Comp implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
return o1.age - o2.age; // 오름차순
// return o2.age - o1.age; 내림차순
}
}
public class Main4 {
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<>(new Comp());
//TreeSet<Person> ts = new TreeSet<>();
ts.add(new Person("홍길동",100));
ts.add(new Person("김길동",20));
ts.add(new Person("이길동",30));
System.out.println(ts);
}
}
//
//TreeSet
//순서가 있는 자료형 컬렉션
//1.방법
//제네릭 객체를 넣을려고 하면...
//Comparable 인터페이스 상속받아
//CompareTo 메서드 재정의
//2. 방법
//
//Comparator 인터페에스 상속받아
//TreeSet 객체 생성시 생성자 변수로 넣어주면 된다.
●Map(key-value) 방식
package org.example;
import java.util.HashMap;
import java.util.Map;
public class Main6 {
public static void main(String[] args) {
Map<Integer,String> map1 = new HashMap<>();
map1.put(10,"홍길동");
map1.put(20,"이길동");
map1.put(30,"김길동");
System.out.println(map1.get(10));
System.out.println(map1.get(20));
System.out.println(map1.get(30));
Map<String,String> map2 = new HashMap<>();
map2.put("aa","홍길동");
map2.put("bb","이길동");
map2.put("cc","김길동");
System.out.println(map2.get("aa"));
System.out.println(map2.get("bb"));
System.out.println(map2.get("cc"));
}
}
put을 10,20,30 을 하고
get을 10,20,30 을 넣으면
뒤에 홍길동,이길동,김길동 차례대로 출력된다.
string 값도 똑같이 나타난다.
package org.example;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Main7 {
public static void main(String[] args) {
Map<Integer,String> map1 = new HashMap<>();
map1.put(10,"홍길동");
map1.put(20,"이길동");
map1.put(30,"김길동");
Set<Integer> seti = map1.keySet();
for(int temp : seti){
System.out.println(map1.get(temp));
}
System.out.println();
// System.out.println(map1.get(10));
// System.out.println(map1.get(20));
// System.out.println(map1.get(30));
Map<String,String> map2 = new HashMap<>();
map2.put("aa","홍길동");
map2.put("bb","이길동");
map2.put("cc","김길동");
Set<String> sets = map2.keySet();
for(String temp : sets){
System.out.println(map2.get(temp));
}
System.out.println();
// System.out.println(map2.get("aa"));
// System.out.println(map2.get("bb"));
// System.out.println(map2.get("cc"));
}
}