当前位置: 首页>>代码示例 >>用法及示例精选 >>正文


Java Collections用法及代码示例


集合Java 中的 class 是 Java Collections Framework 中的实用程序类之一。 java.util 包包含 Java 中的 Collections 类。 Java Collections 类与静态方法对集合进行操作或返回集合。该类的所有方法都会抛出NullPointerException如果传递给方法的集合或对象为 null。

集合类声明

Collection类声明的语法如下:

public class Collections extends Object

记住: Object是所有类的父类。

Collection Classes in java

Java集合类

集合框架包含类和接口。虽然两者看似相同但有一定的Collection 类和 Collection 框架之间的区别。 Java中有一些类,如下所示:

1.ArrayList

ArrayList 是使用列表接口实现的类,提供动态数组的函数,其中数组的大小不固定。

用法:

ArrayList<_type_> var_name = new ArrayList<_type_>();

2.矢量

Vector 是集合类的一部分,它实现了可以根据需要增大或缩小其大小的动态数组。

用法:

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, 
Cloneable, Serializable

3. 堆栈

Stack 是 Java 集合类的一部分,它建模并实现了 Stack 数据结构。它基于后进先出(LIFO)的基本原则。

用法:

public class Stack<E> extends Vector<E>

4.LinkedList

LinkedList 类是 LinkedList 数据结构的实现。它可以存储不存储在连续位置的元素,并且每个元素都是具有不同数据部分和不同地址部分的单独对象。

用法:

LinkedList name = new LinkedList();  

5.HashSet

HashSet是使用Hashtable数据结构实现的。它为执行添加、删除、包含和大小等操作提供恒定的时间性能。

用法:

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable

6.LinkedHashSet

LinkedHashSet 是 HashSet 的有序版本,它维护跨所有元素的 doubly-linked 列表。

用法:

public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, Serializable

7.TreeSet

TreeSet 类是 Java 中 SortedSet 接口的实现,它使用 Tree 进行存储。无论是否提供显式比较器,元素的顺序都由集合使用其自然顺序来维护。

用法:

TreeSet t = new TreeSet(Collection col);

8.PriorityQueue

PriorityQueue 基于优先级堆。优先级队列的元素根据自然顺序或通过队列构造时提供的比较器进行排序,具体取决于使用的构造函数。

用法:

public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable

9.ArrayDeque

Java 中的 ArrayDeque 类是 Deque 接口的实现,它使用可调整大小的数组来存储其元素。 ArrayDeque 类为从两端插入和删除元素提供恒定时间性能。

用法:

public class ArrayDeque<E> extends 
AbstractCollection<E> implements Deque<E>, Cloneable,Serializable

10.HashMap

HashMap 类与HashTable 类似,但数据不同步。它将数据存储在(键,值)对中,您可以通过其他类型的索引访问它们。

用法:

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

11.EnumMap

EnumMap 扩展 AbstractMap 并实现 Java 中的 Map 接口 .

用法:

public class EnumMap<K extends Enum<K>,V> extends 
AbstractMap<K,V> implements Serializable, Cloneable

12.AbstractMap

AbstractMap 类是 Java 集合框架的一部分。它实现了 Map 接口来为其提供结构,这样可以使进一步的实现变得更容易。

用法:

public abstract class AbstractMap<K,V> extends Object, implements Map<K,V>

13.TreeMap

TreeMap 是使用 Red-Black 树实现的。TreeMap 提供键值对的有序集合,其中键根据其自然顺序或传递给构造函数的自定义比较器进行排序。

SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...)); 

Java 集合类字段

集合类包含如下列出的 3 个字段,可用于返回不可变实体。

  • EMPTY_LIST 获取不可变的空列表
  • EMPTY_SET 获取不可变的空集
  • EMPTY_MAP 获得一个不可变的空 Map

现在让我们讨论此类中存在的方法,以便我们稍后可以在程序中使用这些内置函数。下面以表格形式列出了这些方法,如下所示:

Methods

Description

