다크호스 프로그래머 학습 일기 -- 자바 API (2)
10235 단어 다크호스 학습 일기
------Java 교육, Android 교육, iOS 교육,. Net 교육、 ！ -------집합 프레임
집합 류
특징: 집합 은 저장 대상 에 사용 할 수 있 고 집합 길 이 는 가 변 적 이 며 집합 은 서로 다른 유형의 대상 을 저장 할 수 있다.
모든 용기 가 데이터 에 대한 저장 방식 이 다 르 기 때문에 이 저장 방식 을 데이터 구조 라 고 부른다.
add 방법의 매개 변수 유형 은 Object 로 임의의 유형의 대상 을 받 아들 일 수 있 습 니 다.
집합 에 저 장 된 것 은 모두 대상 의 인용 이다.
집합 에서 흔히 볼 수 있 는 방법:
추가:
boolean add(Object obj);
boolean addAll(Collection coll)
삭제:
boolean remove(Object obj)
boolean removeAll(Collection coll)
void clear()
판단:
boolean contains(Object obj)
boolean containsAll(Collection coll)
boolean isEmpty()
가 져 오기:
int size();
Iterator iterator()
기타:
boolean retainAll (Collection coll): 교 집합
Object toArray()
교체 기: 원 소 를 집합 하여 꺼 내 는 방식
Collection：
List: 요 소 는 질서 가 있 고 요 소 는 중복 할 수 있 습 니 다. 이 집합 시스템 에 색인 이 있 기 때 문 입 니 다.
set: 요 소 는 무질서 합 니 다. 요 소 는 중복 할 수 없습니다.
List 특유 의 방법:
추가: add (index, element)
addAll（index，Collection）
삭제: remove (index)
변경: set (index, element)
검색: get (index)
sublist（from,to）
listIterator()
int indexOf(Object)
int lastIndexOf(Object)
ListIterator: List 집합 특유 의 교체 기, Itarator 의 하위 인터페이스
Array List: 바 텀 데이터 구 조 는 배열 구 조 를 사용 하고 스 레 드 가 동기 화 되 지 않 습 니 다.
특징: 조회 가 빠 르 고 삭제 가 느 립 니 다.
링크 드 리스트: 밑 에 링크 데이터 구 조 를 사용 합 니 다.
그 는 첨삭 이 빠 르 고 조회 가 좀 느리다 고 말 했다.
Vector: 바 텀 은 배열 데이터 구조 이 고 라인 동기 화 입 니 다.
연습 코드:
import java.util.*;
class J14_1
{
public static void main(String[] args)
{
ArrayList a = new ArrayList();
a.add("java01");
a.add("java02");
a.add("java03");
a.add("java04");
/*
Iterator i = a.iterator();
while(i.hasNext())
sop(i.next());
*/
for(Iterator i = a.iterator();i.hasNext();)
sop(i.next());
/*
ArrayList b = new ArrayList();
b.add("java01");
b.add("java02");
b.add("java05");
b.add("java06");
*/
//a.retainAll(b);
//a.removeAll(b);
//a.addAll(b);
//sop(a);
//sop(b);
//sop("size="+a.size());
//sop(a);
//a.remove("java02");
//sop(a);
//a.clear();
//sop(" ："+a.isEmpty());
//sop("java03 ："+a.contains("java03"));
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
LinkedList 특유 의 방법:
addFirst() getFirst() removeFirst()
addLast() getLast() removeLast()
창고: 먼저 들 어가 서 나 가기
대열: 먼저 First In First Out
List 집합 은 요소 가 같 는 지 여 부 를 판단 하고 요소 의 equals 방법 에 근 거 를 둔다.
연습 코드:
import java.util.*;
class J14_3
{
public static void main(String[] args)
{
LinkedList ls = new LinkedList();
ls.addLast("java01");
ls.addLast("java02");
ls.addLast("java03");
ls.addLast("java04");
sop(ls);
//sop(ls.getFirst());
//sop(ls.getLast());
//sop(ls.removeFirst());
while(!ls.isEmpty())
sop(ls.removeFirst());
sop("size="+ls.size());
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
set: 요 소 는 무질서 합 니 다. 요 소 는 중복 할 수 없습니다.
Set 집합 기능 은 Collection 과 일치 합 니 다.
-- HashSet: 바 텀 데이터 구 조 는 해시 표 이 고 스 레 드 는 동기 화 되 지 않 습 니 다.
-- TreeSet: Set 집합 에 있 는 요 소 를 정렬 할 수 있 습 니 다.
HashSet 요소 의 유일 성: 요소 의 두 가지 방법: hashCode 와 equals 를 통 해 이 루어 집 니 다.
연습 코드:
import java.util.*;
class J14_7
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
sop(hs.add("java03"));
hs.add("java04");
hs.add("java01");
hs.add("java02");
hs.add("java05");
sop(hs.add("java03"));
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext())
sop(it.next());
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
class Demo
{
public int hashCode()
{
return 60;
}
}
public interface Comparable:
이 인 터 페 이 스 는 모든 종류의 대상 을 강제로 정렬 합 니 다.이러한 정렬 은 클래스 의 자연 정렬 이 라 고 불 리 며, 클래스 의 copare To 방법 은 그의 자연 비교 방법 이 라 고 불 린 다.
TreeSet: 바 텀 데이터 구 조 는 이 진 트 리 입 니 다.
요소 의 유일 성 을 보장 하 는 근거: compare To 방법 return 0
TreeSet 정렬 의 첫 번 째 방식: 요소 자체 가 비교 성 을 가지 도록 합 니 다.원 소 는 Comparable 인 터 페 이 스 를 실현 해 야 한다.compare To 방법 을 덮어 씁 니 다.
TreeSet 의 두 번 째 정렬 방식: 요소 자체 가 비교 성 을 갖 추 지 못 할 때 또는 갖 추 는 비교 성 이 필요 하지 않 을 때 집합 자체 가 비교 성 을 갖 도록 해 야 한다.
코드 예제:
import java.util.*;
class J15_1
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyComparator());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi05",25));
ts.add(new Student("lisi04",18));
ts.add(new Student("lisi03",18));
ts.add(new Student("lisi03",19));
for(Iterator it = ts.iterator();it.hasNext();)
{
Student p = (Student)it.next();
sop(p.getName()+"..."+p.getAge());
}
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException(" ");
Student p = (Student)obj;
System.out.println(this.name+"..equals.."+p.name);
if(this.age>p.age)
return 1;
if(this.ages2.getAge())
return 1;
if(s1.getAge() 범 형
JDK 1.5 버 전 이후 에 나타 난 새로운 기능 은 안전 문 제 를 해결 하 는 데 사용 되 는 유형의 안전 메커니즘 이다.
좋 은 점:
운행 시기 에 문제 가 발생 한 것 을 컴 파일 시기 로 옮 겨 강제 전환 의 번 거 로 움 을 피 했다.
일반 형식:
< > 를 통 해 조작 할 인용 데이터 형식 을 정의 합 니 다.
일반적인 클래스: 클래스 에서 조작 할 참조 데이터 형식 이 불확실 할 때 사용 합 니 다.
범 형 방법: 서로 다른 방법 으로 서로 다른 유형 을 조작 할 수 있 고 유형 이 불확실 하기 위해 범 형 을 방법 에 정의 할 수 있다.
(정적 방법 은 클래스 에서 정의 하 는 범 형 에 접근 할 수 없습니다)
？어댑터
일반적인 한정:
？ extends E: E 타 입 이나 E 의 하위 타 입 (상한 선) 을 받 아들 일 수 있 습 니 다.
？ 슈퍼 E: E 형식 이나 E 의 문자 형식 (하한 선) 을 받 아들 일 수 있 습 니 다.
연습 코드:
class J15_4
{
public static void main(String[] args)
{
/*
Tool t = new Tool();
t.setObj(new Worker());
Worker w = (Worker)t.getObj();
Utils u = new Utils();
u.setObj(new Worker());
Worker w =u.getObj();
Demo d = new Demo();
d.show("haha");
d.print(7);
d.print("java");
Demo.method("china");
Demo.method(5);
*/
InterImp i = new InterImp();
i.show(4);
}
}
interface Inter
{
public abstract void show(T t);
}
class InterImp implements Inter
{
public void show(T s)
{
System.out.println("show:"+s);
}
}
/*
class InterImp implements Inter
{
public void show(String s)
{
System.out.println("show:"+s);
}
}
*/
class Demo
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(Q t)
{
System.out.println("print:"+t);
}
public static void method(Q q)
{
System.out.println("method:"+q);
}
}
class Student
{
}
class Worker
{
}
class Tool
{
private Object obj;
public void setObj(Object obj)
{
this.obj = obj;
}
public Object getObj()
{
return obj;
}
}
class Utils
{
private T obj;
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return obj;
}
}
지도
| - Hashtable: 바 텀 은 해시 표 데이터 구조 입 니 다. null 키 null 값 을 저장 할 수 없습니다. 스 레 드 동기 화.
| HashMap: 아래쪽 은 해시 표 데이터 구조 로 null 키 null 값 을 사용 할 수 있 으 며 스 레 드 가 동기 화 되 지 않 습 니 다.
-- TreeMap: 밑 층 은 이 진 트 리 데이터 구조 이 고 선 층 이 일치 하지 않 습 니 다.맵 집합 에 있 는 키 를 정렬 하 는 데 사용 할 수 있 습 니 다.
keyset: 맵 의 모든 키 를 set 집합 에 저장 합 니 다.
Map 집합 추출 원리: Map 집합 을 set 집합 으로 전환 하여 교체 하 는 방식 으로 추출 합 니 다.
Set > entry Set: map 집합 에 있 는 맵 관 계 를 set 집합 에 저장 합 니 다.
Map. Entry: Entry 도 하나의 인터페이스 입 니 다. 그 는 Map 인터페이스 중의 내부 인터페이스 입 니 다.
코드 예제:
import java.util.*;
class J15_7
{
public static void main(String[] args)
{
Map m = new HashMap ();
m.put(new Student("hoop01",11),"beijing");
m.put(new Student("hoop01",11),"tianjing");
m.put(new Student("hoop02",12),"shanghai");
m.put(new Student("hoop03",13),"guangzhou");
m.put(new Student("hoop04",14),"shenzhen");
//
Set s = m.keySet();
Iterator it = s.iterator();
while(it.hasNext())
{
Student st = it.next();
System.out.println(st+"..."+m.get(st));
}
//
Set> set = m.entrySet();
Iterator> iter = set.iterator();
while(iter.hasNext())
{
Map.Entry me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"........."+addr);
}
}
}
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException();
Student s = (Student) obj;
return this.name.equals(s.getName())&&this.age==s.getAge();
}
public int compareTo(Student s)
{
int num = new Integer(this.getAge()).compareTo(new Integer(s.getAge()));
if(num==0)
return this.name.compareTo(s.getName());
return num;
}
} 좋은 웹페이지 즐겨찾기
