一 集合中的方法
1.addAll removeAll retainAll
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("c");
c2.add("y");
1.addAll
public static void fun1添加(Collection c1, Collection c2) {
// 添加方法
//把c2当做一个元素 添加到c1中
// c1.add(c2); //[a, b, c, d, [a, b, c, y]
//此时是将c2中每一个元素都添加进c1
c1.addAll(c2);
System.out.println(c1);//[a, b, c, d, a, b, c, y]
}
2.removeAll
public static void fun删除(Collection c1, Collection c2) {
//removeAll
//删除的是调用集合的元素,元素指的是两个集合的交集
boolean rel =c1.removeAll(c2);
System.out.println(c1);//[d]
System.out.println(c2);//[a, b, c, y]
System.out.println(rel);//true
}
c1与c2的交集是 a,b,c 故此 c1的最终结果为[d]
3.retainAll
public static void fun3取交(Collection c1, Collection c2) {
//返回的是两个集合的交集,如果两个集合有交集,就返回true;
boolean rel = c1.retainAll(c2);
System.out.println(c1);//a,b,c
System.out.println(c2);//a,b,c,y
System.out.println(rel);
}
二 遍历集合(迭代器)
public static void fun() {
Collection c = new ArrayList<>();
//实际上 集合内部有个指针指向集合最上
// <-- 1指针 调用next 实际上把指针向下移动一位,调用几次,移动几位.
c.add("a");//
c.add("b");//
c.add("c");//
c.add("d");//
//从集合中获取迭代器.
Iterator iterator = c.iterator();
//判断是否有下一个元素
boolean rel = c.iterator().hasNext();
System.out.println(rel);
//如果有下一个元素,
if (rel) {
for (int i = 0; i < c.size(); i++) {
System.out.println(iterator.next());
}
}
}
遍历集合时要先判断是否集合中具有下一个元素public static void fun2() {
Collection c = new ArrayList<>();
c.add("a");//
c.add("b");//
c.add("c");//
c.add("d");//
//从集合中获取迭代器.
Iterator iterator = c.iterator();
//循环
while (iterator.hasNext()) {
// 注意循环中只调用一次next方法
//获取集合中元素
Object x= iterator.next();
//打印集合元素
System.out.println(x);
}
}
list 中的方法
1.ArrayList 和 LinkedList 的区别
1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。
ArrayList 特点数组实现: 查询按角标, 增删时式是把要删除或增加的元素 后面的所有元素
向前移动或者向后移动
linkedList 特点查询慢 增删快
链表实现: 查询时,系统会先看这个元素离链表的最近端开始查找.
增删时 链表的元素 要保证能找到自己上一个和下一个元素,需要保存地址,就能
找到元素位值,就相当于插入到了链中,链中其他元素地址不会改变
2.
add(int index,Object obj)
set(index,obj)
get(int index)
remove(int index)
public static void fun1() {
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//添加(不要超出集合的元素个数)
list.add(4,"x")//.......
// 设置元素(替换该位置的元素)
list.set(1, "w");
//获取下标处的元素
Object object =list.get(2);
// 删除(返回的是删除的元素)
Object obj= list.remove(2);
System.out.println(obj);
stem.out.println(object);
//利用get方法遍历集合
for (int i = 0; i < list.size(); i++) {
Object object1 =list.get(i);
System.out.println(object1);
}
public static void fun2() {
List list = new ArrayList<>();
list.add(111);
list.add(222);
list.add(333);
//删除111
//list.remove(111);//系统会把111 当成角标处理,没有自动装箱
list.remove(0);
System.out.println(list);
}
要注意的是remove() 括号里可以填具体元素 也可以填集合索引值, 当集合为数字时 系统不会自动装箱,会把具体的数值元素当成索引值.
vector 的遍历
public static void fun3() {
//vector 创建一个
Vector vector = new Vector<>();
vector.addElement("a");
vector.addElement("b");
vector.addElement("c");
vector.addElement("d");
vector.addElement("e");
vector.addElement("f");
//遍历集合
Enumeration e = vector.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}
list 中特有的迭代器
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
1.采用 Iterator 迭代器遍历时添加元素
public static void fun错误添加(List list ) {
Iterator it = list.iterator();
//原有长度4 迭代器就按照原有长度进行迭代
while (it.hasNext()) {
String ob =(String)it.next();
//java.util.ConcurrentModificationException
//并发修改异常
if (ob.equals("b")) {
// 修改了集合的原有长度
//解决:让迭代器去进行添加的操作 调用迭代器中的添加方法
list.add("Oh-Yes");
}
}
上面的迭代器遍历时集合长度已定,无法进行添加的操作
//使用list 中特有的迭代器 ListIterator
//创建迭代器
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
//获取元素并强转型
String string = (String)listIterator.next();
if (string.equals("b")) {
listIterator.add("Oh-Yes");
}
}
System.out.println(list);
}
去重:
public static void fun去重() {
// 需求 在集合中存储 "a""a""a" "b""b""b" "c""c""c"
// 要求 去除重复元素
List 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");
//创建新数组
List newlist = new ArrayList<>();
//迭代器
Iterator lt = list.iterator();
while (lt.hasNext()) {
String st = (String)lt.next();
//判断新集合里是否包含了老集合中的元素
if (!newlist.contains(st)) {
newlist.add(st);
}
}
System.out.println(newlist);
}
再看下面一个例子
// 需求 在集合中存储 6个学生
// 分别 两个 彭 18岁 两个坤 16岁 两个峰 80岁
// 去除重复的
1.先建立一个学生类
public class Student {
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;
}
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
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
2.添加元素并去重
List list = new ArrayList<>();
list.add(new Student("彭",18));
list.add(new Student("彭",18));
list.add(new Student("坤",16));
list.add(new Student("坤",16));
list.add(new Student("峰",80));
list.add(new Student("峰",80));
List newlist = new ArrayList<>();
Iterator it = list.iterator();//迭代器
while (it.hasNext()) {
Student sd = (Student)it.next();
// 判断 ,这段代码去重依赖的是 contains
// contains 方法中依赖的是 equals方法 对比的是元素的地址 ,每一个student 创建的地址都不一样所以去重失败
// 只要是学生 名字和年龄相同
if (!newlist.contains(sd)) {
newlist.add(sd);
}
}
System.out.println(newlist);
如上,此时,
(!newlist.contains(sd);
无法进行判断 ,所以我们想到在student类中重写 equals方法,直接比较 字符串 name 与int age.
@Override
public boolean equals(Object obj) {
Student student = (Student)obj;
// 直接重写equals方法 的规则 直接比姓名年龄都相等.
return this.name.equals(student.getName())&&this.age==student.getAge();
}
此刻比较的是 name 与age 两者被不被包含时 将student 移入新集合.