addAll(Collection<? super T> c, T… 元素) 用于将指定的集合元素插入到指定的集合中。
asLifoQueue(Deque<T> 双端队列) 此方法返回作为后进先出 (Lifo) 队列的 Deque 视图。
binarySearch(List<? extends Comparable> 列表,T 键) 此方法使用二分搜索在指定列表中搜索键。
binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 此方法使用二分搜索算法在指定列表中搜索指定对象。
checkCollection(Collection<E> c, Class<E> 类型) 此方法返回指定集合的动态类型安全视图。
checkList(List<E> 列表,Class<E> 类型) 此方法返回指定列表的动态类型安全视图。
checkMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) 此方法返回指定映射的动态类型安全视图。
checkNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType) 此方法返回指定可导航Map的动态类型安全视图。
checkNavigableSet(NavigableSet<E> s, Class<E> 类型) 此方法返回指定可导航集的动态类型安全视图。
checkQueue(Queue<E> 队列, Class<E> 类型) 此方法返回指定队列的动态类型安全视图。
checkSet(Set<E> s, Class<E> 类型) 此方法返回指定集的动态类型安全视图。
checkSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType) 此方法返回指定排序映射的动态类型安全视图。
checkSortedSet(SortedSet<E> s, Class<E> 类型) 此方法返回指定排序集的动态类型安全视图。
复制(列表<?超级T> dest,列表<?扩展T> src) 此方法将一个列表中的所有元素复制到另一个列表中。
不相交(集合<?> c1,集合<?> c2) 如果两个指定的集合没有共同元素,则此方法返回 true。
emptyEnumeration() 此方法返回一个没有元素的枚举。
emptyIterator() 此方法返回一个没有元素的迭代器。
emptyList() 此方法返回一个空列表(不可变)。
emptyListIterator() 此方法返回一个没有元素的列表迭代器。
emptyMap() 此方法返回一个空映射(不可变)。
emptyNavigableMap() 此方法返回一个空的可导航Map(不可变)。
emptyNavigableSet() 此方法返回一个空的可导航集(不可变)。
emptySet() 此方法返回一个空集(不可变)。
emptySortedMap() 此方法返回一个空的排序映射(不可变)。
emptySortedSet() 此方法返回一个空的排序集(不可变)。
枚举(集合<T> c) 此方法返回指定集合的枚举。
fill(List<? super T> 列表, T obj) 此方法用指定元素替换指定列表中的所有元素。
频率(集合<?> c,对象o) 此方法返回指定集合中等于指定对象的元素数量。
indexOfSubList(List<?> 源, List<?> 目标) 此方法返回指定源列表中指定目标列表第一次出现的起始位置,如果没有出现,则返回 -1。
lastIndexOfSubList(List<?> 源, List<?> 目标) 此方法返回指定源列表中最后一次出现的指定目标列表的起始位置,如果没有此类出现,则返回 -1。
列表(枚举<T> e) 此方法返回一个数组列表,其中包含指定枚举返回的元素(按枚举返回的顺序排列)。
max(集合 <? 扩展 T> coll) 此方法根据元素的自然顺序返回给定集合的最大元素。
max(Collection<? extends T> coll, Comparator<? super T> comp) 此方法根据指定比较器产生的顺序返回给定集合的最大元素。
min(Collection<? extends T> coll) 此方法根据元素的自然顺序返回给定集合的最小元素。
min(Collection<? extends T> coll, Comparator<? super T> comp) 此方法根据指定比较器产生的顺序返回给定集合的最小元素。
nCopies(int n, T o) 此方法返回一个由指定对象的 n 个副本组成的不可变列表。
newSetFromMap(Map<E,Boolean> Map) 此方法返回由指定映射支持的集合。
ReplaceAll(List<T> 列表, T oldVal, T newVal) 此方法将列表中所有出现的一个指定值替换为另一个指定值。
反向(列表 <?> 列表) 该方法反转指定列表中元素的顺序
reverseOrder() 此方法返回一个比较器,该比较器对实现 Comparable 接口的对象集合施加与自然顺序相反的顺序。
verseOrder(比较器<T> cmp) 此方法返回一个比较器,该比较器强制指定比较器的相反顺序。
旋转(列表<?>列表,int距离) 此方法将指定列表中的元素旋转指定的距离。
Shuffle[洗牌](列表 <?> 列表) 此方法使用默认的随机源随机排列指定的列表。
洗牌(列表 <?> 列表,随机 rnd) 此方法使用指定的随机源随机排列指定的列表。
singletonMap(K key, V value) 此方法返回一个不可变的映射,仅将指定的键映射到指定的值。
singleton(T o) 此方法返回一个仅包含指定对象的不可变集。
singletonList(T o) 此方法返回一个仅包含指定对象的不可变列表。
排序(列表<T>列表) 此方法根据其元素的自然顺序对指定列表进行升序排序。
排序(列表 <T> 列表,比较器 <? super T> c) 此方法根据指定比较器产生的顺序对指定列表进行排序。
交换(列表 <?> 列表,int i,int j) 此方法交换指定列表中指定位置的元素。
同步集合(集合<T> c) 此方法返回由指定集合支持的同步(线程安全)集合。
同步列表(列表 <T> 列表) 此方法返回由指定列表支持的同步(线程安全)列表。
同步Map(Map<K,V> m) 此方法返回由指定映射支持的同步(线程安全)映射。
同步NavigableMap(NavigableMap<K,V> m) 此方法返回由指定的可导航映射支持的同步(线程安全)可导航映射。
同步的NavigableSet(NavigableSet<T> s) 此方法返回由指定可导航集支持的同步(线程安全)可导航集。
同步集(Set<T> s) 此方法返回由指定集支持的同步(线程安全)集。
同步SortedMap(SortedMap<K,V> m) 此方法返回由指定排序映射支持的同步(线程安全)排序映射。
SynchronizedSortedSet(SortedSet<T> s) 此方法返回由指定排序集支持的同步(线程安全)排序集。
unmodifierCollection(Collection<? extends T> c) 此方法返回指定集合的不可修改的视图。
unmodifierList(List<? 扩展 T> 列表) 此方法返回指定列表的不可修改视图。
unmodifierNavigableMap(NavigableMap<K,? 扩展 V> m) 此方法返回指定可导航Map的不可修改视图。
不可修改的NavigableSet(NavigableSet<T> s) 此方法返回指定可导航集的不可修改视图。
unmodifierSet(Set<?extends T> s) 此方法返回指定集的不可修改视图。
不可修改的SortedMap(SortedMap<K,? extends V> m) 此方法返回指定排序映射的不可修改视图。
不可修改的SortedSet(SortedSet<T> s) 此方法返回指定排序集的不可修改视图。

