集合和数组的不同点：
1、数组的长度是不可变的，集合的长度是可变的
2、数组可以存放同一种基本数据类型或者引用数据类型的元素
而集合只能存放引用数据类型，并且集合中可以存放法不同数据类型的元素
（注意：这里我虽然说了集合可以存放不同的数据类型，实际确实也可以这么做，但是在实际开发中，一个集合存放一种引用数据类型的元素）
Collection:是集合中的顶层接口，它存在由它展开而来的继承体系。
Collection:
由于Collection是一个接口，所以无法被实例化，我们要找它一个子类来进行接口多态的方式实例化，这里我们就暂时用ArrayList来举例。
1、添加功能
boolean add(Object e)确保此集合包含指定的元素（可选操作）
boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
2、删除功能
boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素（可选操作）。
void clear() 从此集合中删除所有元素（可选操作）。
3、获取功能
Iterator 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() 返回一个包含此集合中所有元素的数组。
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
Collection c = new ArrayList();
//boolean add(Object e)确保此集合包含指定的元素（可选操作）
System.out.println(c.add("hello"));
System.out.println(c.add("world"));
System.out.println(c.add("hello"));
c.add(20);
c.add(12.34);
System.out.println(c);
//void clear() 从此集合中删除所有元素（可选操作）。
// c.clear();
//boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
//删除指定的元素
//只移除一个符合条件的元素
System.out.println("从该集合中删除指定的元素："+c.remove("hello"));
//boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
//判断该集合中是否包含某个元素，如果包含，返回true
System.out.println(c.contains("hello"));
//boolean isEmpty() 如果此集合不包含元素，则返回 true 。
System.out.println(c.isEmpty());
//int size() 返回此集合中的元素数
//集合集合的长度
System.out.println("集合的长度为："+c.size());
/**
* java.lang.Object
* java.util.AbstractCollection //重写了toString()方法
* java.util.AbstractList
* java.util.ArrayList
*/
System.out.println(c); //这里调用的是AbstractCollection类中的toString()方法
}
}
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo2 {
public static void main(String[] args) {
//创建集合对象
Collection c1 = new ArrayList();
//向集合中添加元素
c1.add("hadoop");
c1.add("hive");
c1.add("spark");
//创建另一个集合对象
Collection c2 = new ArrayList();
c2.add("hello");
c2.add("world");
c2.add("java");
System.out.println("c1:" + c1);
System.out.println("c2:" + c2);
System.out.println("=========================================");
// //boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合（可选操作）
// System.out.println("将c2添加到集合c1中：");
// System.out.println(c1.addAll(c2));
// System.out.println("c1:" + c1);
// System.out.println("c2:" + c2);
// 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(c2.retainAll(c1));
System.out.println("c1:" + c1);
System.out.println("c2:" + c2);
}
}
集合的遍历：目的就是将集合中的元素依次取出来
Object[] toArray() 返回一个包含此集合中所有元素的数组。
将集合转化成数组，然后再遍历
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo3 {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//向集合中添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("hadoop");
c.add("hive");
//Object[] toArray() 返回一个包含此集合中所有元素的数组。
Object[] objects = c.toArray();
//遍历数组获取每一个元素
for (int i = 0; i < objects.length; i++) {
String s = (String) objects[i];
//需求：想要获取每一个字符串元素的长度？
System.out.println(s + "---" + s.length());
}
}
}
Iterator接口： 返回此集合中的元素的迭代器。 它是Collection集合遍历的专有方式
boolean hasNext() 判断迭代器中是否还有元素
Object next() 返回迭代器中的元素
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo5 {
public static void main(String[] args) {
//创建一个集合对象
Collection c = new ArrayList();
//向集合中添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("hadoop");
c.add("hive");
// System.out.println(c);
//获取集合c的迭代器对象
//Iterator iterator() 返回此集合中的元素的迭代器。 它是Collection集合遍历的专有方式
Iterator iterator = c.iterator(); // Iterator iterator = new Itr();接口多态
while (iterator.hasNext()) {
Object next = iterator.next();
//向下转型使用元素数据类型特有的方法
String s = (String) next;
System.out.println(s + "--长度为：" + s.length());
}
}
}
1、能否将while循环改成for循环呢？ 能，但是不推荐，在工作中推荐使用while循环
同一个迭代器只能遍历一次，多次遍历没有效果，因为遍历一次后，指针指向末尾。
2、Java为什么要将Iterator定义成一个接口呢？而不是一个类呢？
将来你需要根据不同的数据创建不同的集合去存储，每个集合都有自身特点，很有可能每一个集合遍历的顺序和方式都不一样，所以将来取值的时候，使用的方式也不一定是一样的，所以迭代器不应该直接实现如何遍历，而是提供一个接口，将来特有的集合类去实现这个接口中的取值方法，来实现自身的取值特点。
存储自定义对象并遍历
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest2 {
public static void main(String[] args) {
//1、创建集合对象
Collection c = new ArrayList();
//2、创建学生对象
Student s1 = new Student("张飞", 17);
Student s2 = new Student("关羽", 18);
Student s3 = new Student("赵云", 19);
Student s4 = new Student("黄忠", 20);
Student s5 = new Student("马超", 21);
//3、将学生对象添加到集合中
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
//4、遍历集合
//获取迭代器对象
Iterator iterator = c.iterator();
//遍历迭代器获取元素
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
List接口（继承自Collection接口）
1、List集合中的元素是有序的（存储和取出顺序一致） 1，2，3，4，5 ---> 1,2,3,4,5
2、List集合包含了索引的概念
3、List集合中的元素是可以重复的
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
//创建List集合对象，使用接口多态的形式创建对象
List list = new ArrayList();
//向集合中添加元素
list.add("hello");
list.add("world");
list.add("bigdata");
list.add("java");
//遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String s = (String) iterator.next();
System.out.println(s + ",字符串的长度为：" + s.length());
}
}
}
List相关集合特有的功能：
因为List集合拥有下标索引的概念，所以根据这个索引衍生出特有方法
1、添加功能：
void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。
2、删除功能：
Object remove(int index) 删除该列表中指定位置的元素（可选操作）。
3、获取功能：
Object get(int index) 返回此列表中指定位置的元素。
4、修改功能：
Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
5、List集合特有的迭代器
ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.List;
public class ListDemo2 {
public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList();
//添加元素到集合中
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
list.add("hadoop");
System.out.println(list);
System.out.println("======================================");
//void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。
//范围： 0<=index<=size()
list.add(0,"hive");
System.out.println(list);
list.add(5,"spark");
System.out.println(list);
list.add(7,"flink");
System.out.println(list);
list.add(10,"Hbase"); //IndexOutOfBoundsException
System.out.println(list);
System.out.println("======================================");
//Object remove(int index) 删除该列表中指定位置的元素（可选操作）。
System.out.println(list.remove(3));
System.out.println(list);
System.out.println("======================================");
//Object get(int index) 返回此列表中指定位置的元素。
System.out.println(list.get(4));
System.out.println(list);
System.out.println("======================================");
//Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
//返回的是指定位置被替换的元素
Object obj = list.set(2, "hive");
System.out.println(obj);
System.out.println("list:" + list);
}
}
List集合特有的迭代器
ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。
public interface ListIterator extends Iterator
由于ListIterator继承自Iterator接口，所以内部一定有hasNext()和next()方法
Object previous() 返回列表中的上一个元素，并向后移动光标位置。
返回列表中的上一个元素，并向后移动光标位置。 可以反复调用此方法以向后方遍历列表，或者与调用next()进行混合来回。
1、该方法是获取集合中前一个元素
2、该方法获取元素的指针与next()获取元素的指针是同一个
注意：要想倒着遍历，就必须先正着遍历，先将指针移动到末尾。
boolean hasPrevious() 返回 true如果遍历反向列表，列表迭代器有多个元素。
判断上一个位置是否有元素，如果有元素返回true，如果没有元素，返回false。
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo3 {
public static void main(String[] args) {
//1、创建List集合对象
List list = new ArrayList();
//2、添加元素到集合中
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
//3、遍历
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
String s = (String) listIterator.next();
System.out.println(s + ",字符串的长度为：" + s.length());
}
while (listIterator.hasPrevious()){
Object previous = listIterator.previous();
System.out.println(previous);
}
}
}
List集合特有的遍历方式：size()与get()方法结合使用
List集合遍历的方式：
1、调用toArray()方法，转成数组遍历
2、迭代器遍历
3、size()与get()方法结合使用遍历
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.List;
public class ListDemo4 {
public static void main(String[] args) {
//1、创建List集合对象
List list = new ArrayList();
//2、向集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
list.add("hadoop");
//size()与get()方法结合使用遍历集合
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
//向下转型
String s = (String) o;
System.out.println(s + ",字符串的长度为：" + s.length());
}
}
}
List集合存储学生对象并遍历
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo5 {
public static void main(String[] args) {
//1、创建List集合对象
List list = new ArrayList();
//2、创建学生对象
Student s1 = new Student("王宇", 18);
Student s2 = new Student("明旺", 19);
Student s3 = new Student("周家祥", 20);
Student s4 = new Student("张保桂", 17);
//3、将学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//遍历
//a:转成数组遍历
Object[] objects = list.toArray();
for (int i = 0; i < objects.length; i++) {
Student s = (Student) objects[i];
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("=======================================");
//b:迭代器遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s.getName() + "---" + s.getAge());
}
System.out.println("=======================================");
//c:get()和size()方法结合遍历(这是List集合特有的遍历方式，因为有索引的概念)
for (int i = 0; i < list.size(); i++) {
Student s = (Student) list.get(i);
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
需求：有一个集合，集合中存储着一些字符串类型的元素，我想判断一下里面有没有"bigdata"这个字符串如果有，我们就添加一个"yes"。
注意：在迭代器遍历的时候，不能通过集合去修改元素
解决办法：
1、迭代器遍历，迭代器修改
2、集合遍历，集合修改
package com.shujia.wyh.day17;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo6 {
public static void main(String[] args) {
//1、创建一个集合对象
List list = new ArrayList();
//2、向集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
list.add("hive");
//遍历
// Iterator iterator = list.iterator();
// while (iterator.hasNext()){
// Object next = iterator.next();
// String s = (String) next;
// if("bigdata".equals(s)){
// list.add("yes"); //在迭代器遍历的时候，不能通过集合去修改元素
// }
// }
//迭代器遍历，迭代器修改
// ListIterator listIterator = list.listIterator();
// while (listIterator.hasNext()){
// Object next = listIterator.next();
// String s = (String) next;
// if("bigdata".equals(s)){
// listIterator.add("yes"); //在bigdata后面添加，因为此时指针正好指到这里
// }
// }
//集合遍历，集合修改
for(int i=0;i<list.size();i++){
String s = (String) list.get(i);
if("bigdata".equals(s)){
list.add("yes"); //在集合末尾添加
}
}
System.out.println(list);
}
}
107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
