什么是集合

集合,集合是java中提供的一种容器,可以用来存储多个数据。

集合和数组的区别

  • 数组的长度是固定的。集合的长度是可变的
  • 集合中存储的元素必须是引用类型数据

Map集合概述

  • Collection中的集合,元素是孤立存在的,向集合中存储元素采用一个个元素的方式存储
  • Map中的集合,元素是成对存在的。每个元素由键与值两部分组成,通过键可以找对所对应的值
  • Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值

集合Map

  • Collection接口中的方法
  • 是集合中所有实现类必须拥有的方法
  • 方法的执行,都是实现的重写
Modifier and Type Method and Description
void clear()
从该地图中删除所有的映射(可选操作)。
default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
尝试计算指定键的映射及其当前映射的值(如果没有当前映射, null )。
default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
如果指定的键尚未与值相关联(或映射到 null ),则尝试使用给定的映射函数计算其值,并将其输入到此映射中,除非 null
default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
如果指定的密钥的值存在且非空,则尝试计算给定密钥及其当前映射值的新映射。
boolean containsKey(Object key)
如果此映射包含指定键的映射,则返回 true
boolean containsValue(Object value)
如果此地图将一个或多个键映射到指定的值,则返回 true
Set<Map.Entry<K,V>> entrySet()
返回此地图中包含的映射的Set视图。
boolean equals(Object o)
将指定的对象与此映射进行比较以获得相等性。
default void forEach(BiConsumer<? super K,? super V> action)
对此映射中的每个条目执行给定的操作,直到所有条目都被处理或操作引发异常。
V get(Object key)
返回到指定键所映射的值,或 null如果此映射包含该键的映射。
default V getOrDefault(Object key, V defaultValue)
返回到指定键所映射的值,或 defaultValue如果此映射包含该键的映射。
int hashCode()
返回此地图的哈希码值。
boolean isEmpty()
如果此地图不包含键值映射,则返回 true
Set<K> keySet()
返回此地图中包含的键的Set视图。
default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
如果指定的键尚未与值相关联或与null相关联,则将其与给定的非空值相关联。
V put(K key, V value)
将指定的值与该映射中的指定键相关联(可选操作)。
void putAll(Map<? extends K,? extends V> m)
将指定地图的所有映射复制到此映射(可选操作)。
default V putIfAbsent(K key, V value)
如果指定的键尚未与某个值相关联(或映射到 null )将其与给定值相关联并返回 null ,否则返回当前值。
V remove(Object key)
如果存在(从可选的操作),从该地图中删除一个键的映射。
default boolean remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。
default V replace(K key, V value)
只有当目标映射到某个值时,才能替换指定键的条目。
default boolean replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时,才能替换指定键的条目。
default void replaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果,直到所有条目都被处理或该函数抛出异常。
int size()
返回此地图中键值映射的数量。
Collection values()
返回此地图中包含的值的Collection视图。

put()方法 Map接口方法

  • V put(K,V) K 作为键的对象, V作为值的对象
  • 存储的是重复的键,将原有的值,覆盖
  • 返回值一般情况下返回null
  • 存储重复键的时候,返回被覆盖之前的值
//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println(map);

get()方法 Map接口方法

  • V get(K) 通过键对象,获取值对象 如果集合中没有这个键,返回null
//创建集合对象,作为键的对象整数,值的对象存储字符串
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
System.out.println(map);
String value = map.get(4);
System.out.println(value);

remove()方法 Map接口方法

  • V remove(K) 移除集合中的键值对,返回被移除之前的值
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
System.out.println(map);
String value = map.remove(33);
System.out.println(value);
System.out.println(map);

LinkedHashMap

  • LinkedHashMap继承HashMap 保证迭代的顺序
LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
link.put("1", "a");
link.put("13", "a");
link.put("15", "a");
link.put("17", "a");
System.out.println(link);

Map集合遍历

  • Map集合不能直接使用迭代器和增强for,但可以通过其他方式使用迭代器和增强for来达到遍历的目的

