자바 SE 기초 (컬 렉 션 인터페이스 개요)
13255 단어 자바comparable번복comparator
1。교체 가능 인터페이스 (Iterable) 교체 가능 한 인 터 페 이 스 는 하나의 방법 만 포함 하고 T 형식 요소 에서 교체 하 는 교체 기 를 되 돌려 줍 니 다.
public abstract Iterator<T> iterator();교체 기 Iterator 인터페이스의 방법 은 다음 과 같 습 니 다.
public interface Iterator<E>{
public abstract boolean hasNext(); // ， true
public abstract E next(); //
}2。Collection 인터페이스 에 대하 여 모든 통용 되 는 Collection 실현 류 는 두 가지 구조 방법 을 제공 합 니 다. (1) 빈 collection 을 만 드 는 데 사용 되 는 매개 변수 구조 방법 이 없습니다. (2) Collection 형식의 단일 매개 변 수 를 가 진 구조 방법 은 매개 변수 와 같은 원소 의 새로운 collection 을 만 드 는 데 사 용 됩 니 다.3。List 인터페이스 에 대하 여 (1) 질서 있 는 collection (시퀀스 라 고도 함), 이 인터페이스의 사용 자 는 목록 에 있 는 모든 요소 의 삽입 위 치 를 정확하게 제어 할 수 있 습 니 다. (2) 목록 은 보통 중복 되 는 요 소 를 허용 합 니 다. 목록 자체 가 null 요 소 를 허용 한다 면 여러 개의 null 요 소 를 허용 합 니 다. (3) List 인 터 페 이 스 는 특수 한 교체 기 ListIterator 를 제공 합 니 다. Iterator 인터페이스 가 제공 하 는 정상 적 인 조작 을 허용 하 는 동시에 요소 삽입 과 교체, 그리고 양 방향 접근 도 허용 합 니 다. (4) List 부분 방법
public interface List<E> extends Collection<E>{
Iterator<E> iterator(); //
ListIterator<E> listIterator(); // （ ）。
ListIterator<E> listIterator(int index); // （ ），
E set(int index, E element); // （
E get(int index); //
void add(int index, E element); // （ ）
List<E> subList(int fromIndex, int toIndex) // fromIndex（ ） toIndex（ ） 。
}
(1) 목록 교체 기 는 목록 을 한 방향 으로 옮 겨 다 니 며 교체 기간 에 목록 을 수정 하고 교체 기 가 목록 에 있 는 현재 위 치 를 얻 을 수 있 습 니 다.
(2) ListIterator 에 현재 요소 가 없습니다.커서 위 치 는 previous () 가 되 돌아 오 는 요소 와 next () 가 되 돌아 오 는 요소 사이 에 있 습 니 다.
Element(0) Element(1) Element(2) ... Element(n-1)
cursor positions: ^ ^ ^ ^ ^ ^
(3) reove () 와 set (Object) 방법 은 커서 위치 에 따라 정 의 된 것 이 아 닙 니 다.이것 은 next () 나 previous () 를 호출 하여 돌아 오 는 마지막 요소 에 대한 작업 정의 에 따 른 것 입 니 다.
(4) ListIterator 부분 방법
public interface ListIterator<E> extends Iterator<E>{
boolean hasNext(); // ， ， true
boolean hasPrevious(); // ， ， true
E next(); //
E previous(); //
int nextIndex(); // next
int previousIndex(); // previous
void add(E e); // ： next , previous ,
// next ， previous
void set(E e); // next previous
void remove(); // next previous
}
(1) 중복 요 소 를 포함 할 수 있 고 값 은 null 로 허용 되 며 스 레 드 가 동기 화 되 지 않 습 니 다.
(2) 모든 ArrayList 인 스 턴 스 는 하나의 용량 을 가지 고 있 으 며, ArrayList 에 요 소 를 계속 추가 하면 서 그 용량 도 자동 으로 증가 합 니 다.
대량의 요 소 를 추가 하기 전에 프로그램 은 ensureCapacity 작업 을 사용 하여 ArrayList 인 스 턴 스 의 용량 을 증가 시 킬 수 있 습 니 다.이것 은 증가 식 재분배 의 수량 을 줄 일 수 있다.
(3) ArrayList 인 스 턴 스 의 스 레 드 동기 화 는 일반적으로 이 목록 을 봉 인 된 대상 을 동기 화 하 는 것 을 통 해 이 루어 집 니 다.
이러한 대상 이 존재 하지 않 는 다 면 Collections. synchronized List 방법 으로 이 목록 을 '포장' 해 야 합 니 다.
List list = Collections.synchronizedList(new ArrayList(...));
(4) ArrayList 부분 방법
4. 567913. (5) 예 를 들 면:
public void ensureCapacity(int minCapacity){} // ArrayList ， minCapacity 。
public void add(int index, E element){} //
public int indexOf(Object o){} // ， ， -1
protected void removeRange(int from, int to){} // fromIndex（ ） toIndex（ ）
public void trimToSize(){} // ArrayList 。 ArrayList
(1) 중복 요 소 를 포함 할 수 있 고 값 은 null 로 허용 되 며 스 레 드 가 동기 화 되 지 않 습 니 다.
(2) List 인 터 페 이 스 를 실현 하 는 것 외 에 LinkedList 류 는 목록 의 시작 과 끝 에 get, remove 와 insert 요 소 를 통일 적 으로 명명 하 는 방법 을 제공 합 니 다.
이 동작 들 은 링크 목록 을 스 택, 대기 열 또는 더 블 엔 드 대기 열 로 사용 할 수 있 습 니 다.
(3) 이러한 iterator 와 listIterator 방법 으로 되 돌아 오 는 교체 기 는 빠 른 속도 로 실 패 했 습 니 다. 교체 기 를 만 든 후 구조 적 으로 목록 을 수정 하면,
교체 기 자체 의 reove 나 add 방법 을 통 해 다른 어떠한 방식 으로 든 수정 되 지 않 는 한 교체 기 는 Concurrent ModificationException 을 던 집 니 다.
(4) LinkedList 부분 방법
4. 567913. (5) 예 를 들 면:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class MyArrayList {
public static void main(String[] args) {
ArrayList< Integer> arraylist = new ArrayList<Integer>(); // ArrayList , 10
for(int i = 0 ; i < 15 ; i++){ //
arraylist.add(i);
}
Object[] arr =arraylist.toArray(); // arraylist ，
for (Object object : arr) { // ，
System.out.print( (int)object +"\t");
}
System.out.println();
System.out.println(arraylist.size()); // arraylist
System.out.println(arraylist.contains(15)); //
arraylist.add(5, -1); //
arraylist.add(15); //
System.out.println(arraylist.contains(15)); //
arr =arraylist.toArray(); // arraylist ，
for (Object object : arr) { // ，
System.out.print( (int)object +"\t");
}
System.out.println();
arraylist.set(5, 1); //
arraylist.remove(16); //
arraylist.remove(15);
arraylist.remove(arraylist.lastIndexOf(1));
Iterator<Integer> iterator = arraylist.iterator(); //
while(iterator.hasNext()){
System.out.print(iterator.next()+"\t");
}
System.out.println();
arraylist.trimToSize(); // ArrayList
ListIterator<Integer> listiterator = arraylist.listIterator(); // ListIterator
System.out.println(listiterator.hasPrevious());
while(listiterator.hasNext()){
System.out.print( listiterator.next()+"\t" );
}
System.out.println();
while(listiterator.hasPrevious()){
System.out.print( listiterator.previous()+"\t" );
}
System.out.println();
listiterator.next(); //
listiterator.next();
listiterator.set(-1);
while(listiterator.hasPrevious()) //
listiterator.previous();
while(listiterator.hasNext()) //
System.out.print( listiterator.next()+"\t" );
System.out.println();
}
}
(1) 중복 요 소 를 포함 하지 않 고 최대 null 을 포함 합 니 다.
(2) 인터페이스 설명 (부분):
public void addFirst(E e){} // 。
public void addLast(E e){} //
public E getFirst(){} //
public E getLast(){} //
public E removeFirst(){} //
public E removeLast(){} //
public ListIterator<E> listIterator(int index){} // ,
public Iterator<E> descendingIterator(){} // 。
(1) 중복 요 소 를 포함 하지 않 고 null 을 허용 하 며 스 레 드 가 동기 화 되 지 않 습 니 다.
(2) 이러한 것 은 HashMap 인 스 턴 스 가 지원 하 며 교체 순서 가 영원히 변 하지 않 을 것 을 보장 하지 않 습 니 다.
(3) 부분 적 방법
import java.util.Iterator;
import java.util.LinkedList;
public class MyLinkedList {
public static void main(String[] args) {
LinkedList<Integer> linkedlist = new LinkedList<Integer>();//
for(int i =0 ; i < 15 ; i++){ //
linkedlist.add(i);
}
Iterator iterator = linkedlist.iterator();// ，
while(iterator.hasNext()){
System.out.print( iterator.next()+"\t" );
}
System.out.println();
linkedlist.addFirst(15);//
System.out.println( linkedlist.removeLast() );//
iterator = linkedlist.iterator();// ，
while(iterator.hasNext()){
System.out.print( iterator.next()+"\t" );
}
System.out.println();
Iterator descendingiterator = linkedlist.descendingIterator(); //
while(descendingiterator.hasNext())
System.out.print( descendingiterator.next()+"\t" );
System.out.println();
}
}
(4) 예 를 들 면
public interface Set<E>extends Collection<E>{
Iterator<E> iterator(); // set
int size(); // set
}
(1) 요 소 는 null 로 허용 되 지 않 습 니 다.
(2) 요 소 는 자연 순 서 를 사용 하여 정렬 하거나 질서 있 는 set 를 만 들 때 제공 하 는 Comparator 에 따라 정렬 합 니 다.이 set 의 교체 기 는 요소 의 오름차 순 으로 set 를 옮 겨 다 닐 것 입 니 다.
(3) 질서 있 는 set 를 삽입 하 는 모든 요 소 는 Comparable 인 터 페 이 스 를 실현 해 야 합 니 다. 모든 요 소 는 서로 비교 할 수 있어 야 합 니 다.
(4) 모든 질서 있 는 set 실현 류 는 4 개의 구조 방법 을 제공 해 야 한다.
1) 매개 변수 없 는 구조 방법 으로 빈 질서 있 는 set 를 만 들 고 요소 의 자연 순서에 따라 정렬 합 니 다.
2) Comparator 형식의 매개 변 수 를 가 진 구조 방법 으로 빈 질서 있 는 set 를 만 들 고 지정 한 비교 기 에 따라 정렬 합 니 다.
3) Collection 형식의 매개 변 수 를 가 진 구조 방법 으로 새로운 질서 있 는 set 를 만 듭 니 다. 그 요 소 는 매개 변수 와 같 고 요소 의 자연 순서에 따라 정렬 합 니 다.
4) SortedSet 형식 매개 변 수 를 가 진 구조 방법 으로 새로운 질서 있 는 set 를 만 듭 니 다. 그 요소 와 정렬 방법 은 입력 한 질서 있 는 set 와 같 습 니 다.
(5) 부분 적 방법
public boolean add(E e){} // set ，
public Iterator<E> iterator(){} // set
public boolean remove(Object o){} // set ，
(1) 중복 요 소 를 포함 하지 않 고 null 을 허용 하지 않 으 며 스 레 드 가 동기 화 되 지 않 습 니 다.
(2) 요소 의 자연 순 서 를 사용 하여 요 소 를 정렬 하거나 set 를 만 들 때 제공 하 는 Comparator 에 따라 정렬 합 니 다. 구체 적 으로 사용 하 는 구조 방법 에 달 려 있 고 요 소 는 비교 할 수 있어 야 합 니 다.
(3) 이 는 기본 작업 (add, remove, contains) 에 보 증 된 log (n) 시간 비용 을 제공 합 니 다.
(4) 부분 적 방법
4. 567913. (5) 예 를 들 면
import java.util.HashSet;
import java.util.Iterator;
public class MyHashSet {
public static void main(String[] args) {
HashSet<Integer> hashset = new HashSet<Integer>(); //
for(int i =0 ; i < 15 ; i++) //
hashset.add(i);
hashset.add(null);
Iterator iterator = hashset.iterator(); // ， hashset
while(iterator.hasNext())
System.out.print( iterator.next()+"\t" );
System.out.println();
System.out.println( hashset.size() ); //
System.out.println( hashset.contains(10) ); //
System.out.println( hashset.add(10) ); //
System.out.println( hashset.add(15) ); //
System.out.println( hashset.remove(0) ); //
System.out.println( hashset.remove(0) ); //
iterator = hashset.iterator(); // ， hashset
while(iterator.hasNext())
System.out.print( iterator.next()+"\t" );
System.out.println();
System.out.println( hashset.isEmpty() );
hashset.clear(); //
System.out.println( hashset.isEmpty() );
}
}
(1) 중복 허용, null 허용, 스 레 드 동기 화 허용
(2) 배열 기반
(3) Vector 의 elements 방법 으로 되 돌아 오 는 Enumeration 은 빠 른 실패 가 아 닙 니 다.
(4) 용량 의 증 가 량 이 0 보다 적 으 면 용량 을 늘 려 야 할 때마다 벡터 의 용량 이 배로 커진다.
(5) 부분 적 방법
4. 567913. (6) 예 를 들 면
Comparator<? super E> comparator(); // set ; set , null
E first(); // set ( )
E last(); // set ( )
SortedSet<E> subSet(E from, E to); // set ， from( ) to( )
SortedSet<E> headSet(E toElement); // set ， toElement
SortedSet<E> tailSet(E fromElement); // set ， fromElement
(1) Stack 클래스 는 스 택 을 표시 하고 클래스 벡터 를 확장 하여 push, pop 작업 을 제공 합 니 다.
(2) 부분 적 방법
4. 567913. (3) 예 를 들 면
public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, Serializable{
public TreeSet(){} // set, set
public TreeSet(Comparator<? super E> comparator){} // TreeSet，
public TreeSet(Collection<? extends E> c){} // collection TreeSet,
public TreeSet(SortedSet<E> s){} // set TreeSet
E ceiling(E e){} // set >=e ； ， null
E floor(E e){} // set <=e ； ， null
E higher(E e){} // set >e ； ， null
E lower(E e){} // set <e ； ， null
Comparator<? super E> comparator(){} // set ； set ， null
Iterator<E> iterator(){} // set
Iterator<E> descendingIterator(){} // set
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Is Eclipse IDE dying?In 2014 the Eclipse IDE is the leading development environment for Java with a market share of approximately 65%. but ac...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