现在,我们已经列出了所有方法,因此现在我们已经有了一个微弱的提示,可以让我们了解这些方法在考虑全局编程角度时的重要性。编写优化代码时重要且经常使用的方法,因为您将在几乎每个 Java 优化代码中看到这些方法,因为 Java 中 Collections 类的大量使用。因此,在这里,比在任何课程中更有可能的是,我们不仅会实现该方法,还会讨论可以执行的操作,以便人们在实现相同方法时能够拥有清晰的概念和强大的命令。

Java 集合示例

Java 中集合类的示例如下:

  • 将元素添加到集合中
  • 对集合进行排序
  • 在集合中搜索
  • 复制元素
  • 不相交集合

1. 将元素添加到 Collections 类对象

Collections addAll()的方法java.util.Collections 类class 用于将所有指定元素添加到指定集合中。要添加的元素可以单独指定或作为数组指定。

例子

Java


// Java Program to Demonstrate Adding Elements 
// Using addAll() method 
  
// Importing required classes 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.List; 
  
// Main class 
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
        // Creating a list 
        // Declaring object of string type 
        List<String> items = new ArrayList<>(); 
  
        // Adding elements (items) to the list 
        items.add("Shoes"); 
        items.add("Toys"); 
  
        // Add one or more elements 
        Collections.addAll(items, "Fruits", "Bat", "Ball"); 
  
        // Printing the list contents 
        for (int i = 0; i < items.size(); i++) { 
            System.out.print(items.get(i) + " "); 
        } 
    } 
}
输出
Shoes Toys Fruits Bat Ball 

2.对集合进行排序

java.util.Collections.sort() 用于按升序对指定集合list 中存在的元素进行排序。 java.util.Collections.reverseOrder()用于降序排序。

示例

Java


// Java program to demonstrate sorting 
// a Collections using sort() method 
  
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.List; 
  
// Main Class 
// SortingCollectionExample 
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
        // Creating a list 
        // Declaring object of string type 
        List<String> items = new ArrayList<>(); 
  
        // Adding elements to the list 
        // using add() method 
        items.add("Shoes"); 
        items.add("Toys"); 
  
        // Adding one or more elements using addAll() 
        Collections.addAll(items, "Fruits", "Bat", "Mouse"); 
  
        // Sorting according to default ordering 
        // using sort() method 
        Collections.sort(items); 
  
        // Printing the elements 
        for (int i = 0; i < items.size(); i++) { 
            System.out.print(items.get(i) + " "); 
        } 
  
        System.out.println(); 
  
        // Sorting according to reverse ordering 
        Collections.sort(items, Collections.reverseOrder()); 
  
        // Printing the reverse order 
        for (int i = 0; i < items.size(); i++) { 
            System.out.print(items.get(i) + " "); 
        } 
    } 
} 
输出
Bat Fruits Mouse Shoes Toys 
Toys Shoes Mouse Fruits Bat 

