您的位置: 首页  >  文章  >  java-collections总结

java-collections总结

分类: 文章 • 2025-03-18 10:45:15

早在Java 2中之前，Java就提供了特设类。比如：Dictionary, Vector, Stack, 和Properties这些类用来存储和操作对象组。

虽然这些类都非常有用，但是它们缺少一个核心的，统一的主题。由于这个原因，使用Vector类的方式和使用Properties类的方式有着很大不同。

集合框架被设计成要满足以下几个目标。

  • 该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
  • 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
  • 对一个集合的扩展和适应必须是简单的。

为此，整个集合框架就围绕一组标准接口而设计。你可以直接使用这些接口的标准实现，诸如： LinkedList, HashSet, 和 TreeSet等,除此之外你也可以通过这些接口实现自己的集合。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

  • 接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。
  • 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。
  • 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合，该框架也定义了几个Map接口和类。Map里存储的是键/值对。尽管Map不是collections，但是它们完全整合在集合中。

java-collections总结java-collections总结


java-collections总结

类Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

java.lang.Object
        java.util.Collections

Collections中常用的方法：

（1）sort()排序方法

        函数定义：public static <T extends Comparable<? super T>> void sort(List<T> list) 根据元素的
        自然顺序对指定列表按升序进行排序。
        参数：要排序的列表。
        函数定义： public static <T> void sort(List<T> list,Comparator<? super T> c)，根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
        参数：list-要排序的列表；c-确定列表顺序的比较器。

（2）binarySearch()二分查找方法

        函数定义：public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
        使用二分搜索法搜索指定列表，以获得指定对象，在进行此方法调用前比较要将列表元素按照升序排序，否则结果不确定，此方法会执行O(n)次链接遍历和O(log n)次元素比较。
        参数: list-要搜索的链表，key-要搜索的键。
        函数定义： public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 根据指定的比较器对列表进行升序排序。
        参数：list-要搜索的列表，key-要搜索的键，c-排序列表的比较器。

（3）reverse()反转方法

         函数定义：public static void reverse(List<?> list)，反转指定列表中元素的顺序，此方法以线性时间运行。
        参数：list-元素要被反转的列表

（4）shuffle()改组方法

       函数定义：public static void shuffle(List<?> list)，使用默认随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的。
        参数：list-要改组的列表
        函数定义：public static void shuffle(List<?> list,Random rnd),使用指定的随机源对指定列表进行置换。
    参数：list-要改组的列表，rnd-用来改组列表的随机源。

（5）swap()交换方法

        函数定义：public static void swap(List<?> list,int i，int j)，在指定列表的指定位置处交换元素。
        参数：list-进行元素交换的列表，i-要交换的一个元素的索引，j-要交换的另一个元素的索引。

（6）fill()替换方法

        函数定义：public static <T> void fill(List<? super T> list,T obj)，使用指定元素替换指定列表中的所有元素，线性时间运行。
        参数:list-使用指定元素填充的列表，obj-用来填充指定列表的元素。

（7）copy()复制方法

        函数定义：public static <T> void copy(List<? super T> dest,List<? extends T> src)，将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引，目标列表的长度至少必须等于源列表。
        参数：dest-目标列表，src-源列表。

（8）min()最小值法

        函数定义：public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)，根据元素的自然顺序返回给定Collection的最小元素，Collection中的所有元素必须实现Comparable接口，此外，collection中的所有元素都必须是可相互比较的。
        参数：coll-将确定其最小元素的collection。
        函数定义：public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp),根据指定比较器产生的顺序，返回给定collection的最小元素。
        参数：coll-将确定其最小元素的collection，comp-用来确定最小元素的比较器。

（9）max()最大值方法

        函数定义：public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)，根据元素的自然顺序，返回给定collection的最大元素。
        参数：coll-将确定其最大元素的collection。
        函数定义：public static <T> T max(Collection<?extends T> coll,Comparator<? super T> comp)，根据指定比较器产生的顺序，返回给定collection的最大元素。
        参数：coll-将确定其最大元素的collection，comp-用来确定最大元素的比较器

