Java集合运算是指对集合中的元素进行操作,以获得新的集合。它可以用来求出两个或多个集合之间的交集、并集、差集等。
Java中有一些内置的方法可以用来实现常见的集合运算,如retainAll()、removeAll()和containsAll()。retainAll()方法用于获取两个集合之间的交集,removeAll()方法用于获取两个集合之间的差集,而containsAll()方法用于判断一个集合是否包含另一个集合中所有元素。
// 获取list1和list2之间的交集 List<String> list1 = new ArrayList<String>(); list1.add("a"); list1.add("b"); list1.add("c"); List<String> list2 = new ArrayList<String>(); list2.add("b"); list2.add("c"); list2.add("d"); // 返回[b, c] list1.retainAll(list2); // list1 = [b, c] list2 = [b, c, d] list1 ∩ list2 = [b, c]
Collection类中的两个静态方法会对List进行排序。
我们还可以使用List接口中的sort(Comparator c)对List进行排序,而不使用Collections类。
以下代码演示了如何对 List
进行排序:
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("J"); list.add("R"); list.add("C"); list.add("X"); System.out.println("List: " + list); // Uses Comparable implementation in String class // to sort the list in natural order Collections.sort(list); System.out.println("Sorted List: " + list); } }
上面的代码生成以下结果。
以下代码使用List接口中的sort()方法按其元素长度的升序对列表进行排序:
import java.util.ArrayList; import java.util.Comparator; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); System.out.println("List: " + list); // Uses List.sort() method with a Comparator list.sort(Comparator.comparing(String::length)); System.out.println("Sorted List: " + list); } }
上面的代码生成以下结果。
sort()
方法使用修改的mergeesort算法,这是一个稳定的排序。
在稳定的排序中,相等的元素将在排序操作之后保持在它们当前的位置。
排序提供了 n*log(n)
性能,其中 n
是列表中元素的数量。
Collections类中的两个静态binarySearch()方法在List中搜索键。
该方法使用二分搜索算法执行搜索。
int binarySearch(List list, T key) int binarySearch(List list, T key, Comparator c)
List
必须按升序排序,然后才能使用 binarySearch()
方法。
如果在列表中找到该键,则该方法将在列表中返回其索引。
如果在列表中没有找到键,它返回( - (insertion_index)-1)
,其中 Math.abs(( - (insertion_index)-1))
是我们可以插入这个键的索引仍然保持列表订购。
在列表中找不到键时,返回值为负值。
以下代码段显示了如何使用此方法:
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); Collections.sort(list); System.out.println("List: " + list); int index = Collections.binarySearch(list, "CSS"); System.out.println("CSS in List is at " + index); index = Collections.binarySearch(list, "Javascript"); System.out.println("Javascript in List is at " + index); } }
上面的代码生成以下结果。
由于“Javascript”不在列表中,二进制搜索返回-3。这意味着如果在列表中插入“Javascript”,它将被插入索引2,使用表达式( - ( - 2 + 1))计算。
Shuffle给我们一个列表中的元素的随机排列。
来自Collections类的shuffle()方法的两个版本如下:
void shuffle(List list) void shuffle(List list, Random rnd)
以下代码显示如何使用shuffle方法。
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); Collections.sort(list); System.out.println("List: " + list); Collections.shuffle(list); System.out.println("List: " + list); Collections.shuffle(list); System.out.println("List: " + list); } }
上面的代码生成以下结果。
我们可以使用 Collections
类的 reverse()
的静态方法来反转列表中的元素。
void reverse(List list)
以下代码显示如何使用 reverse()
方法。
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); Collections.sort(list); System.out.println("List: " + list); Collections.reverse(list); System.out.println("List: " + list); } }
上面的代码生成以下结果。
交换交换列表中的两个元素。
Collections类的 swap()
静态方法执行交换。
void swap(List list, int i, int j)
i
和 j
是两个元素的索引,它们必须在0和size-1之间,其中size是List的大小。
以下代码显示了如何使用这些方法对List的元素重新排序。
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); Collections.sort(list); System.out.println("List: " + list); // Swap elements at indexes 1 and 3 Collections.swap(list, 1, 3); System.out.println(list); } }
上面的代码生成以下结果。
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Main { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("Java"); list.add("R"); list.add("CSS"); list.add("XML"); Collections.sort(list); System.out.println("List: " + list); // Rotate elements by 2 Collections.rotate(list, 2); System.out.println("After Rotating by 2: " + list); } }
上面的代码生成以下结果。
我们可以使用Collections类的asLifoQueue()静态方法创建Deque的LIFO队列视图:
<T> Queue<T> asLifoQueue(Deque<T> deque)
要将Map的实现用作Set实现,请使用Collections类的 newSetFromMap()
静态方法:
<E> Set<E> newSetFromMap(Map<E, Boolean> map)
当将集合传递到其他方法时,我们可以获取集合的只读视图,并且我们不希望被调用的方法修改集合。
Collections类提供了以下方法来获取不同类型集合的只读视图:
<T> Collection<T> unmodifiableCollection(Collection<? extends T> c) <T> List<T> unmodifiableList(List<? extends T> list) <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m) <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m) <T> Set<T> unmodifiableSet(Set<? extends T> s) <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
我们传递一个特定类型的集合,并获得相同类型的只读集合。
我们可以使用Collections类的以下静态方法之一获取集合的同步视图。
<T> Collection<T> synchronizedCollection(Collection<T> c) <T> List<T> synchronizedList(List<T> list) <K,V> Map<K,V> synchronizedMap(Map<K,V> m) <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m) <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) <T> Set<T> synchronizedSet(Set<T> s) <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) <K,V> SortedMap<K,V> synchronizedSortedMap (SortedMap<K,V> m)
泛型为集合提供编译时类型安全。
下面的代码有一个编译时错误,因为我们试图添加Integer类型值到一个只能有String值的Set。
Set<String> s = new HashSet<>(); s.add("Hello"); a.add(new Integer(1)); // A compile-time error
我们可以通过使用以下代码绕过编译器检查:
Set<String> s = new HashSet< >(); s.add("Hello"); Set s2 = s; s2.add(new Integer(123)); // No runtime exception
我们可以通过使用检查的集合避免上述错误。Collection类的以下静态方法返回特定类型的已检查集合:
<E> Collection<E> checkedCollection(Collection<E> c, Class<E> type) <E> List<E> checkedList(List<E> list, Class<E> type) <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType) <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType) <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type) <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type) <E> Set<E> checkedSet(Set<E> s, Class<E> type) <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType) <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
下面的代码重写了上面的代码。
Set<String> checkedSet = Collections.checkedSet(new HashSet<String>(), String.class); Set s2 = checkedSet; s2.add(new Integer(1)); // Throws ClassCastException
Collections
类可以返回每种类型的不可变空集合对象。
它也可以返回一个空的迭代器。以下代码在Collections类中列出了这些静态方法:
<T> List<T> emptyList() <K,V> Map<K,V> emptyMap() <T> Set<T> emptySet() <T> Iterator<T> emptyIterator() <T> ListIterator<T> emptyListIterator()
我们可以使用Collections类创建一个只有一个元素的集合。
我们必须创建这种集合对象,当一个方法接受一个集合作为其参数,我们只有一个对象传递给该方法。
这些方法如下:
<T> Set<T> singleton(T o) <T> List<T> singletonList(T o) <K,V> Map<K,V> singletonMap(K key, V value)
以下代码显示了如何使用Collections.singleton()方法。
Set<String> singletonSet = Collections.singleton("Lonely"); // Throws a runtime exception since a singleton set is immutable singletonSet.add("Hello");
JPA 教程 -JPA 字段映射示例当将 Java bean 字段映射到数据库列时,我们可以选择标记字段,标记 getter 方法并标记两者。标记字...
Java设计模式 -MVC模式MVC 模式表示模型 - 视图 - 控制器模式。从名称我们可以看到,MVC模式涉及三个部分:Model(模型)- 模型表...
本章主要为大家介绍java多态的概念,以及便于理解的多态简单例子。Java 多态 多态是同一个行为具有多个不同表现形式或形态的能力...
Java教程 -Java布尔类型Java对逻辑值有一个布尔类型。这是所有关系运算符返回的类型。值它只能有两个可能的值之一, true 或 fal...
Java indexOf() 方法JavaString类indexOf() 方法有以下四种形式:public int indexOf(int ch): 返回指定字符在字符串中第一次出...