Java中的集合就像一个容器，专门用来存储Java对象（实际上是对象的引用，但习惯上称为对象）
集合按照其存储结构可以分为两大类，即单列集合Collection和双列集合Map
Collection：单列集合的根接口，用于存储一系列符合某种规则的元素。
Collection集合有两个重要的子接口，分别是List和Set。
List集合的特点是元素有序、可重复；
Set集合的特点是元素无序并且不可重复。
List接口的主要实现类有ArrayList和LinkedList，Vector，
Set接口的主要实现类有HashSet和TreeSet，LinkedHashSet继承HashSet。
Collection接口的主要方法
方法声明 功能描述
boolean add(Object o) 向集合中添加一个元素
boolean addAll(Collection c) 将指定集合c中的所有元素添加到该集合中
void clear() 删除该集合中的所有元素
boolean remove(Object o) 删除该集合中指定的元素
boolean removeAll(Collection c) 删除该集合中包含指定集合c中的所有元素
boolean isEmpty() 判断该集合是否为空
boolean contains(Object o) 判断该集合中是否包含某个元素
boolean containsAll(Collection c) 判断该集合中是否包含指定集合c中的所有元素
Iterator iterator() 返回在该集合的元素上进行迭代的迭代器（Iterator），用于遍历该集合所有元素
int size() 获取该集合元素个数
Stream<E> stream() 将集合源转换为有序元素的流对象（JDK 8新方法）
List接口： List集合常用方法
方法声明 功能描述
void add(int index,Object element) 将元素element插入在List集合的指定索引位置
boolean addAll(int index,Collection c) 将集合c包含的所有元素插入到List集合的指定索引位置
Object get(int index) 返回集合索引index处的元素
Object remove(int index) 删除index索引处的元素
Object set(int index, Object element) 将索引index处元素替换成element元素，并将替换后的元素返回
int indexOf(Object o) 返回对象o在List集合中首次出现的位置索引
int lastIndexOf(Object o) 返回对象o在List集合中最后一次出现的位置索引
List subList(int fromIndex, int toIndex) 返回从索引fromIndex（包括）到 toIndex（不包括）处所有元素集合组成的子集合
Object[] toArray() 将集合元素转换为数组
default void sort(Comparator<? super E> c) 根据指定的比较器规则对集合元素排序（JDK 8新方法）
（1）ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
（2）LinkedList： 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
（3）Vector：底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素
ArrayList：在ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。
正是由于ArrayList内部的数据存储结构是数组形式，在增加或删除指定位置的元素时，会创建新的数组，效率比较低，因此不适合做大量的增删操作。但是，这种数组结构允许程序通过索引的方式来访问元素，因此使用ArrayList集合在遍历和查找元素时显得非常高效。
// 创建ArrayList集合
ArrayList list = new ArrayList();
// 向集合中添加元素
list.add("stu1");
list.add("stu2");
System.out.println("第2个元素是：" + list.get(1));
List<String> list2 = new ArrayList<>();
list2.add("abc");
list2.add("dc");
list2.add("bade");
System.out.println(list2);
LinkedList集合内部包含有两个Node类型的first和last属性维护一个双向循环链表，在链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，从而可以将所有的元素彼此连接起来。
对于元素的增删操作表现出很高的效率
LinkedList中的特有方法
方法声明 功能描述
void add(int index, E element) 在此列表中指定的位置插入指定的元素。
void addFirst(Object o) 将指定元素插入集合的开头
void addLast(Object o) 将指定元素添加到集合的结尾
Object getFirst() 返回集合的第一个元素
Object getLast() 返回集合的最后一个元素
Object removeFirst() 移除并返回集合的第一个元素
Object removeLast() 移除并返回集合的最后一个元素
boolean offer(Object o) 将指定元素添加到集合的结尾
boolean offerFirst(Object o) 将指定元素添加到集合的开头
boolean offerLast(Object o) 将指定元素添加到集合的结尾
Object peek() 获取集合的第一个元素
Object peekFirst() 获取集合的第一个元素
Object peekLast() 获取集合的最后一个元素
Object poll() 移除并返回集合的第一个元素
Object pollFirst() 移除并返回集合的第一个元素
Object pollLast() 移除并返回集合的最后一个元素
void push(Object o) 将指定元素添加到集合的开头
Object pop() 移除并返回集合的第一个元素
例：// 创建LinkedList集合
LinkedList link = new LinkedList();
link.add("stu1");
// 创建集合对象
LinkedList<String> products = new LinkedList<String>();
Vector子类
底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素。
Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
Vector link = new Vector();
Vector<String> products = new Vector<String>();
Set集合：Set的特点就是无序，不允许保存重复元素，其也就是Collection子接口。
Set集合与List集合存取元素的方式都一样
HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。
HashSet 具有以下特点：
不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
集合元素值可以是 null。
当向HashSet集合中添加一个元素时，首先会调用该元素的hashCode()方法来确定元素的存储位置，然后再调用元素对象的equals()方法来确保该位置没有重复元素。
如果有两个元素通过 equals() 方法比较返回的结果为 true，但它们的 hashCode 不相等，HashSet 将会把它们存储在不同的位置，依然可以添加成功。
也就是说，两个对象的 hashCode 值相等且通过 equals() 方法比较返回结果为 true，则 HashSet 集合认为两个元素相等。
声明：HashSet hs = new HashSet(); // 调用无参的构造函数创建HashSet对象
HashSet<String> hss = new HashSet<String>(); // 创建泛型的 HashSet 集合对象
LinkedHashSet底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。
TreeSet集合它内部采用平衡二叉排序树来存储元素，这样的结构可以保证TreeSet集合中没有重复的元素，并且可以对元素进行排序，左子树上的元素小于它的根结点，而右子树上的元素大于它的根结点。
底层数据结构采用红黑树来实现，元素唯一且已经排好序；唯一性同样需要重写hashCode和equals()方法，二叉树结构保证了元素的有序性。TreeSet是利用Comparable接口来确认重复数据的。
TreeSet<Double> scores = new TreeSet<Double>(); // 创建 TreeSet 集合
TreeSet ts = new TreeSet();// 创建TreeSet集合
ts.add(3);// 1、向TreeSet集合中添加元素
TreeSet集合的特有方法
方法声明 功能描述
Object first() 返回TreeSet集合的首个元素
Object last() 返回TreeSet集合的最后一个元素
Object lower(Object o) 返回TreeSet集合中小于给定元素的最大元素，如果没有返回null
Object floor(Object o) 返回TreeSet集合中小于或等于给定元素的最大元素，如果没有返回null
Object higher(Object o) 返回TreeSet集合中大于给定元素的最小元素，如果没有返回null
Object ceiling(Object o) 返回TreeSet集合中大于或等于给定元素的最小元素，如果没有返回null
Object pollFirst() 移除并返回集合的第一个元素
Object pollLast() 移除并返回集合的最后一个元素
Java提供了两种TreeSet的排序规则，分别为：自然排序和定制排序。在默认情况下，TreeSet集合都是采用自然排序，
1．自然排序
自然排序要求向TreeSet集合中存储的元素所在类必须实现Comparable接口，并重写compareTo()方法，然后TreeSet集合就会对该类型元素使用compareTo()方法进行比较，并默认进行升序排序。
import java.util.TreeSet;
// 定义Teacher类实现Comparable接口
class Teacher implements Comparable {
String name;
int age;
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return name + ":" + age;
}
//重写Comparable接口的compareTo()方法
public int compareTo(Object obj){
Teacher s = (Teacher) obj;
// 定义比较方式，先比较年龄age，再比较名称name
if(this.age -s.age > 0) {
return 1;
}
if(this.age -s.age == 0) {
return this.name.compareTo(s.name);
}
return -1;
}
}
public class Example12 {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Teacher("Jack",19));
ts.add(new Teacher("Rose",18));
ts.add(new Teacher("Tom", 19));
ts.add(new Teacher("Rose",18));
System.out.println(ts);
}
}
2．定制排序，通过定制比较器实现
import java.util.Comparator;
import java.util.TreeSet;
// 定义比较器实现Comparator接口
class MyComparator implements Comparator {
public int compare(Object obj1, Object obj2) { // 定制排序方式
String s1 = (String) obj1;
String s2 = (String) obj2;
int temp = s1.length() - s2.length();
return temp;
}
}
public class Example13 {
public static void main(String[] args) {
// 1、创建集合时，传入Comparator接口实现定制排序规则
TreeSet ts = new TreeSet(new MyComparator());
ts.add("Jack");
ts.add("Helena");
ts.add("Eve");
System.out.println(ts);
// 2、创建集合时，使用Lambda表达式定制排序规则
TreeSet ts2 = new TreeSet((obj1, obj2) -> {
String s1 = (String) obj1;
String s2 = (String) obj2;
return s1.length() - s2.length();
});
ts2.add("Jack");
ts2.add("Helena");
ts2.add("Eve");
System.out.println(ts2);
}
}
遍历集合：四种方法，前两种最常用
1.Iterator迭代器 主要用于遍历（即迭代访问）Collection 集合中的元素。只允许由前向后实现输出
Iterator 接口里定义了如下 4 个方法。
boolean hasNext()：如果被迭代的集合元素还没有被遍历完，则返回 true。
Object next()：返回集合里的下一个元素。
void remove()：删除集合里上一次 next 方法返回的元素。
void forEachRemaining(Consumer action)：这是 Java 8 为 Iterator 新增的默认方法，该方法可使用 Lambda 表达式来遍历集合元素。
例： // 创建ArrayList集合
ArrayList list = new ArrayList();
// 向该集合中添加字符串
list.add("data_1");
list.add("data_2");
list.add("data_3");
// 获取Iterator对象
Iterator iterator = list.iterator();
// 判断集合中是否存在下一个元素
while (iterator.hasNext()) {
Object obj = iterator.next(); // 取出ArrayList集合中的元素
System.out.println(obj);
}
-----------
List<String> list = new ArrayList<>();
for (int i=0;i<10;i++){
list.add("list"+i);
}
//获取迭代器
Iterator<String> iter = list.iterator();
while (iter.hasNext()){
System.out.println(iter.next());
}
System.out.println("-------for------");
for (Iterator<String> iter2 = list.iterator();iter2.hasNext();){
System.out.println(iter2.next());
}
2.foreach遍历
普通：foreach循环用于遍历数组或集合中的元素，其具体语法格式如下：
for(容器中元素类型 临时变量 ：容器变量) {
// 执行语句
}
例：ArrayList list = new ArrayList();
// 使用foreach循环遍历集合
for (Object obj : list) {
System.out.println(obj); // 取出并打印集合中的元素
}
JDK 8中针对所有集合类型对象根据Lambda表达式特性还新增了一个forEach(Consumer action)方法来遍历集合
// 使用JDK 8新增的forEach(Consumer action)方法遍历集合
list.forEach(obj -> System.out.println("迭代集合元素："+obj));
//简写
list.forEach(System.out::println);
针对Iterator迭代器对象提供了一个forEachRemaining(Consumer action)方法来进行遍历
// 将集合转换为Iterator迭代器对象
Iterator it = list.iterator();
// 使用JDK 8新增的forEachRemaining(Consumer action)来遍历迭代器对象
it.forEachRemaining(obj -> System.out.println("迭代集合元素："+obj));
3.List专用ListIterator输出，进行双向迭代处理，那么就必须依靠Iterator的子接口ListIterator实现。
在ListIterator接口里面定义有如下的操作方法：
判断是否有前一个元素：public boolean hasPrevious()；
获取当前元素：public E previous()
例：List<String> list = new ArrayList<>();
//集合迭代器，向前遍历
ListIterator listIterator = list.listIterator(list.size());
System.out.println("----向前遍历----");
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
System.out.println("----向后遍历----");
while (listIterator.hasNext()){
System.out.println(listIterator.next());
}
4.Vector专用Enumeration输出
Vector<String> vs = new Vector<String>();
Enumeration<String> es=vs.elements();
while(es.hasMoreElements()){
System.out.println(es.next());
}
04-16
184
184
12-22
05-06
1027
1027
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
