区别:
Collection接口:单列存储。数据可以重复存储。
|
List接口 (线性表): 数据可以重复存储,有顺序的,线性排列。
|
public static void main(String[] args) {
// 集合的容器
Collection arr = new ArrayList();
// 是空的
System.out.println(arr.isEmpty());// true
// 向集合中添加数据
arr.add("aa");
arr.add("bb");
arr.add("cc");
System.out.println(arr);// [aa, bb, cc]
1. 判断集合是否为 空 ,为空 true
System.out.println(arr.isEmpty());// false
2. 集合中存储的元素的个数
System.out.println(arr.size());// 3
// 3.
Collection c1 = new ArrayList<>();
c1.add("ee");
c1.add("ff");
// 把 参数集合中的所有元素添加到当前集合中,只要当前集合发生了改变 true
arr.addAll(c1);
System.out.println(arr);// [aa, bb, cc, ee, ff]
// 4. 把参数元素 从当前集合中 删除掉,只要当前集合发生了改变 true
arr.remove("cc");
System.out.println(arr);// [aa, bb, ee, ff]
// 5. 把参数集合中的所有元素从当前集合中删除掉,只要当前集合发生了改变 true
arr.removeAll(c1);
System.out.println(arr);// [aa, bb]
// 6. 参数元素 在当前集合中是否存在,存在 true
System.out.println(arr.contains("aa"));// true
// 7. 参数集合中的所有元素在当前集合中是否存在,存在 true
System.out.println(arr.containsAll(c1));// false
// 8. 把集合 元素 转换 成 一个 新的数组对象
Object [] obj = arr.toArray();
System.out.println(Arrays.toString(obj));// [aa, bb]
Object [] objs = new Object[0];
// obj = arr.toArray(objs);
obj = arr.toArray(new Object[0]);
System.out.println(Arrays.toString(obj));// [aa, bb]
// 保留类型
String [] strs = arr.toArray(new String[2]);
System.out.println(Arrays.toString(strs));// [aa, bb]
// 9. 清空集合
arr.clear();
System.out.println(arr.isEmpty());// true
System.out.println(arr.size());// 0
}
List:线性表
是数据结构。
有多个具有相同特性的元素 组成的序列。
顺序。
按照元素添加的顺序分配索引。索引从0 开始的。
public static void main(String[] args) {
//
List list = new ArrayList<>();
list.add("aa"); // 0
list.add("bb"); // 1
list.add("cc"); // 2
// 1. 向指定的位置添加元素
list.add(1, "hello");
System.out.println(list);// [aa, hello, bb, cc]
// 2. 获得索引位置的元素
System.out.println(list.get(0));// aa
// 3. 用第二个参数的元素 替换 索引位置的元素
list.set(1, "tom");
System.out.println(list);// [aa, tom, bb, cc]
// 4. 取子集 【起始,终止)
System.out.println(list.subList(1, 3)); // tom,bb
// 5. 排序
list.sort(new Comparator() {
@Override
public int compare(String o1, String o2) {
// 升序
return o1.compareTo(o2);
}
});// [aa, bb, cc, tom]
list.sort((s1,s2)->s2.compareTo(s1));// 降序 [tom, cc, bb, aa]
// 没有指定自定义比较器Comparator那么会进行自然升序排序(Comparable接口)
list.sort(null);
System.out.println(list); // [aa, bb, cc, tom]
}
函数式接口:
Consumer原码:
@FunctionalInterface
public interface Consumer {
void accept(T t);
}
遍历:
// 有序
List list = new ArrayList<>();
list.add("aa");
list.add("bb");
// 1. 基本for :只针对List
for(int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// 2. 增强for
for(String s : list) {
System.out.println(s);
}
// 3. 集合的forEach方法遍历
list.forEach(new Consumer() {
@Override
public void accept(String t) {
System.out.println(t);
}
});
// Lambda简化
list.forEach(s->System.out.println(s));
// 方法引用
list.forEach(System.out::println);
迭代器:
List list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
System.out.println(list);// [aa, bb, cc]
//--------------------------------------------
// 1. Iterator
Iterator i = list.iterator();
// (1) forEachRemaining
//i.forEachRemaining(System.out::println);
// (2)
while(i.hasNext()) {
System.out.println(i.next());
}
//----------ListIterator :只针对 List集合-------------------------------------
System.out.println("---------ListIterator---------------");
// 获得一个迭代器对象
ListIterator li = list.listIterator();
// 向后遍历
while(li.hasNext()) {
System.out.println(li.next());
}
// 向前遍历
while(li.hasPrevious()) {
System.out.println(li.previous());
}
List:线性表
是数据结构。
有多个具有相同特性的元素 组成的序列。
实现的技术:
public static void main(String[] args) {
/*
* 创建数组:创建了一个长度为0 的数组
* public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
*/
ArrayList list = new ArrayList<>();
/*
* 数组的初始容量为 10
* private static final int DEFAULT_CAPACITY = 10;
* 超过 10个 的扩容方式:
* int newCapacity = oldCapacity + (oldCapacity >> 1);
* 扩容的最大值 :Integer.MAX_VALUE
* return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
*/
list.add("aa");
}
由 非连续的 元素 组成 的 存储结构。
存数据 Node
分类:
(1) 单向链表
单向非循环链表
单向循环链表
Node代码:
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
List 实现类:
ArrayList : 线程非安全的。
Vector -> Stack : 线程安全的。(不去使用)
LinkedList:链表