keySet()方法 Map接口方法

  • 调用map集合的方法keySet,所有的键存储到Set集合中
  • 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
  • 调用map集合方法get,通过键获取到值
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);
//1. 调用map集合的方法keySet,所有的键存储到Set集合中
Set<String> set = map.keySet();
//2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
Iterator<String> it = set.iterator();
while(it.hasNext()){
//it.next返回是Set集合元素,也就是Map中的键
//3. 调用map集合方法get,通过键获取到值
String key = it.next();
Integer value = map.get(key);
System.out.println(key+"...."+value);
}
// 增强for部分
for(String key : map.keySet()){
Integer value = map.get(key);
System.out.println(key+"...."+value);
}

entrySet()方法 Map内部接口Entry方法

在Map类设计时,提供了一个嵌套接口:Entry。Entry将键值对的对应关系封装成了对象,在遍历Map集合时,就可以从每一个键值对(Entry)对象中获取对应的键与对应的值。

  • getKey()方法:获取Entry对象中的键

  • getValue()方法:获取Entry对象中的值

  • entrySet()方法:用于返回Map集合中所有的键值对(Entry)对象,以Set集合形式返回

  • 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合Set<Entry <K,V> >

  • 迭代Set集合,获取出的Set集合的元素,是映射关系对象

  • 通过映射关系对象方法 getKet, getValue获取键值对

// 创建内部类对象 外部类.内部类 = new
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");
// while
// 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
Set<Map.Entry <Integer,String> > set = map.entrySet();
// 迭代Set集合
Iterator<Map.Entry <Integer,String> > it = set.iterator();
while(it.hasNext()){
// 获取出的Set集合的元素,是映射关系对象
// it.next 获取的是什么对象,也是Map.Entry对象
Map.Entry<Integer, String> entry = it.next();
// 通过映射关系对象方法 getKet, getValue获取键值对
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"...."+value);
}
// 增强for
// Map集合不能直接使用迭代器或者增强for进行遍历。但是转成Set之后就可以使用了
for(Map.Entry<Integer, String> entry : map.entrySet()){
System.out.println(entry.getKey()+"..."+entry.getValue());
}

静态导入

  • 如果本类中有和静态导入的同名方法会优先使用本类的
  • 如果还想使用静态导入的,依然需要类名来调用
import static java.lang.System.out;
import static java.util.Arrays.sort;
public class StaticImportDemo {
public static void main(String[] args) {
out.println("hello");
int[] arr = {1,4,2};
sort(arr);
}
}

方法的可变参数

  • 方法参数数据类型确定,参数的个数任意
  • 可变参数本质就是一个数组
  • 可变参数语法: 数据类型...变量名
  • 一个方法中,可变参数只能有一个
  • 可变参数,必须写在参数列表的最后一位
public static void main(String[] args) {
//调用一个带有可变参数的方法,传递参数,可以任意
int sum = getSum(5,34,3,56,7,8,0);
System.out.println(sum);
}
public static int getSum(int...a){
int sum = 0 ;
for(int i : a){
sum = sum + i;
}
return sum;
}

Collections工具类

  • 此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法,“包装器”,返回由指定集合支持的新集合,以及其他一些可能的和最终的。
