目录
集合的概念
当我们需要保存一组类型相同的数据时，我们想到的是数组，但数组的缺点是一旦长度确认就无法改变。而集合解决了这一问题
集合是一种存储相同数据且长度可自行改变的一种容器。
集合API
集合体系概述：
Java
的集合框架是由很多接口、抽象类、具体类组成的，都位于
java.util
包中
如图所示：Map,Collection,List,Set 都为接口（其中List和Set都继承Collection）,Arraylist,Hashlist
Vector,HashSet,TreeSet,TreeMap,HashMap 都为实现类。
下面我们一一列举说明：
List接口及实现类：
List继承了Collection接口,有三个实现的类：
1. ArrayList 数组列表，数据采用数组方式存储。
2.LinkedList 链表
3.Vector 数组列表，添加同步锁,线程安全的
ArrayList:
ArrayList实现了长度可变的数组在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
定义一个ArrayList用来演示
public static void main(String[] args) {
ArrayList<String> l = new ArrayList<>();
}ArrayList的常用方法：
add(int index, E element) 在指定位置添加指定元素
public static void main(String[] args) {
List<String> l = new ArrayList<>();
l.add(0,"王");
l.add("小");
l.add(1,"白");
System.out.println(l);
}
get(int index) 获得指定位置的元素
public static void main(String[] args) {
List<String> l = new ArrayList<>();
l.add(0,"王");
l.add("小");
l.add(1,"白");
l.add("XX");
System.out.println(l.get(3));//获得第三个位置上的元素
}
remove(int index) 删除并返回指定位置元素
System.out.println(l.remove(3));//删除返回第三个元素
System.out.println(l);
removeRange
(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用)
indexOf(Object o) 从头开始遍历链表当指定元素在列表中不存在，或者是如果列表为空。返回值为-1
lastIndexOf(Object o) 从尾部开始遍历链表当指定元素在列表中不存在，或者是如果列表为空。返回值为-1
LinkedList:
LinkedList的常用方法:
定义一个Linkedlist 插入数据用来演示：
public static void main(String[] args) {
LinkedList<String> l = new LinkedList<>();
l.add(0, "王");
l.add("小");
l.add(1, "白");
l.add("XX");
}add(int index,Object element) 在链表指定位置插入指定类型的元素。
addFirist(Object element) 将指定元素插入链表的第一位。
addLast(Object element) 将指定元素插入链表的最后一位。
l.addFirst("第一位");
l.addLast("最后一位");
System.out.println(l);
get(int index) 获得指定位置的元素
System.out.println(l.get(0));
removeFirst() 删除并返回链表第一个元素。
removeLast() 删除并返回链表最后一个元素。
System.out.println(l.removeFirst()+" "+l.removeLast());
System.out.println(l);
remove(int index) 删除并返回指定位置元素。
System.out.println(l.remove(0));
System.out.println(l);
getFirst() 获得链表第一个位置的元素。
getLast() 获得链表最后一个位置的元素。
System.out.println(l.getFirst()+" "+l.getLast());
List接口集合迭代：
List迭代有三钟方法：1.for循环遍历 2.增强for循环的遍历 3.迭代器遍历（Iterato)
1.for循环遍历List
public static void main(String[] args) {
LinkedList<String> l = new LinkedList<>();
l.add(0, "王");
l.add("小");
l.add(1, "白");
l.add("XX");
for (int i = 0; i <l.size() ; i++) {
System.out.println(l.get(i));
}
}
2.增强for循环遍历
增强for循环结构 ：for(数据类型 数据名称;遍历目标){ }
public static void main(String[] args) {
LinkedList<String> l = new LinkedList<>();
l.add(0, "王");
l.add("小");
l.add(1, "白");
l.add("XX");
for (String i : l) {
System.out.println(i);
}
}
3.迭代器遍历（Iterato)
public static void main(String[] args) {
ArrayList<String> l = new ArrayList<>();
l.add(0, "王");
l.add("小");
l.add(1, "白");
l.add("XX");
Iterator<String> it = l.iterator();
while (it.hasNext())
{
System.out.println(it.next()+" ");
}
}
Set 接口:
Set接口继承了Collection接口。Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
Set接口有两个实现类:
HashSet:
HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。
底层数据结构是哈希表+链表 哈希表依赖于哈希值存储
TreeSet:
可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)
Set 接口集合迭代:
public static void main(String[] args) {
Set<String> l = new HashSet<>();
l.add("李");
l.add("小");
l.add("黑");
Iterator<String> it = l.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}因为Set存储数据时是无序的 所以迭代输出时不一定和添加数据的顺序一样。
Map 接口：
Map将键映射到值的对象 一个映射不能包含重复的键 但不同的键可以有重复的值 每个键最多只能映射到一个值。
Map有三个实现类：
1.HashMap
HashMap中元素的key值不能重复， 排列顺序是不固定的,可以存储一个 为null的键。
2.TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序 的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
3.HashTable
实现了同步。 不能存储为null的键
Map集合遍历：
方式1：根据键找值
获取所有键的集合 遍历键的集合，获取到每一个键 根据键找值
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "张三");
map.put(2, "李四");
map.put(3, "王五");
Set<Integer> keySet = map.keySet(); // 获取map所有的key成新的集合
System.out.println(keySet); // [1, 2, 3]
Iterator<Integer> iterator = keySet.iterator(); // 对key的集合生成迭代器
while(iterator.hasNext()){ // 迭代器循环
Integer key = iterator.next(); // 获取迭代器下一个值（key）
String value = map.get(key); // 获取迭代器下一个值对用的值（value）
System.out.println("key:"+key+",value:"+value);
}
方式2：根据键值对对象找键和值
获取所有键值对对象的集合 遍历键值对对象的集合，获取到每一个键值对对象 根据键值对对象找键和值
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "张三");
map.put(2, "李四");
map.put(3, "王五");
Set<Entry<Integer,String>> entrySet = map.entrySet(); // 获取（key,value）集合
System.out.println(entrySet); // [1=张三, 2=李四, 3=王五]
for(Entry<Integer,String> a : entrySet){ // 遍历
System.out.println("key:"+a.getKey()+",value:"+a.getValue());
}Collections（集合处理的工具类）
1.什么是Collections？
此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合。
2.其主要方法如下：
addAll(Collection<? super T> c, T… elements) 将所有指定的元素添加到指定的集合。
binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二叉搜索算法搜索指定对象的指定列表。
copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表中。
emptyList() 返回空列表（immutable）。
fill(List<? super T> list, T obj) 用指定的元素代替指定列表的所有元素。
max(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最大元素。
min(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最小元素。
replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
reverse(List<?> list) 反转指定列表中元素的顺序。
sort(List list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
swap(List<?> list, int i, int j) 交换指定列表中指定位置的元素。
package collectionsDemo;
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args) {
ArrayList<String> alist = new ArrayList<>();
alist.add("a");
alist.add("b");
alist.add("c");
Collections.addAll(alist,"d","e","f");//addAll(Collection<? super T> c, T... elements)将所有指定的元素添加到指定的集合。
System.out.println(alist);
ArrayList<Integer> alist1 = new ArrayList<>();
alist1.add(1);
alist1.add(3);
alist1.add(2);
alist1.add(7);
alist1.add(4);
alist1.add(2);
// Collections.sort(alist1);
// Collections.sort(alist1, new Comparator<Integer>() {//可自定义排序
// @Override
// public int compare(Integer o1, Integer o2) {
// return o1-o2;
// }
// });
Collections.sort(alist1,((o1, o2) -> {return o2-o1;}));//Lambda表达式
System.out.println(alist1);
System.out.println(Collections.binarySearch(alist1,1));//binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
// 使用二叉搜索算法搜索指定对象的指定列表。
Collections.swap(alist1,0,2);//交换指定列表中指定位置的元素
System.out.println(alist1);
ArrayList<Integer> alist2 = new ArrayList<>();
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
alist2.add(0);
Collections.copy(alist2,alist1);//copy(List<? super T> dest, List<? extends T> src)
// 将所有元素从一个列表复制到另一个列表中。
System.out.println(alist2);
System.out.println(Collections.max(alist1));
System.out.println(Collections.min(alist1));
Collections.replaceAll(alist2,0,1);//将旧集合中的某一元素替换为新元素
System.out.println(alist2);
Collections.reverse(alist2);//翻转集合中元素
System.out.println(alist2);
List<Integer> alist3 = new ArrayList<>();
alist3=Collections.emptyList();//返回一个不能更改的集合；
System.out.println(alist3);
}
}
运行结果：
[a, b, c, d, e, f]
[7, 4, 3, 2, 2, 1]
-1
[3, 4, 7, 2, 2, 1]
[3, 4, 7, 2, 2, 1, 0, 0, 0]
7
1
[3, 4, 7, 2, 2, 1, 1, 1, 1]
[1, 1, 1, 1, 2, 2, 7, 4, 3]
[]
扫一扫
6122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