3. 在集合中搜索

Collections.binarySearch()方法返回对象在排序列表中的位置。要使用此方法,列表应按升序排序,否则该方法返回的结果将是错误的。如果该元素存在于列表中,则该方法将返回该元素在排序列表中的位置,否则该方法返回的结果将为-(元素应该存在的插入点(如果存在)-1)

示例

Java


// Java Program to Demonstrate Binary Search 
// Using Collections.binarySearch() 
  
// Importing required classes 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.List; 
  
// Main class 
// BinarySearchOnACollection 
public class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
        // Creating a List 
        // Declaring object of string type 
        List<String> items = new ArrayList<>(); 
  
        // Adding elements to object 
        // using add() method 
        items.add("Shoes"); 
        items.add("Toys"); 
        items.add("Horse"); 
        items.add("Ball"); 
        items.add("Grapes"); 
  
        // Sort the List 
        Collections.sort(items); 
  
        // BinarySearch on the List 
        System.out.println( 
            "The index of Horse is "
            + Collections.binarySearch(items, "Horse")); 
  
        // BinarySearch on the List 
        System.out.println( 
            "The index of Dog is "
            + Collections.binarySearch(items, "Dog")); 
    } 
}
输出
The index of Horse is 2
The index of Dog is -2

4. 复制元素

Collections copy()的方法java.util.Collections 类类用于将一个列表中的所有元素复制到另一个列表中。操作完成后,目标列表中每个复制元素的索引将与其在源列表中的索引相同。目标列表必须至少与源列表一样长。如果更长,则目标列表中的其余元素不受影响。

示例

Java


// Java Program to Demonstrate Copying Elements 
// Using copy() method 
  
// Importing required classes 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.List; 
  
// Main class 
// CopyOneCollectionToAnother 
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
        // Create destination list 
        List<String> destination_List = new ArrayList<>(); 
  
        // Add elements 
        destination_List.add("Shoes"); 
        destination_List.add("Toys"); 
        destination_List.add("Horse"); 
        destination_List.add("Tiger"); 
  
        // Print the elements 
        System.out.println( 
            "The Original Destination list is "); 
  
        for (int i = 0; i < destination_List.size(); i++) { 
            System.out.print(destination_List.get(i) + " "); 
        } 
        System.out.println(); 
  
        // Create source list 
        List<String> source_List = new ArrayList<>(); 
  
        // Add elements 
        source_List.add("Bat"); 
        source_List.add("Frog"); 
        source_List.add("Lion"); 
  
        // Copy the elements from source to destination 
        Collections.copy(destination_List, source_List); 
  
        // Printing the modified list 
        System.out.println( 
            "The Destination List After copying is "); 
  
        for (int i = 0; i < destination_List.size(); i++) { 
            System.out.print(destination_List.get(i) + " "); 
        } 
    } 
}
输出
The Original Destination list is 
Shoes Toys Horse Tiger 
The Destination List After copying is 
Bat Frog Lion Tiger 

5. 不相交集合

java.util.Collections.disjoint() 用于检查两个指定集合是否不相交。更正式地说,如果两个集合没有共同元素,则它们是不相交的。如果两个集合没有任何共同元素,则返回 true。

示例

Java


// Java Program to Illustrate Working of Disjoint Function 
  
// Importing required classes 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.List; 
  
// Main class 
// DisjointCollectionsExample 
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
        // Create list1 
        List<String> list1 = new ArrayList<>(); 
  
        // Add elements to list1 
        list1.add("Shoes"); 
        list1.add("Toys"); 
        list1.add("Horse"); 
        list1.add("Tiger"); 
  
        // Create list2 
        List<String> list2 = new ArrayList<>(); 
  
        // Add elements to list2 
        list2.add("Bat"); 
        list2.add("Frog"); 
        list2.add("Lion"); 
  
        // Check if disjoint or not 
        System.out.println( 
            Collections.disjoint(list1, list2)); 
    } 
}
输出
true

相关文章:



相关用法


注:本文由纯净天空筛选整理自lavishgarg26大神的英文原创作品 Collections Class in Java。非经特殊声明,原始代码版权归原作者所有,本译文未经允许或授权,请勿转载或复制。