什么是集合
集合,集合是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>> |
max(Collection<? extends T> coll)
根据其元素的
自然顺序返回给定集合的最大元素。
|
static <T> T |
max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定的比较器引发的顺序返回给定集合的最大元素。
|
static <T extends Object & Comparable<? super 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
返回由指定地图支持的集合。
|
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 |
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); } }
最后一次更新于2019-06-28 21:47
0 条评论