一.接口Collection的带All的方法
1.containsAll :调用者 完全包含被判断的集合的元素时 才会返回true
代码例子:
public class Kll {
//注解@SuppressWarnings(压制警告)
//rawtypes :保持原有类型
//unchecked:不检查容器中储存的元素类型
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
//创建两个集合,并添加元素
Collection sb1 = new ArrayList<>();
sb1.add("a");
sb1.add("b");
sb1.add("c");
sb1.add("d");
sb1.add("m");
Collection sb2 = new ArrayList<>();
sb2.add("a");
sb2.add("b");
sb2.add("c");
//sb2.add("d");
//containsAll方法测试
boolean b1 = sb1.containsAll(sb2);
System.out.println(b1);
System.out.println(sb1);
System.out.println(sb2);
}
}
2.retainAll 仅保留两个集合的交集 .
调用者集合的元素变化时 返回true,否则 返回false.
谁调用这个方法就保留那个集合中的相同元素.
代码例子:
public class Kll {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
Collection sb1 = new ArrayList<>();
sb1.add("a");
sb1.add("b");
sb1.add("r");
sb1.add("x");
Collection sb2 = new ArrayList<>();
sb2.add("a");
sb2.add("b");
sb2.add("c");
sb2.add("h");
sb2.add("f");
//retainAll方法
boolean b1 = sb1.retainAll(sb2);
System.out.println(b1);
System.out.println(sb1);
System.out.println(sb2);
}
}
3.removeAll
删除是 两个集合的交集
谁调用这个方法 就是在哪儿个集合中删除
代码例子:
public class Kll {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
//创建两个集合 添加 a b c d
Collection sb1 = new ArrayList<>();
sb1.add("a");
sb1.add("b");
sb1.add("c");
sb1.add("d");
Collection sb2 = new ArrayList<>();
sb2.add("a");
sb2.add("b");
sb2.add("c");
sb2.add("d");
sb2.add("m");
//removeAll方法
sb1.removeAll(sb2);
System.out.println(sb1);
System.out.println(sb2);
}
}
4.//addAll方法
add和addAll 的区别:
addAll 把传入的集合中的所有元素添加到调用的集合中(从后边开始添加)
add 是把整个传入的集合当做一个元素添加进去
public class Kll {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
//创建两个集合 添加 a b c d
Collection sb1 = new ArrayList<>();
sb1.add("a");
sb1.add("b");
sb1.add("c");
sb1.add("d");
Collection sb2 = new ArrayList<>();
sb2.add("a");
sb2.add("b");
sb2.add("c");
sb2.add("d");
//addAll方法
sb1.add(sb2);
boolean b1 = sb1.addAll(sb2);
System.out.println(sb1);
}
}
二.利用迭代器遍历集合
1.利用迭代器遍历集合(重点)
迭代器中 相当于有一个指针 默认指向 首元素的上面
当调用hasNext()时 会判断指针的下一个位置有没有元素 是不会改变指针的位置
调用next方法时 会获取下一个元素的值 并且会将指针向下挪动一个位置
注意: 迭代遍历时 循环中只能调用一次next方法
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 利用迭代器遍历集合(重点)
*/
public class DKll {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
//创建集合 添加元素
Collection sb = new ArrayList<>();
sb.add("a");
sb.add("b");
sb.add("c");
sb.add("d");
//迭代器中 相当于有一个指针 默认指向 首元素的上面
//当调用hasNext()时 会判断指针的下一个位置有没有元素 是不会改变指针的位置
//调用next方法时 会获取下一个元素的值 并且会将指针向下挪动一个位置
//注意: 迭代遍历时 循环中只能调用一次next方法
//测试迭代器中的方法
//从集合中获取迭代器
Iterator it = sb.iterator();
boolean b1 = it.hasNext();
System.out.println(b1);
int i = 0;
//判断下一个是否有元素
while (it.hasNext()) {
Object obj1 = it.next();
System.out.println(obj1);
}
}
}
迭代器中hasNext()和next()在集合中的作用步骤图:
三.接口类List
接口List特有方法:
add(int index,Object obj)
索引不能超过长度size
set(index,obj)
替换当前位置
get(int index)
获取当前位置的值
remove(int index)
删除当前位置的值,按索引删除 不能超过角标
public static void fun1() {
//创建多态对象
List list = new ArrayList<>();
//重写的add方法(一个参数)
list.add("a");
list.add("b");
list.add("c");
list.add("d");
System.out.println(list);
//索引不能超过长度size
//List的add特有方法
list.add(2, 30);
System.out.println(list);
//替换当前位置
list.set(2, "kll");
System.out.println(list);
//获取当前位置的值
Object object = list.get(2);
System.out.println(object);
//删除当前位置的值,按索引删除 不能超过角标
list.remove(0);
System.out.println(list);
}
利用List特有的get方法遍历集合:
public static void fun2() {
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// get 遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
迭代器错误的添加集合元素方式
Iterator创建的迭代器 是不能在遍历改变集合长度的
代码例子及解释如下:
public static void fun3() {
// 需求 遍历数组(使用迭代器)
// 如果数组中 有"b"这个元素 就添加"Oh-Yes"这个元素
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 从集合中获取迭代器时已经获取了长度 4
// 当前迭代器遍历集合时 系统就按长度4 进行遍历
// 在遍历的过程中 修改集合长度 这时就发生并发修改异常ConcurrentModificationException
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String object = (String)iterator.next();
if(object.equals("b")) {
// 并发修改异常 ConcurrentModificationException
//增加了集合的长度
list.add("Oh-Yes");
}
}
System.out.println(list);
}
迭代器正确添加集合元素的方式
利用ListIterator 创建迭代器,并且使用迭代器自己的方法可以对集合的长度做出改变.
public static void fun4() {
//解决迭代器错误的添加集合元素方式的方案是 使用迭代器自己的添加方法
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
String object = (String)listIterator.next();
if (object.equals("b")) {
//使用迭代器自己的方法
listIterator.add("Oh-Yes");
}
}
System.out.println(list);
}
利用迭代器自己的方法倒着输出集合元素的方法:
//需要先遍历,把指针移到最后
public static void fun5() {
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
String string = (String)listIterator.next();
System.out.println(string);
}
System.out.println("-------------");
//倒着输出
while (listIterator.hasPrevious()) {
String obj1 = (String)listIterator.previous();
//Object obj2 = listIterator.previous();
System.out.println(obj1);
}
}
Vector类的方法
Vector :JDK1.0出现 ,线程安全 ,内部数组实现 ,被ArrayList替代.
Collection :JDK1.2出现
public static void fun6() {
//创建Vector对象
Vector vector = new Vector<>();
vector.add("a");
vector.add("b");
vector.add("c");
vector.add("d");
//迭代器遍历
Enumeration elements = vector.elements();
while (elements.hasMoreElements()) {
String string = (String)elements.nextElement();
System.out.println(string);
}
}
LinkedList类
LinkedList特点:
查询慢 增删快
相对ArrayList而言 .查询慢:是因为查询,是根据地址(元素仅存相邻的地址)进行对比查询的,而ArrayList查询是根据角标,所以更快速。
增删快是因为:只需要改变前一个元素,后一个元素和添加进去元素内保存的地址就可以了,他们的排序就会改变成你想要的. 而ArrayList,是需要把所需改变的元素的后边的所有元素,都按顺序后移一位或者前移一位来完成增删.数据过多时,速度差会更明显。
以下是LinkedList的特有方法代码例子:
public class Kll {
public static void main(String[] args) {
//LinkedList 内部是链表实现的
//LinkedList 模拟一下栈结构
//栈特点:先入后出
//队列特点:先入先出
LinkedList list = new LinkedList<>();
//添加第一个元素
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
System.out.println(list);
//从最后添加
list.addLast("d");
list.addLast("e");
list.addLast("f");
System.out.println(list);
//删除最后一个元素
list.removeLast();
System.out.println(list);
}
ArrayList类
ArrayList 特点:
查询快 增删快
判断新数组是否包含某个元素的核心:使用的是contains。
去除集合中的重复元素
代码案例:
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.ListIterator;
public class Kll {
// 需求 在集合中存储
// "a""a""a" "b""b""b" "c""c""c"
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
//去除重复数字
ListIterator iterator = list.listIterator();
//新建集合
ArrayList list1 = new ArrayList<>();
while (iterator.hasNext()) {
Object obj1 = iterator.next();
//判断新数组是否包含这个元素
if (!list1.contains(obj1)) {
//不包含添加到新数组
list1.add(obj1);
}
}
System.out.println(list1);
}
}
以下同样是去除集合相同元素但需要重写父类Object类的equals方法的案例:
需求:在集合中存储 6个学生
分别 两个 花花 21岁 两个小明 20岁 两个小红 23岁
去除重复的
student类:
public class Student {
/*
* 学生类(name age)
* 私有化成员变量 有参无参
* set/get方法
* toString方法
*/
private String name;
private int age;
//构造方法
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
//set/get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override//重写toString方法
// TODO Auto-generated method stub
String str = "学生名字:"+name+" 学生年龄:"+age;
return str;
}
//重写equals方法
@Override
public boolean equals(Object obj) {
//重写 判断两个对象相等的规则
//人名 和 年龄 相等
//this 和 obj比较
//类型强转
Student stu = (Student) obj;
boolean rel = this.getName().equals(stu.getName()) && this.getAge() == stu.getAge();
return rel;
}
}
测试类:
判断新数组是否包含某个元素的核心使用的是contains。
contains方法中 ,依赖的是equals方法。
Object类中equals方法 判断时的是对象地址是否相等
所以要重写equals方法。
public class Test {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
// 需求 在集合中存储 6个学生
// 分别 两个 东东 18岁 两个生生 16岁 两个柳柳 20岁
// 去除重复的
ArrayList list = new ArrayList<>();
list.add(new Student("花花", 21));
list.add(new Student("花花", 21));
list.add(new Student("小明", 20));
list.add(new Student("小明", 20));
list.add(new Student("小红", 23));
list.add(new Student("小红", 23));
ListIterator iterator = list.listIterator();
//新建集合
ArrayList list1 = new ArrayList<>();
while (iterator.hasNext()) {
Student obj1 = (Student)iterator.next();
//判断新数组是否包含这个元素
//本段代码 核心使用的是contains
//点击contains方法 发现contains方法中 依赖的是equals方法
//Object类中equals方法 判断时的是对象地址是否相等
if (!list1.contains(obj1)) {
//不包含添加到新数组
list1.add(obj1);
}
}
System.out.println(list1);
}
}