（10）rotate()轮换方法

        函数定义：public static void rotate(List<?> list，int distance)，根据指定的距离轮转指定列表中的元素。
        参数：list-要轮换的列表，distance-列表轮换的距离，可以使0、负数或者大于list.size()的数。

（11）replaceAll()替换所有函数

        函数定义：public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)，使用另一个值替换列表总出现的所有的某一指定值。
        参数：list-在其中进行替换的列表；oldVal-将被替换的原值；newVal-替换oldVald的新值。

示例代码： 
public class Hello {
public static void main(String[] args) {
        System.out.println("sort");
        List list=new ArrayList<Double>();
       double array[] = {112, 111, 23, 456, 231 };
        for (int i = 0; i < array.length; i++) {
            list.add(new Double(array[i]));
        }
        Collections.sort(list);//自然排序
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        System.out.println("shuffle");

        Collections.shuffle(list);//置换
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        Collections.sort(list);//自然排序
        System.out.println("reverse");
        Collections. reverse (list);//反转
        for (int i = 0; i < array.length; i++) {
            System.out.println(list.get(i));
        }
        Collections.sort(list);//自然排序
        System.out.println("copy");
        List li = new ArrayList();
        double arr[] = {1131,333};
        for(int j=0;j<arr.length;j++){
            li.add(new Double(arr[j]));
        }
        Collections.copy(list,li);//拷贝
        for (int i = 0; i <list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("min");
        System.out.println(Collections.min(list));//返回最小值
        System.out.println("max");
        System.out.println(Collections.max(list));//返回最大值
        System.out.println("rotate");
        Collections.rotate(list,-1);//循环
        for (int i = 0; i <list.size(); i++) {
            System.out.println( list.get(i));
        }
         System.out.println("binarySearch");
        Collections.sort(list);
        System.out.println(list);
        System.out.println(Collections.binarySearch(list, 333.0));//二分查找
    }
}

以上是Collections比较常用的方法，Collections还有很多其他的方法，如下表：

方法摘要
static
<T> boolean
addAll(Collection<? super T> c, T... elements) 
          将所有指定元素添加到指定 collection 中。
static
<T> Queue<T>
asLifoQueue(Deque<T> deque) 
          以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。
static
<T> int
binarySearch(List<? extends Comparable<? super T>> list, T key) 
          使用二分搜索法搜索指定列表，以获得指定对象。
static
<T> int
binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
          使用二分搜索法搜索指定列表，以获得指定对象。
static
<E> Collection<E>
checkedCollection(Collection<E> c, Class<E> type) 
          返回指定 collection 的一个动态类型安全视图。
static
<E> List<E>
checkedList(List<E> list, Class<E> type) 
          返回指定列表的一个动态类型安全视图。
static
<K,V> Map<K,V>
checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) 
          返回指定映射的一个动态类型安全视图。
static
<E> Set<E>
checkedSet(Set<E> s, Class<E> type) 
          返回指定 set 的一个动态类型安全视图。
static
<K,V> SortedMap<K,V>
checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType) 
          返回指定有序映射的一个动态类型安全视图。
static
<E> SortedSet<E>
checkedSortedSet(SortedSet<E> s, Class<E> type) 
          返回指定有序 set 的一个动态类型安全视图。
static
<T> void
copy(List<? super T> dest, List<? extends T> src) 
          将所有元素从一个列表复制到另一个列表。
static boolean disjoint(Collection<?> c1, Collection<?> c2) 
          如果两个指定 collection 中没有相同的元素，则返回 true。
static
<T> List<T>
emptyList() 
          返回空的列表（不可变的）。
static
<K,V> Map<K,V>
emptyMap() 
          返回空的映射（不可变的）。
static
<T> Set<T>
emptySet() 
          返回空的 set（不可变的）。
