一、概述与集合的体系结构
1.概述
集合是能够存储多个数据且长度可变的容器；集合能够存储引用数据类型，如果要存储基本数据类型，则必须要存储基本数据类型对应的包装类！
与数组的对比：
数组的长度不可变；
数组能够存储基本数据类型和引用数据类型。
2.集合的体系结构
二、Collection
1.概述
Collection集合是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素；
JDK 不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现。
一般使用多态的方式创建Collection集合的对象，具体实现类ArrayList。
2.常用的成员方法
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean addAll(Collection<? extends E> c) | 将指定集合中的所有元素添加到此集合（可选操作） |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| boolean removeIf(Object o) | 根据条件进行移除 |
| boolean removeAll(Collection<?> c) | 删除指定集合中包含的所有此集合的元素 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
| boolean retainAll(Collection<?> c) | retainAll仅保留此集合中包含在指定集合中的元素（可选操作）---求交集 |
| int size() | 集合的长度，也就是集合中元素的个数 |
2.1代码演示
package CollectionStudy1;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
//多态方式创建Collection对象
Collection<String> col = new ArrayList<>(); //编译看左边，运行看右边。
//boolean add(E e)---添加元素
col.add("aaa");
col.add("bbb");
col.add("ccc");
col.add("hello");
System.out.println(col);
System.out.println("----------------");
//boolean remove(Object o)---从集合中移除指定的元素
boolean result1 = col.remove("ccc");
boolean result2 = col.remove("abc"); //如果指定的元素在集合中不存在，则返回false，删除失败，但程序不会报错。
System.out.println(result1);
System.out.println(result2);
System.out.println(col);
System.out.println("----------------");
//boolean removeIf(Object o)---根据条件进行移除
boolean result3 = col.removeIf((String str)->{ //根据该方法的特有条件（接口且仅有一个抽象方法-函数思想）可使用Lambda表达式。
return str.length()==3; //集合内字符串长度为3则删除
});
System.out.println(result3);
System.out.println(col);
System.out.println("----------------");
//boolean contains(Object o)---判断集合中是否存在指定的元素
boolean result4 = col.contains("hello");
boolean result5 = col.contains("Hello");
System.out.println(result4);
System.out.println(result5);
System.out.println("----------------");
//boolean isEmpty()---判断集合是否为空
boolean result6 = col.isEmpty();
System.out.println(result6);
System.out.println("---------------- ");
//int size()---集合的长度-也就是集合中元素的个数
System.out.println(col.size()); //由于上面通过removeIf删除了三个元素，所以只剩1个元素。
System.out.println("---------------- ");
//void clear()---清空集合中的元素
col.clear();
System.out.println(col);
}
}
3. 集合迭代器
3.1迭代器介绍---Iterator
（1）迭代器是集合的专用遍历方式
（2）Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
（3）Iterator中的常用方法
boolean hasNext(): 判断当前位置是否有元素可以被取出
E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置。
void remove(): 删除迭代器对象当前指向的元素
（4）集合遍历的代码演示
package CollectionStudy1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo2 {
public static void main(String[] args) {
Collection col = new ArrayList<>();
col.add("aaa");
col.add("bbb");
col.add("ccc");
//返回迭代器对象，迭代器对象指向集合元素的索引0位置（"aaa"）。
Iterator<String> iterator = col.iterator();
//boolean hasNext()---判断当前位置是否有元素可以被取出
System.out.println(iterator.hasNext());
//E next()---获取当前位置的元素，将迭代器对象移向下一个索引位置（"bbb"）。
String next = iterator.next();
System.out.println(next);
System.out.println("-----------");
//可通过循环来遍历集合
while (iterator.hasNext()){ //在上面的代码中，已经获取了0索引位置的元素（"aaa"），此时迭代器对象指向1索引位置（"bbb"）
String result = iterator.next();
System.out.print(result+" ");
}
}
}
3.2ListIterator
3.2.1概述
ListIterator接口是Iterator接口的子接口，在Iterator正向迭代的基础上扩展了逆向迭代的操作。简单来说，就是反向遍历集合。
3.2.2ListIterator接口的常用方法
| 方法名 | 说明 |
|---|---|
| boolean hasPrevious() | 判断当前位置是否有元素。 |
| E previous() | 返回列表中的前一个元素，并向前移动光标位置。 |
| int previousIndex() | 返回由后续调用previous()返回的元素的索引。 |
3.2.3代码演示
package CollectionStudy2;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo6 {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//ListIterator提供了逆向迭代
ListIterator lit = list.listIterator();
System.out.println(lit.hasPrevious()); //指向第一个元素的左侧,没有前一个元素，返回false。
while (lit.hasNext()){
System.out.println(lit.nextIndex()+":"+lit.next());
}
System.out.println("-----");
System.out.println(lit.hasPrevious()); //此时指向了最后一个元素的右侧，有前一个元素，返回true。
while (lit.hasPrevious()){
System.out.println(lit.previousIndex()+":"+lit.previous());
}
}
}
4.List集合
4.1概述
（1）有序集合，这里的有序指的是存取顺序。
（2）用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
（3）与Set集合不同，列表通常允许重复的元素。
简单总结：存取有序、可以重复、有索引
4.2List集合特点的代码演示
package CollectionStudy2;
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//存取有序
list.add("a");
list.add("a"); //可以重复
list.add("b");
list.add("c");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i)); //有索引
}
}
}
4.3List集合的特有方法
| 方法名 | 描述 |
|---|---|
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| boolean addAll(int index, Collection<? extends E> c) | 将指定集合中的所有元素插入到此列表中的指定位置（可选操作） |
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
| int indexOf(Object o) | 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。 |
| int lastIndexOf(Object o) | 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 |
| List<E> subList(int fromIndex, int toIndex) | 返回此类表中指定的fromIndex和toIndex之间的视图（元素集合） [fromIndex, toIndex) |
4.4代码演示
package CollectionStudy2;
import java.util.ArrayList;
import java.util.List;
public class ListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//void add(int index,E element)---在此集合中的指定位置插入指定的元素
list.add(0,"1");
System.out.println(list); //新增了一个元素"1"
System.out.println("----------------");
list.add(4,"d"); //注意：最多只能在"c"（索引3）的下方（索引4）再插入一个元素，超出长度5的范围则会抛出异常。
System.out.println(list);
System.out.println("----------------");
//E remove(int index)---删除指定索引处的元素，返回被删除的元素。 注意：使用此方法（包括下面的方法），索引不能超出范围。
String remove = list.remove(0); //此时将第一个元素"1"删除了
System.out.println(remove);
System.out.println(list);
System.out.println("----------------");
//E set(int index,E element)---修改指定索引处的元素，返回被修改的元素。
String e = list.set(3, "e"); //注意：返回的是被修改的元素。
System.out.println(e);
System.out.println(list);
System.out.println("----------------");
//E get(int index)---返回指定索引处的元素
String s = list.get(3);
System.out.println(s);
System.out.println(list);
}
}
5.LinkedList集合
5.1概述
LinkedList集合是List集合的子类；
底层的数据结构是双向链表，元素有序、可重复；
LinkedList在实现数据的添加和删除效率高，查询和修改效率低，顺序访问会非常高效，而随机访问效率会比较低；
LinkedList实现了List接口，支持使用索引访问元素；
LinkedList是线程不安全的，效率高。
5.2特有方法
| 方法名 | 说明 |
|---|---|
| public void addFirst(E e) | 在该列表开头插入指定的元素 |
| public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元素 |
| public E getLast() | 返回此列表中的最后一个元素 |
| public E removeFirst() | 从此列表中删除并返回第一个元素 |
| public E removeLast() | 从此列表中删除并返回最后一个元素 |
5.3代码演示
package CollectionStudy2;
import java.util.LinkedList;
public class ListDemo3 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("b");
list.add("c");
//public void addFirst(E e)---在该列表开头插入指定的元素
list.addFirst("a");
System.out.println(list);
System.out.println("-------------");
//public void addLast(E e)---将指定的元素追加到此列表的末尾
list.addLast("d");
System.out.println(list);
System.out.println("-------------");
//public E getFirst()---返回此列表中的第一个元素
String first = list.getFirst();
System.out.println(first);
System.out.println(list);
System.out.println("-------------");
//public E getLast()---返回此列表中的最后一个元素
String last = list.getLast();
System.out.println(last);
System.out.println(list);
System.out.println("-------------");
//public E removeFirst()---从此列表中删除并返回第一个元素(删除的那个元素)
String s1 = list.removeFirst();
System.out.println(s1);
System.out.println(list);
System.out.println("-------------");
//public E removeLast()---从此列表中删除并返回最后一个元素(删除的那个元素)
String s2 = list.removeLast();
System.out.println(s2);
System.out.println(list);
}
}
6.ArrayList
6.1概述
ArrayList是List集合的子类，ArrayList中常用的方法全部来自于父类Collection、List、Object。创建ArrayList，集合的默认初始长度为10，扩容因子1.5。
6.2特点
底层的数据结构是数组
能够存储null值
线程不安全，效率高。
底层是数组结构，那么就意味着查询和修改的效率高，而增加和删除的效率低。
有索引，能够方便的检索
元素是可以重复的，我们可以自己通过选择排序法去掉重复内容。
存取有序
可排序。
7.增强for循环
7.1概述
它是JDK5之后出现的,其内部原理是一个Iterator迭代器，需要实现Iterable接口的类才可以使用迭代器和增强for，增强for循环可用来遍历Collection集合 。
7.2格式
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
7.3代码演示
package CollectionStudy1;
import java.util.ArrayList;
public class CollectionDemo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
//增强for 快捷方式---集合名/数组名.for
for(String s:list){ //String---集合中的数据类型 s---临时变量名，指的是循环遍历中的每一个元素。
System.out.println(s); //临时变量s---当前这一次循环遍历的元素。
}
}
}
7.4注意事项
使用增强for不能修改集合或数组中的元素，因为在增强for循环中仅仅是修改了临时变量，并没有改变数组中的元素。
package CollectionStudy1;
import java.util.ArrayList;
public class CollectionDemo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
System.out.println(list+" ");
System.out.println("---------");
for(String s:list){
s = "m"; //注意：s仅仅只是一个临时变量，它无法改变集合中的内容，最终遍历后的内容还是原集合内容。
}
System.out.println(list+" ");
}
}
说明：以上内容是集合框架知识点的一部分，有些细节我放在了代码的注释中。本次的内容并不全面。当然，欢迎各位的补充与指正。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