Modifier and Type Method and Description
static <T> boolean addAll(Collection<? super T> c, T... elements)
将所有指定的元素添加到指定的集合。
static <T> Queue<T> asLifoQueue(Deque<T> deque)
返回Deque作为先进先出( Lifo ) Queue的视图 。
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, 类<E> type)
返回指定集合的动态类型安全视图。
static <E> List<E> checkedList(List<E> list, 类<E> type)
返回指定列表的动态类型安全视图。
static <K,V> Map<K,V> checkedMap(Map<K,V> m, 类<K> keyType, 类
返回指定地图的动态类型安全视图。
static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类
返回指定可导航地图的动态类型安全视图。
static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, 类<E> type)
返回指定的可导航集的动态类型安全视图。
static <E> Queue<E> checkedQueue(Queue<E> queue, 类<E> type)
返回指定队列的动态类型安全视图。
static <E> Set<E> checkedSet(Set<E> s, 类<E> type)
返回指定集合的动态类型安全视图。
static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类
返回指定排序映射的动态类型安全视图。
static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, 类<E> type)
返回指定排序集的动态类型安全视图。
static <T> void copy(List<? super T> dest, List<? extends T> src)
将所有元素从一个列表复制到另一个列表中。
static boolean disjoint(Collection<?> c1, Collection<?> c2)
如果两个指定的集合没有共同的元素,则返回 true
static <T> Enumeration<T> emptyEnumeration()
返回没有元素的枚举。
static <T> Iterator<T> emptyIterator()
返回没有元素的迭代器。
static <T> List<T> emptyList()
返回空列表(immutable)。
static <T> ListIterator<T> emptyListIterator()
返回没有元素的列表迭代器。
static <K,V> Map<K,V> emptyMap()
返回空的地图(不可变)。
static <K,V> NavigableMap<K,V> emptyNavigableMap()
返回空导航地图(不可变)。
static <E> NavigableSet<E> emptyNavigableSet()
返回一个空导航集(immutable)。
static <T> Set<T> emptySet()
返回一个空集(immutable)。
static <K,V> SortedMap<K,V> emptySortedMap()
返回空的排序映射(immutable)。
static <E> SortedSet<E> emptySortedSet()
返回一个空的排序集(immutable)。
static <T> Enumeration<T> enumeration(Collection<T> c)
返回指定集合的枚举。
static <T> void fill(List<? super T> list, T obj)
用指定的元素代替指定列表的所有元素。
static int frequency(Collection<?> c, Object o)
返回指定集合中与指定对象相等的元素数。
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)
根据其元素的 自然顺序返回给定集合的最大元素。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最大元素。
static <T extends Object & Comparable<? super T>>
T
min(Collection<? extends T> coll)
根据其元素的 自然顺序返回给定集合的最小元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最小元素。
static <T> List<T> nCopies(int n, T o)
返回由指定对象的 n副本组成的不可变列表。
static <E> Set<E> newSetFromMap(Map map)
返回由指定地图支持的集合。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
将列表中一个指定值的所有出现替换为另一个。
static void reverse(List<?> list)
反转指定列表中元素的顺序。
static <T> Comparator<T> reverseOrder()
返回一个比较器,它对实现 Comparable接口的对象集合施加了 自然排序的相反。
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)
返回一个只包含指定对象的不可变集。
static <T> List<T> singletonList(T o)
返回一个只包含指定对象的不可变列表。
static <K,V> Map<K,V> singletonMap(K key, V value)
返回一个不可变的地图,只将指定的键映射到指定的值。
static
void
sort(List<T> list)
根据其元素的natural ordering对指定的列表进行排序。
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)
返回由指定集合支持的同步(线程安全)集合。
static <T> List<T> synchronizedList(List<T> list)
返回由指定列表支持的同步(线程安全)列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定地图支持的同步(线程安全)映射。
static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
返回由指定的可导航地图支持的同步(线程安全)可导航地图。
static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
返回由指定的可导航集支持的同步(线程安全)可导航集。
static <T> Set<T> synchronizedSet(Set<T> s)
返回由指定集合支持的同步(线程安全)集。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
返回由指定的排序映射支持的同步(线程安全)排序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
返回由指定的排序集支持的同步(线程安全)排序集。
static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
返回指定集合的不可修改视图。
static <T> List<T> unmodifiableList(List<? extends T> list)
返回指定列表的不可修改视图。
static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
返回指定地图的不可修改视图。
static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
返回指定可导航地图的不可修改视图。
static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
返回指定的可导航集合的不可修改的视图。
static <T> Set<T> unmodifiableSet(Set<? extends T> s)
返回指定集合的不可修改视图。
static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
返回指定排序映射的不可修改视图。
static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
返回指定排序集的不可修改视图。

Collections.sort()静态方法

  • 对于List集合,进行升序排列
