关于tailsetjava的信息
今天给各位分享tailsetjava的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
java有哪些有序集合？
Comparable接口
Comparator接口
SortedSet接口
SortedMap接口
在集合框架中有许多类具有排序功能，如：TreeSet类TreeMap类
为了用“集合框架”的额外部分把排序支持添加到Java2 SDK，版本1.2，核心Java库作了许多更改。像String和Integer类如今实现Comparable接口以提供自然排序顺序。对于那些没有自然顺序的类、或者当您想要一个不同于自然顺序的顺序时，您可以实现Comparator接口来定义您自己的。
Comparable接口
适用于一个类有自然顺序的时候（对于这个自然顺序的理解，我觉得是这样：Comparable中只有一个方法compareTo（），它是比较当前实例和作为参数传入的元素，一个实例，一个参数，说明实例和参数自然具有可比较性）。
下面是Comparable接口的定义：
package java.lang; import java.util.*; public interfaceComparableT { publicintcompareTo(T o); }
compareTo()方法：如果排序过程中当前实例出现在参数前，就返回某个负值。如果当前实例出现在参数后，则返回正值。否则，返回零。这里不要求零返回值表示元素相等。零返回值只是表示两个对象排在同一个位置。
Java1.6中实现了Comparable接口的类大概有50左右个。
Comparator接口
有些类是不能用于实现java.lang.Comparable，这时我们可以提供自己的java.lang.Comparator行为。或者，如果你不喜欢缺省的Comparable行为，你也照样可以提供自己的Comparator。
package java.lang; import java.util.*; public interface ComparableT { public int compareTo(T o); } 实例： import java.util.Comparator; import java.util.Iterator; import java.util.Set; import java.util.TreeSet; /** * 10、 定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性， * 创建5个对象, 属性可为任意值. 编程对这5个对象按成绩排序，并将结果输出。 * （提示，用TreeSet和Comparator实现） * * *******************按成绩小大排序**************** * @author jin * */ public class Test10 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Student_ stu1=new Student_("Joyce", 21, 98); Student_ stu2=new Student_("kelvin", 25, 95); Student_ stu3=new Student_("kelvun", 29, 89); Student_ stu4=new Student_("Judy", 25, 92); Student_ stu5=new Student_("phil", 43, 93); // 创建TreeSet SetStudent_ st=new TreeSetStudent_(new Student_.TestScoresCompareStudent_()); st.add(stu5); st.add(stu4); st.add(stu3); st.add(stu2); st.add(stu1); //遍历 IteratorStudent_ it=st.iterator(); while(it.hasNext()){ Student_ student=it.next(); System.out.println(student.getName()+" : "+student.getAge()+" : "+student.getTest_scores()); } } } class Student_{ // 三个属性 private String name; private int age; private int test_scores; public String getName(){ return this.name; } public int getAge(){ return this.age; } public int getTest_scores(){ return this.test_scores; } Student_(String name, int age, int test_scores){// 构造器 this.name=name; this.age=age; this.test_scores=test_scores; } // 这里为什么要用静态类呢？ static class TestScoresCompareT implements ComparatorT{ // 注意：ComparatorT是泛型，实现了这个接口的类也要是泛型 //// 实现比较器 @Override public int compare(T o1, T o2) { Student_ stu1=(Student_)o1; Student_ stu2=(Student_)o2; if(stu1.test_scoresstu2.test_scores){ return 1; } return -1; } } // 泛型参数可以出现在：类，接口，成员方法，内嵌类（接口）中 }
另外，“集合框架”提供了两个特殊的接口：SortedSet接口 和 SortMap接口
SortedSet接口
接口为集的子集和它的两端（即头和尾）提供了访问方法。
从treeSet类的定义中可以发现，TreeSet中实现了SortedSet接口.
添加到SortedSet中的元素必须实现Comparable接口。或者你必须给他的实现类的构造函数提供一个Comparator（上面那个实例就是这样呀）。
如果添加元素时比较两个元素导致了零返回值，那么新元素就没有添加进去。
public interface SortedSetE extends SetE { Comparator? super E comparator(); // 返回与排序有关联的比较器 SortedSetE subSet(E fromElement, E toElement); // 返回指定对象间的元素 SortedSetE headSet(E toElement); // 返回从开始到指定元素的集合 SortedSetE tailSet(E fromElement); E first(); E last(); }
SortedMap接口
用来保持键Key的有序。
和上面的SortedSet接口类似，为映射的子集包括两个端点提供了访问方法。
TreeMap中实现了SortMap接口。
如果在添加一个键-值对时比较两个键产生了零返回值，那么，原始键对应值被新的值替代。
java TreeSet.tailSet(E fromElement)抛出java.lang.NullPointerException 异常
空指针错误
抛这种NullPointerException
说明你有变量没有初始化就使用啦，就是说没有new出来就使用啦
看看自己的程序里面有没有尚未初始化就使用的变量
java 小题目
package util;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* p
* 操作集合的类，可以返回以读写锁实现的各类集合br
* /p
*
*/
public class CollectionUtils {
private CollectionUtils() {}
/**
* p
* 返回用读写锁实现的集合
* /p
*
* @param collection
* 基础集合
* @return 同步集合
*/
public static T CollectionT readWriteLockCollection(
CollectionT collection) {
return new ReadWriteLockCollectionT(collection);
}
/**
* p
* 返回用读写锁实现的List
* /p
*
* @param list
* 基础List
* @return 同步List
*/
public static T ListT readWriteLockList(ListT list) {
return new ReadWriteLockListT(list);
}
/**
* p
* 返回用读写锁实现的Set
* /p
*
* @param set
* 基础Set
* @return 同步Set
*/
public static T SetT readWriteLockSet(SetT set) {
return new ReadWriteLockSetT(set);
}
/**
* p
* 返回用读写锁实现的SortedSet
* /p
*
* @param sortedSet
* 基础SortedSet
* @return 同步SortedSet
*/
public static T SortedSetT readWriteLockSortedSet(SortedSetT sortedSet) {
return new ReadWriteLockSortedSetT(sortedSet);
}
/**
* p
* 返回用读写锁实现的Map
* /p
*
* @param map
* 基础Map
* @return 同步Map
*/
public static K, V MapK, V readWriteLockMap(MapK, V map) {
return new ReadWriteLockMapK, V(map);
}
/**
* p
* 返回用读写锁实现的SortedMap
* /p
*
* @param sortedMap
* 基础SortedMap
* @return 同步SortedMap
*/
public static K, V SortedMapK, V readWriteLockSortedMap(
SortedMapK, V sortedMap) {
return new ReadWriteLockSortedMapK, V(sortedMap);
}
private static class ReadWriteLockCollectionT implements CollectionT {
private CollectionT collection;
protected ReadWriteLock lock = new ReentrantReadWriteLock();
private ReadWriteLockCollection(CollectionT collection) {
if (collection == null)
throw new NullPointerException();
this.collection = collection;
}
@Override
public boolean add(T e) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.add(e);
} finally {
lock.unlock();
}
}
@Override
public boolean addAll(Collection? extends T c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.addAll(c);
} finally {
lock.unlock();
}
}
@Override
public void clear() {
Lock lock = this.lock.writeLock();
lock.lock();
try {
collection.clear();
} finally {
lock.unlock();
}
}
@Override
public boolean contains(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.contains(o);
} finally {
lock.unlock();
}
}
@Override
public boolean containsAll(Collection? c) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.containsAll(c);
} finally {
lock.unlock();
}
}
@Override
public boolean isEmpty() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.isEmpty();
} finally {
lock.unlock();
}
}
@Override
public IteratorT iterator() {
return collection.iterator();
}
@Override
public boolean remove(Object o) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.remove(o);
} finally {
lock.unlock();
}
}
@Override
public boolean removeAll(Collection? c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.removeAll(c);
} finally {
lock.unlock();
}
}
@Override
public boolean retainAll(Collection? c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return collection.retainAll(c);
} finally {
lock.unlock();
}
}
@Override
public int size() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.size();
} finally {
lock.unlock();
}
}
@Override
public Object[] toArray() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.toArray();
} finally {
lock.unlock();
}
}
@Override
public E E[] toArray(E[] a) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return collection.toArray(a);
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockListT extends
ReadWriteLockCollectionT implements ListT {
private ListT list;
private ReadWriteLockList(ListT list) {
super(list);
this.list = list;
}
@Override
public void add(int index, T element) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
list.add(index, element);
} finally {
lock.unlock();
}
}
@Override
public boolean addAll(int index, Collection? extends T c) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.addAll(index, c);
} finally {
lock.unlock();
}
}
@Override
public T get(int index) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.get(index);
} finally {
lock.unlock();
}
}
@Override
public int indexOf(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.indexOf(o);
} finally {
lock.unlock();
}
}
@Override
public int lastIndexOf(Object o) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return list.lastIndexOf(o);
} finally {
lock.unlock();
}
}
@Override
public ListIteratorT listIterator() {
return list.listIterator();
}
@Override
public ListIteratorT listIterator(int index) {
return list.listIterator(index);
}
@Override
public T remove(int index) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.remove(index);
} finally {
lock.unlock();
}
}
@Override
public T set(int index, T element) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return list.set(index, element);
} finally {
lock.unlock();
}
}
@Override
public ListT subList(int fromIndex, int toIndex) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockListT(
list.subList(fromIndex, toIndex));
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockSetT extends ReadWriteLockCollectionT
implements SetT {
private ReadWriteLockSet(SetT set) {
super(set);
}
}
private static class ReadWriteLockSortedSetT extends ReadWriteLockSetT
implements SortedSetT {
private SortedSetT sortedSet;
private ReadWriteLockSortedSet(SortedSetT sortedSet) {
super(sortedSet);
this.sortedSet = sortedSet;
}
@Override
public Comparator? super T comparator() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.comparator();
} finally {
lock.unlock();
}
}
@Override
public T first() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.first();
} finally {
lock.unlock();
}
}
@Override
public SortedSetT headSet(T toElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(
sortedSet.headSet(toElement));
} finally {
lock.unlock();
}
}
@Override
public T last() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedSet.last();
} finally {
lock.unlock();
}
}
@Override
public SortedSetT subSet(T fromElement, T toElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(sortedSet.subSet(
fromElement, toElement));
} finally {
lock.unlock();
}
}
@Override
public SortedSetT tailSet(T fromElement) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedSetT(
sortedSet.tailSet(fromElement));
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockMapK, V implements MapK, V {
private MapK, V map;
protected ReadWriteLock lock = new ReentrantReadWriteLock();
private ReadWriteLockMap(MapK, V map) {
if (map == null)
throw new NullPointerException();
this.map = map;
}
@Override
public void clear() {
Lock lock = this.lock.writeLock();
lock.lock();
try {
map.clear();
} finally {
lock.unlock();
}
}
@Override
public boolean containsKey(Object key) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.containsKey(key);
} finally {
lock.unlock();
}
}
@Override
public boolean containsValue(Object value) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.containsValue(value);
} finally {
lock.unlock();
}
}
@Override
public Setjava.util.Map.EntryK, V entrySet() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSetjava.util.Map.EntryK, V(
map.entrySet());
} finally {
lock.unlock();
}
}
@Override
public V get(Object key) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.get(key);
} finally {
lock.unlock();
}
}
@Override
public boolean isEmpty() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.isEmpty();
} finally {
lock.unlock();
}
}
@Override
public SetK keySet() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSetK(map.keySet());
} finally {
lock.unlock();
}
}
@Override
public V put(K key, V value) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return map.put(key, value);
} finally {
lock.unlock();
}
}
@Override
public void putAll(Map? extends K, ? extends V m) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
map.putAll(m);
} finally {
lock.unlock();
}
}
@Override
public V remove(Object key) {
Lock lock = this.lock.writeLock();
lock.lock();
try {
return map.remove(key);
} finally {
lock.unlock();
}
}
@Override
public int size() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return map.size();
} finally {
lock.unlock();
}
}
@Override
public CollectionV values() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockCollectionV(map.values());
} finally {
lock.unlock();
}
}
}
private static class ReadWriteLockSortedMapK, V extends
ReadWriteLockMapK, V implements SortedMapK, V {
private SortedMapK, V sortedMap;
private ReadWriteLockSortedMap(SortedMapK, V sortedMap) {
super(sortedMap);
this.sortedMap = sortedMap;
}
@Override
public Comparator? super K comparator() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.comparator();
} finally {
lock.unlock();
}
}
@Override
public K firstKey() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.firstKey();
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V headMap(K toKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(
sortedMap.headMap(toKey));
} finally {
lock.unlock();
}
}
@Override
public K lastKey() {
Lock lock = this.lock.readLock();
lock.lock();
try {
return sortedMap.lastKey();
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V subMap(K fromKey, K toKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(sortedMap.subMap(
fromKey, toKey));
} finally {
lock.unlock();
}
}
@Override
public SortedMapK, V tailMap(K fromKey) {
Lock lock = this.lock.readLock();
lock.lock();
try {
return new ReadWriteLockSortedMapK, V(
sortedMap.tailMap(fromKey));
} finally {
lock.unlock();
}
}
}
}
tailsetjava的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、tailsetjava的信息别忘了在本站进行查找喔。
发布于：2022-12-03，除非注明，否则均为原创文章，转载请注明出处。