为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java 提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。
Java Collection接口
Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
boolean | add(E e) 确保此集合包含指定的元素（可选操作）。 |
boolean | addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合（可选操作）。 |
void | clear() 从此集合中删除所有元素（可选操作）。 |
boolean | contains(Object o) 如果此集合包含指定的元素，则返回 true 。 |
boolean | containsAll(Collection<?> c) 如果此集合包含指定 集合中的所有元素，则返回true。 |
boolean | equals(Object o) 将指定的对象与此集合进行比较以获得相等性。 |
int | hashCode() 返回此集合的哈希码值。 |
boolean | isEmpty() 如果此集合不包含元素，则返回 true 。 |
Iterator<E> | iterator() 返回此集合中的元素的迭代器。 |
default Stream<E> | parallelStream() 返回可能并行的 |
boolean | remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。 |
boolean | removeAll(Collection<?> c) 删除指定集合中包含的所有此集合的元素（可选操作）。 |
default boolean | removeIf(Predicate<? super E> filter) 删除满足给定谓词的此集合的所有元素。 |
boolean | retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。 |
int | size() 返回此集合中的元素数。 |
default Spliterator<E> | spliterator() 创建一个Spliterator在这个集合中的元素。 |
default Stream<E> | stream() 返回以此集合作为源的顺序 |
Object[] | toArray() 返回一个包含此集合中所有元素的数组。 |
<T> T[] | toArray(T[] a) 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。 |
详细介绍请参考JavaAPI文档 collection类
https://www.matools.com/api/java8
Java List集合：ArrayList和LinkedList类的用法及区别
List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List 集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。
List 实现了 Collection 接口，它主要有两个常用的实现类：ArrayList 类和 LinkedList 类。
ArrayList 类
ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。
LinkedList类
LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素。
具体实现代码
public class ListExcise {
public static void main(String[] args) {
Collection<Integer> collection=new ArrayList<>();
Iterator iterator=new Iterator() {
@Override
public boolean hasNext() {
return false;
}
@Override
public Object next() {
return null;
}
};
//List集合索引从0开始，集合中的元素可以重复
System.out.println("-----ArraysList------");
List<Integer> list=new ArrayList<>();//泛型<>内填入包装类
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(1);
list.forEach(System.out::println); //遍历
System.out.println();
System.out.println(list.indexOf(1)); //indexOf返回该集合中指定元素第一次出现的索引，若无该元素则返回-1
System.out.println(list.lastIndexOf(1)); //lastIndexOf返回该集合中指定元素最后一次的索引，若无该元素则返回-1
System.out.println(list.set(2,8)); //set将指定索引位置的值的设置为指定的值，指定位置不能超过集合的最长索引的值
list.forEach(System.out::println); //遍历
System.out.println( list.subList(2,4)); //subList子集合，返回指定索引起始位置至指定索引结束位置的集合（左开右闭）
/*
subList使用linkList类
*/
System.out.println("-----subList------");
LinkedList<Integer> subList=new LinkedList<>();
subList.add(10);
subList.add(20);
subList.add(30);
subList.add(40);
subList.add(50);
System.out.print(subList);
System.out.println();
System.out.println("---subList方法");
subList.addFirst(0); //将元素e的值加入到集合的开头
subList.addLast(60);//将元素e的值加入到集合的结尾
System.out.print(subList);
System.out.println();
System.out.println("-----get()");
System.out.println(subList.get(2)); //获取指定索引位置的值
System.out.println( subList.getFirst()); //获取开头的元素
System.out.println(subList.getLast()); //获取结尾的元素
System.out.println("----remove()---");
System.out.println(subList.remove(2)); //与get()方法类似，删除
System.out.println(subList.removeFirst());
System.out.println(subList.removeLast());
}
}ArrayList 类和 LinkedList 类的区别
ArrayList 类和 LinkedList 类的区别 ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List 的所有未实现的方法，只是实现的方式有所不同。 ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList。 对于快速访问对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高。 不同的结构对应于不同的算法，有的考虑节省占用空间，有的考虑提高运行效率，对于程序员而言，它们就像是“熊掌”和“鱼肉”，不可兼得。高运行速度往往是以牺牲空间为代价的，而节省占用空间往往是以牺牲运行速度为代价的。
Java Set集合：HashSet和TreeSet类
Set 实现了 Collection 接口，它主要有两个常用的实现类：HashSet 类和 TreeSet类。
HashSet 类
HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。
HashSet 具有以下特点：
- 不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
- HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
- 集合元素值可以是 null。
import java.util.HashSet;
//HashSet 是 Set 接口的典型实现,具有很好的存取和查找性能
public class SetExcise {
public static void main(String[] args) {
System.out.println("----HashSet---");
HashSet hs=new HashSet(); //调用无参构造函数创建对象
HashSet<String> hashSet=new HashSet<String>(); //创建泛型的HashSet集合对象
hashSet.add("JAVA");
hashSet.add("PYTHON");
hashSet.add("C++");
hashSet.add("GO");
hashSet.add("JAVA"); //Set 集合中不能包含重复的对象
hashSet.add(null); //集合元素值可以是 null。
//不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
System.out.println(hashSet);
System.out.println("-----TreeSet-----");
}
}
TreeSet 类
TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。
Java Map集合和Java遍历Map集合的四种方式
Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。
Map 集合里保存着两组值，一组值用于保存 Map 里的 key，另外一组值用于保存 Map 里的 value，key 和 value 都可以是任何引用类型的数据。Map 的 key 不允许重复，value 可以重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false。
Map 中的 key 和 value 之间存在单向一对一关系，即通过指定的 key，总能找到唯一的、确定的 value。从 Map 中取出数据时，只要给出指定的 key，就可以取出对应的 value。
Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序。
Map 接口中提供的常用方法如表 1 所示。
| 方法名称 | 说明 |
|---|---|
| void clear() | 删除该 Map 对象中的所有 key-value 对。 |
| boolean containsKey(Object key) | 查询 Map 中是否包含指定的 key，如果包含则返回 true。 |
| boolean containsValue(Object value) | 查询 Map 中是否包含一个或多个 value，如果包含则返回 true。 |
| V get(Object key) | 返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型 |
| V put(K key, V value) | 向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。 |
| void putAll(Map m) | 将指定 Map 中的 key-value 对复制到本 Map 中。 |
| V remove(Object key) | 从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null |
| boolean remove(Object key, Object value) | 这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。 |
| Set entrySet() | 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry |
| Set keySet() | 返回 Map 集合中所有键对象的 Set 集合 |
| boolean isEmpty() | 查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。 |
| int size() | 返回该 Map 里 key-value 对的个数 |
| Collection values() | 返回该 Map 里所有 value 组成的 Collection |
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
//Map集合
public class MapExcise {
public static void main(String[] args) {
HashMap<String,Integer> hashMap=new HashMap<>();
hashMap.put("一",10);
hashMap.put("二",20);
hashMap.put("三",30);
hashMap.put("四",40);
hashMap.put("五",50);
//Map 的 key 不允许重复，value 可以重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false。
hashMap.put("六",50);
hashMap.put("九",null); //key，value可以为null
System.out.println(hashMap); //Map集合是无序的
System.out.println("集合中是否包含指定的KEY: "+hashMap.containsKey(40)); //boolean类型
System.out.println("集合中是否包含一个或多个指定的value: "+hashMap.containsValue(50)); //boolean类型
System.out.println("返回指定键对象对应的值： "+hashMap.get("四"));
System.out.println("向集合中添加指定的键值对，如果集合中已有一个相等的键值对，则将覆盖："+hashMap.put("七",70)); //输出为null
System.out.println("向集合中添加指定的键值对，如果集合中已有一个相等的键值对，则将覆盖："+hashMap.put("七",70)); //输出为70
System.out.println(hashMap);
HashMap<String,Integer> hashMap1=new HashMap<>();
hashMap1.putAll(hashMap); //将指定map的键值对复制给本map中
System.out.println(hashMap1);
//从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
System.out.println(hashMap.remove("五"));
// java8新增的方法，编译器中出现如果存在相同的键值对(key-value两个一致)则返回true，不存在则为false
System.out.println( hashMap.remove("四",50)); //false
System.out.println(hashMap);
// 返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
System.out.println(hashMap.entrySet());
//返回 Map 集合中所有键对象的 Set 集合(返回的是一个集合）
System.out.println(hashMap.keySet());
System.out.println("查询集合是否为空： "+hashMap.isEmpty());
System.out.println("返回集合中键值对的个数： "+hashMap.size());
System.out.println("返回集合中所有的val组成的collection:"+ hashMap.values()); //返回键值对的值
hashMap.clear();
System.out.println(hashMap); //{}
//java遍历Map集合的四种方式
//在for循环中使用entires实现Map的遍历
for(Map.Entry<String,Integer> entry : hashMap1.entrySet()){
System.out.println(entry.getKey()+" ."+entry.getValue());
}
//使用 for-each 循环遍历 key 或者 values，
// 一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。
for(String s : hashMap1.keySet()){
System.out.println(s);
}
for(Integer i : hashMap1.values()){
System.out.println(i);
}
//使用迭代器（Iterator）遍历
Iterator<Map.Entry<String,Integer>> entryIterator=hashMap1.entrySet().iterator();
while(entryIterator.hasNext()){
Map.Entry<String,Integer> stringIntegerEntry= entryIterator.next();
System.out.println(stringIntegerEntry.getKey()+","+stringIntegerEntry.getValue());
}
//通过键找值遍历，这种方式的效率比较低。
for(String s : hashMap1.keySet()){
System.out.println(hashMap1.get(s));
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
