集合
集合和数组很类似，都是一种容器，但是为什么我们学了数组还要学习集合呢？其实还是有很大差距的，我们先看一下数组和集合的不同点
区别：
集合和数组的不同点：
1、数组的长度是不可变的，集合是可以改变
2、数组可以存放同一种基本数据类型或者引用数据类型
而集合只能存放引用数据类型，并且集合中可以存放不同的引用数据类型
我们虽然说了集合可以存放不同的引用数据类型，确实也可以这么做，但是，开发中
一个集合存放一种数据类型。）引入：
集合可以存放各种各样的数据，每种数据的长度，大小以及自身的特点都不一样。
所以，java提供的集合也应该不能够是单一的，我们要针对不同的需求，java提供不同的集合类。
这么多不同的集合，它们的底层数据结构也是不同的，不同并不重要，我们只要知道集合是可以用来
存放东西的，不光可以存放，而且可以去使用这些东西，比如：查找获取，判断等等。我们先来介绍一下Collection
collection
1、添加功能
boolean add(Object obj) 确保此集合包含指定的元素（可选操作）。
boolean addAll(Collection c)
将指定集合中的所有元素添加到此集合（可选操作）。
2、删除功能
boolean remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素（可选操作）。
void clear()
从此集合中删除所有元素（可选操作）。
3、获取功能
Iterator<E> iterator() 返回此集合中的元素的迭代器。
4、判断功能
boolean contains(Object o)
如果此集合包含指定的元素，则返回 true 。
boolean containsAll(Collection<?> c)
如果此集合包含指定 集合中的所有元素，则返回true。
boolean isEmpty()
如果此集合不包含元素，则返回 true 。
5、获取长度功能
int size()
返回此集合中的元素数。
6、求交集功能
boolean retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素（可选操作）。
7、将集合转换成数组
Object[] toArray()
返回一个包含此集合中所有元素的数组。上代码演示：
public class CollectionDemo1{
public static void main(String[] args){
//通过子类创建对象
Collection cl = new ArrayList();
//先看添加数据add
cl.add("asd");
cl.add(20);
cl.add(20.21);
cl.add(true);
System.out.println("集合中的元素："+s l);
//删除功能
//这里为了下面的代码继续演示，代码
//将其注释，会发现全部的数据都已经被清除掉了。
//cl.clear();
//System.out.println(cl);
//boolean remove()
//从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
//只移除一个符合条件的
cl.remove(20);
System.out.println("清除后的数据"+cl);
//是否包含某个元素
//boolean contains(Object o)
System.out.println(cl.comtains(true));
//判断是否为空isEmpty
System.out.println(cl.isEmpty());
//获取集合的长度功能 int size()
System.out.println(c.size);
//String toString()
//返回此集合的字符串表示形式，AbstractCollection类中的toString()方法
/**
* java.lang.Object
* java.util.AbstractCollection<E>
* java.util.AbstractList<E>
* java.util.ArrayList<E>
*/
System.out.println("集合c: " + c);
}
}这里的一些基本的使用方法就说完了，我们下面看看在基本操作后面加了All有什么区别
boolean addAll(Collection c)--可以把某个集合
添加到另一个集合中去
boolean removeAll(Collection c)--删除指定集合
中包含的所有的元素
boolean containsAll(Collection c)--如果此集合
包含指定 集合中的所有元素，则返回true。
boolean retainAll(Collection c)--c1对c2做交集，
最终的结果保存在c1中，c2不变public class CollectionDemo2{
public static void main(String[] args){
//创建一个集合对象
Collection cl1 = new ArrayLinst();
//向集合中添加元素
cl1.add("hello");
cl1.add("world");
cl1.add("java");
cl1.add("hadoop");
cl1.add("hive");
// cl1.add("spark");
//定义另一个集合
Collection cl2 = new ArrayList();
cl2.add("hello");
cl2.add("world");
cl2.add("hive");
cl2.add("spark");
System.out.println("cl1: "+cl1);
System.out.println("cl2: "+cl2);
System.out.println("===============================");
//1.addAll功能：
//将cl2添加到cl1中
System.out.println("将c2添加到从c1中：");
System.out.println(cl1.addAll(cl2));
System.out.println("cl1: "+cl1);
System.out.println("cl2: "+cl2);
// System.out.println("===============================");
//boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
// 此调用返回后，此集合将不包含与指定集合相同的元素。
// System.out.println(c1.removeAll(c2));
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
// System.out.println("===============================");
// //boolean containsAll(Collection c)如果此集合包含指定 集合中的所有元素，则返回true。
// System.out.println(c1.containsAll(c2));
System.out.println("===============================");
//boolean retainAll(Collection c)
//仅保留此集合中包含在指定集合中的元素（可选操作）。
// 换句话说，从该集合中删除所有不包含在指定集合中的元素。
//假设有两个集合 c1,c2
//c1对c2做交集，最终的结果保存在c1中，c2不变
//并且c1中删除与c2不是共同的其他元素
// System.out.println(c1.retainAll(c2));
// System.out.println("c1: "+c1);
// System.out.println("c2: "+c2);
}
}继续来看比较重要的一点，集合的遍历
集合的遍历
一共来说三种方法
1.把集合转换成数组进行数组的遍历
上代码：
public class CollectonDemo3{
public static void main(String[] args){
//创建集合对象
Collection cl = ArrayList();
//添加元素
cl.add("sdfejif");
cl.add("29");
cl.add("21.23");
cl.add("10");
//cl.add(19);
//将集合转换成数组
Object[] array = al.toArrtay();
//遍历数组中的每一个元素
for(int i = 0;i< array.length;i++){
System.out.println(array[i]);
//因为获取到的元素类型是Object类型
//所有没有length()方法
//要想调用字符串的方法，就必须要进行向下转型
//System.out.println(arr[i].length());
String s = (String)array[i];
System.out.println(s+"，长度为："+s.length());
}
}
}
这种方法我们并不建议。我们用上面这个方法来写个案例：
public class Demo{
public static void main(String[] args){
//创建几个
Collection sl = new ArrayList();
//创建学生对象
Student s1 = new Student("ss1"+18);
Student s2 = new Student("ss2"+19);
Student s3 = new Student("ss3"+20);
sl.add(s1);
sl.add(s2);
sl.add(s3);
//把集合对象转成数组
Object[] array = sl.toArray();
//遍历数组
for(int i = 0;i < array.length; i++){
//向下转型
Student s = (Student)array[i];
System.out.println(s.getname()+ "--"+ s.getAge());
}
}
}迭代器，集合专用的遍历模式
- boolean hasNext()–如果迭代具有更多元素，则返回 true 。
- Object next()–迭代器中的下一个元素
public class CollectionDemo5{
public static void main(String[] args){
//创建集合对象
Collection c1 = new ArrayList();
//添加元素
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
Interator it = cl.interator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}增强for循环
public class CollectionDemo5{
public static void main(String[] args){
//创建集合对象
Collection c1 = new ArrayList();
//添加元素
c1.add("hello");
c1.add("world");
c1.add("java");
c1.add("hadoop");
//增强for
for(Object o : cl){
System.out.println(o+",");
}
}
}案例：遍历学生对象
public class CollectionDemo7 {
public static void main(String[] args) {
//创建学生集合对象
Collection c1 = new ArrayList();
//创建学生对象
Student s1 = new Student("张咪", 16);
Student s2 = new Student("张梦云", 17);
Student s3 = new Student("刘梦云", 18);
Student s4 = new Student("贝贝", 20);
Student s5 = new Student("姜水旺", 21);
//将学生对象添加到集合中
c1.add(s1);
c1.add(s2);
c1.add(s3);
c1.add(s4);
c1.add(s5);
//获取集合中的迭代器对象
Interator it = c1.interator();
while(it.hasNext){
//如果直接这样输出，会把s1作为整个对象进行输出，不是我们想要的效果
//System.out.println(it.next);
Object next = interator.next();
//向下转型
Student s = (Student)next;
System.out.println(s.getName() + "---" + s.getAge());
}
}
}Collection 的字接口List
有序集合（有序指的是存储和取出的顺序一致）
允许有重复的元素
public class DemoList{
public static void main(String[] args){
//创建List的集合对象，使用接口多态的形式创建
List list = new ArrayList();
//添加数据
list.add("hello");
list.add("spark");
list.add("java");
list.add("bigdata");
Interator it = list.interator();
while(interator.hasNext){
Object hn = it.next();
//向下转型
String s = (String)hn;
System.out.println(s+",长度为"+s.length());
}
}
}List的 基本功能
List相关集合特有的功能
因为List集合拥有下标索引，所以根据这个下标索引衍生出特有方法
添加功能：
void add(int index,Object element)
将指定的元素插入此列表中的指定位置（可选操作）。
删除功能：
Object remove(int index)
删除该列表中指定位置的元素（可选操作）。
获取功能：
Object get(int index)
返回此列表中指定位置的元素。
修改功能：
Object set(int index,Object element)
用指定的元素（可选操作）替换此列表中指定位置的元素。
List特有迭代器：
ListIterator<E> listIterator()
返回列表中的列表迭代器（按适当的顺序）。public calss DemoList2{
public static void main(String[] args){
//创建集合对象
List list = new ArrayList;
//添加数据
list.add("hello");
list.add("world");
list.add("java");
list.add("hadoop");
System.out.println(list);
System.out.println("===============================");
//void add(int index,Object element)
//将指定的元素插入此列表中的指定位置（可选操作）。
//如果指数超出范围（ index < 0 || index > size() ）
list.add(0, "hive");
System.out.println(list);
list.add(5, "spark");
System.out.println(list);
//IndexOutOfBoundsException: Index: 7, Size: 6
// list.add(7, "flink");
// System.out.println(list);
System.out.println("********************************");
//Object remove(int index)
//删除该列表中指定位置的元素（可选操作）。
//返回被删除的元素，类型为Object类型
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
System.out.println("******************************");
//Object get(int index)
//返回此列表中指定位置的元素。
//不改变原集合中的元素
Object obj2 = list.get(3);
System.out.println(obj2);
System.out.println(list);
System.out.println("******************************");
//Object set(int index,Object element)
//用指定的元素（可选操作）替换此列表中指定位置的元素。
//返回的是指定位置被替换的元素
Object obj3 = list.set(3, "flink");
System.out.println(obj3);
System.out.println(list);
System.out.println("******************************");
//获取迭代器对象
Iterator iterator = list.iterator();
while(iterator.hasNext()){
String s = (String)iterator.next();
System.out.println(s + ",长度为：" + s.length());
}
}
}遍历
List集合特有的遍历方式：
size()方法和get()方法的结合使用public class ListDemo3 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//向集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
//用size()方法
for(int i = 0;i < list.size();i++){
Object boj = list.get(i);
String s = (String) obj;
System.out.println(s + ",长度为：" + s.length());
}
}
}案例：
import java.util.ArrayList;
import java.util.List;
/*
List集合存储学生对象，使用size()和get()方法遍历
*/
public class ListDemo4 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//创建学生对象
Student s1 = new Student("王力宏", 45);
Student s2 = new Student("李元浩", 22);
Student s3 = new Student("智勋", 24);
Student s4 = new Student("呆妹", 22);
Student s5 = new Student("乌兹", 21);
//将学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
//使用size()和get()方法遍历
for (int i = 0; i < list.size(); i++) {
Student student = (Student) list.get(i);
System.out.println(student.getName() + "---" + student.getAge());
}
}
}list独有的迭代器
List集合特有的迭代器：
ListIterator extends Iterator
由于继承自Iterator接口，所以内部一定也有hasNext()方法和next()方法
Object previous()返回列表中的上一个元素，并向后移动光标位置。
可以反复调用此方法以向后方遍历列表，或者与调用next()进行混合来回。
（请注意，对next和previous交替调用将next返回相同的元素。）
1、该方法是倒着遍历迭代器
2、该方法的获取元素指针与next()获取元素指针是同一个
boolean hasPrevious()返回true如果遍历反向列表，列表迭代器有多个元素。
（换句话说，如果previous()将返回一个元素而不是抛出异常，则返回true ）。
注意：
要想倒着遍历，必须先正着遍历一遍。在开发中很少使用，面试中经常遇到。public class ListIteratorDemo1 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("hadoop");
ListIterator listIterator = list.listIterator();
// while (listIterator.hasPrevious()) {
// Object previous = listIterator.previous();
// String s = (String) previous;
// System.out.println(s + ",长度为：" + s.length());
// }
//NoSuchElementException
//迭代器一开始的时候指针在第一个位置之前
// Object previous = listIterator.previous();
// String s = (String) previous;
// System.out.println(s + ",长度为：" + s.length());
//先将指针移动到最后一个元素的位置后面
//先正着遍历一遍
System.out.println("正着遍历：");
while (listIterator.hasNext()){
Object next = listIterator.next();
String s = (String) next;
System.out.println(s + ",长度为：" + s.length());
}
System.out.println("************************************");
System.out.println("倒着遍历：");
//然后在倒着遍历
while (listIterator.hasPrevious()){
Object previous = listIterator.previous();
String s = (String) previous;
System.out.println(s + ",长度为：" + s.length());
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