static
<T> Enumeration<T>
enumeration(Collection<T> c) 
          返回一个指定 collection 上的枚举。
static
<T> void
fill(List<? super T> list, T obj) 
          使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o) 
          返回指定 collection 中等于指定对象的元素数。
static int indexOfSubList(List<?> source, List<?> target) 
          返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static int lastIndexOfSubList(List<?> source, List<?> target) 
          返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
static
<T> ArrayList<T>
list(Enumeration<T> e) 
          返回一个数组列表，它按返回顺序包含指定枚举返回的元素。
static
<T extends Object & Comparable<? super T>> 
T
max(Collection<? extends T> coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。
static
<T> T
max(Collection<? extends T> coll, Comparator<? super T> comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static
<T extends Object & Comparable<? super T>> 
T
min(Collection<? extends T> coll) 
          根据元素的自然顺序 返回给定 collection 的最小元素。
static
<T> T
min(Collection<? extends T> coll, Comparator<? super T> comp) 
          根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static
<T> List<T>
nCopies(int n, T o) 
          返回由指定对象的 n 个副本组成的不可变列表。
static
<E> Set<E>
newSetFromMap(Map<E,Boolean> map) 
          返回指定映射支持的 set。
static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list) 
          反转指定列表中元素的顺序。
static
<T> Comparator<T>
reverseOrder() 
          返回一个比较器，它强行逆转实现了 Comparable接口的对象 collection 的自然顺序。
static
<T> Comparator<T>
reverseOrder(Comparator<T> cmp) 
          返回一个比较器，它强行逆转指定比较器的顺序。
static void rotate(List<?> list, int distance) 
          根据指定的距离轮换指定列表中的元素。
static void shuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd) 
          使用指定的随机源对指定列表进行置换。
static
<T> Set<T>
singleton(T o) 
          返回一个只包含指定对象的不可变 set。
static
<T> List<T>
singletonList(T o) 
          返回一个只包含指定对象的不可变列表。
static
<K,V> Map<K,V>
singletonMap(K key, V value) 
          返回一个不可变的映射，它只将指定键映射到指定值。
static
<T extends Comparable<? super T>> 
void
sort(List<T> list) 
          根据元素的自然顺序 对指定列表按升序进行排序。
static
<T> void
sort(List<T> list, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定列表进行排序。
static void swap(List<?> list, int i, int j) 
          在指定列表的指定位置处交换元素。
static
<T> Collection<T>
synchronizedCollection(Collection<T> c) 
          返回指定 collection 支持的同步（线程安全的）collection。
static
<T> List<T>
synchronizedList(List<T> list) 
          返回指定列表支持的同步（线程安全的）列表。
static
<K,V> Map<K,V>
synchronizedMap(Map<K,V> m) 
          返回由指定映射支持的同步（线程安全的）映射。
static
<T> Set<T>
synchronizedSet(Set<T> s) 
          返回指定 set 支持的同步（线程安全的）set。
static
<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m) 
          返回指定有序映射支持的同步（线程安全的）有序映射。
static
<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s) 
          返回指定有序 set 支持的同步（线程安全的）有序 set。
static
<T> Collection<T>
unmodifiableCollection(Collection<? extends T> c) 
          返回指定 collection 的不可修改视图。
static
<T> List<T>
unmodifiableList(List<? extends T> list) 
          返回指定列表的不可修改视图。
static
<K,V> Map<K,V>
unmodifiableMap(Map<? extends K,? extends V> m) 
          返回指定映射的不可修改视图。
static
<T> Set<T>
unmodifiableSet(Set<? extends T> s) 
          返回指定 set 的不可修改视图。
static
<K,V> SortedMap<K,V>
unmodifiableSortedMap(SortedMap<K,? extends V> m) 
          返回指定有序映射的不可修改视图。
static
<T> SortedSet<T>
unmodifiableSortedSet(SortedSet<T> s) 
          返回指定有序 set 的不可修改视图。



    

相关推荐