//创建List集合
List<String> list = new ArrayList<String>();
list.add("ewrew");
list.add("qwesd");
list.add("Qwesd");
list.add("bv");
list.add("wer");
System.out.println(list);
//调用集合工具类的方法sort
Collections.sort(list);
System.out.println(list);

Collections.binarySearch静态方法

  • 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(5);
list.add(8);
list.add(10);
list.add(15);
list.add(20);
//调用工具类静态方法binarySearch
int index = Collections.binarySearch(list, 16);
System.out.println(index);

Collections.shuffle方法

  • 对List集合中的元素,进行随机排列
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(5);
list.add(9);
list.add(11);
list.add(8);
list.add(10);
list.add(15);
list.add(20);
System.out.println(list);
//调用工具类方法shuffle对集合随机排列
Collections.shuffle(list);
System.out.println(list);

集合的嵌套

定义嵌套的集合

//定义基础班集合
HashMap<String, String> values1 = new HashMap<String, String>();
//定义就业班集合
HashMap<String, String> values2 = new HashMap<String, String>();
//向班级集合中,存储学生信息
values1.put("key1", "value1");
values1.put("key2", "value2");
values2.put("key1", "value1");
values2.put("key2", "value2");
//定义传智播客集合容器,键是班级名字,值是两个班级容器
HashMap<String, HashMap<String,String>> array = new HashMap<String, HashMap<String,String>>();
array.put("keys1", values1);
array.put("keys2", values2);

嵌套集合keySet遍历

//调用array集合方法keySet将键存储到Set集合
Set<String> classNameSet = array.keySet();
//迭代Set集合
Iterator<String> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
//classNameIt.next获取出来的是Set集合元素,array集合的键
String classNameKey = classNameIt.next();
//array集合的方法get获取值,值是一个HashMap集合
HashMap<String,String> classMap = array.get(classNameKey);
//调用classMap集合方法keySet,键存储到Set集合
Set<String> studentNum = classMap.keySet();
Iterator<String> studentIt = studentNum.iterator();
while(studentIt.hasNext()){
//studentIt.next获取出来的是classMap的键,学号
String numKey = studentIt.next();
//调用classMap集合中的get方法获取值
String nameValue = classMap.get(numKey);
System.out.println(classNameKey+".."+numKey+".."+nameValue);
}
}
System.out.println("==================================");
for(String className: array.keySet()){
HashMap<String, String> hashMap = array.get(className);
for(String numKey : hashMap.keySet()){
String nameValue = hashMap.get(numKey);
System.out.println(className+".."+numKey+".."+nameValue);
}
}

嵌套集合entrySet遍历

//调用array集合方法entrySet方法,将array集合的键值对关系对象,存储到Set集合
Set<Map.Entry<String, HashMap<String,String>>> classNameSet = array.entrySet();
//迭代器迭代Set集合
Iterator<Map.Entry<String, HashMap<String,String>>> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
//classNameIt.next方法,取出的是array集合的键值对关系对象
Map.Entry<String, HashMap<String,String>> classNameEntry = classNameIt.next();
//classNameEntry方法 getKey,getValue
String classNameKey = classNameEntry.getKey();
//获取值,值是一个Map集合
HashMap<String,String> classMap = classNameEntry.getValue();
//调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
//迭代Set集合
Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
while(studentIt.hasNext()){
//studentIt方法next获取出的是班级集合的键值对关系对象
Map.Entry<String, String> studentEntry = studentIt.next();
//studentEntry方法 getKey getValue
String numKey = studentEntry.getKey();
String nameValue = studentEntry.getValue();
System.out.println(classNameKey+".."+numKey+".."+nameValue);
}
}
System.out.println("==================================");
for (Map.Entry<String, HashMap<String, String>> me : array.entrySet()) {
String classNameKey = me.getKey();
HashMap<String, String> numNameMapValue = me.getValue();
for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
String numKey = nameMapEntry.getKey();
String nameValue = nameMapEntry.getValue();
System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
}
}