JAVA集合框架
Java集合框架概述：提供一套性能优良、使用方便的接口和类，它们位于Java.util包中
Collection接口
Collection接口的常用方法
集合作为容器应该具有的一些功能（增，删，改，查）
不一定全部具备
集合的基本操作：增加，删除，判断，取出
import java.util.ArrayList;
import java.util.Collection;
/**
* @Auther:Yuhai
* @Date:2022/3/13-03-13-22:14
* +
* @Description:IntelliJ IDEA
* @version:1.0
*/
public class CollectionDemo {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add(0);
collection.add("123");
collection.add(true);
System.out.println(collection);
Collection collection2 = new ArrayList();
collection2.add("abc");
collection2.add(666);
collection2.add(100L);
// System.out.println(collection2.addAll(collection));
// collection.clear();
// System.out.println(collection);
// System.out.println(collection.contains(666));
// System.out.println(collection.containsAll(collection));
// System.out.println(collection.isEmpty());
//collection常见的使用方法
// boolean add(Ee) 添加元素
//boolean remove (object o) 从集合中移除指定的元素
//void clear() 清空集合中的元素
//boolean contains 判断集合中是否存在指定的元素
//boolean isEmpty 判断集合是否为空
//int size 判断集合的长度，也就是集合中的元素
// System.out.println(collection.removeAll(collection2));
// collection.clear();
// System.out.println(collection);
// collection.contains(2);
// System.out.println(collection);
collection.size();
System.out.println(collection.size());
//collection 集合的遍历
// Iterator 迭代器，集合遍历的专用方式
/*Iterator中的常用方法：
E next():返回迭代器中的下一个元素
boolean hasNext():如果迭代具有更多的元素，则返回为true
*/
}
}
Collection下面的有List和Set接口来存储对象
List代码
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @Auther:Yuhai
* @Date:2022/3/16-03-16-13:02
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
List集合特点
有序；存储和取出元素一致
可重复，存储的元素可以重复
多态： 父类的引用指向子类的实力化
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList();
//添加元素
list.add("hello");
list.add(12);
list.add(true);
list.add(100L);
//输出对象
System.out.println(list);
//迭代器的遍历方式
Iterator it = list.iterator();
while(it.hasNext()){
Object s = it.next();
System.out.println(s);
}
}
}
Set代码
import java.util.HashSet;
import java.util.Set;
/**
* @Auther:Yuhai
* @Date:2022/3/16-03-16-8:11
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
set集合特点：
不包含重复元素的集合
没有带索引值的方法，所以不能使用普通for循环进行遍历
HashSet:对集合中的迭代顺序不做保证
*/
public class SetDemo {
public static void main(String[] args) {
//创建集合对象
Set<String> set = new HashSet<String>();
//添加元素
set.add("Hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("java");
//遍历
for(String s : set){
System.out.println(s);
}
}
}
LIst下面有ArrayList和LinkedList
ArrayList例子的展示
/**
* @Auther:Yuhai
* @Date:2022/3/14-03-14-18:46
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
List 接口是有序的、不唯一、可重复的
ArrayList实现长度可变的数组，在内存分配连续的空间
可调整大小的数组的实现List接口。 实现所有可选列表操作，并允许所有元素，包括null 。
除了实现List 接口之外，该类还提供了一些方法来操纵内部使用的存储列表的数组的大小。
（这个类是大致相当于Vector，不同之处在于它是不同步的）。
ArrayList<E>:
可调整数组大小的实现
<E>:泛型，是一种特殊的数据类型
*/
public class ArrayListDemo {
public static void main(String[] args) {
//创建一个空的集合对象
java.util.ArrayList<String> array = new java.util.ArrayList<String>();
//public boolean add(E e)；指定的元素追加到此集合的末尾
array.add("1");//位置为0
array.add("abc");//1
array.add("true");//2
//public boolean add(E e)；指定的元素追加到此集合的末尾
array.add(1,"你好");
array.add(2,"123");
array.add(5,"333");
array.add(3,"666");
//输出集合
System.out.println("array:"+array);
}
}
LinkedList例子的展示
import java.util.LinkedList;
/**
* @Auther:Yuhai
* @Date:2022/3/16-03-16-13:17
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
ArrayList – 遍历元素和随机访问元素的效率比较高
– 插入、删除等操作频繁时性能低下
▪ LinkedList
– 插入、删除元素时效率较高
– 查找效率较低
*/
public class LinkedListDemo {
public static void main(String[] args) {
//创建集合对象
LinkedList linkedList = new LinkedList();
//添加元素
linkedList.add(1);
linkedList.add("abc");
linkedList.add(true);
linkedList.add(100L);
linkedList.addFirst("javase");//在开头插入指定元素
linkedList.addLast("ok");//将指定的元素插入此列表的末尾
System.out.println(linkedList);
// linkedList.peek();//检索但不删除此列表的头（第一个元素）
// System.out.println(linkedList.peek());
//
// linkedList.poll();//检索并删除此列表的第一个元素
// System.out.println(linkedList.poll());
// System.out.println(linkedList);
linkedList.pop();//从此列表表示的堆栈中弹出一个元素怒
System.out.println(linkedList.pop());
}
}
Iterator迭代器的使用
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。 Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作
上代码演示
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @Auther:Yuhai
* @Date:2022/3/14-03-14-12:31
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
collection 集合的遍历
Iterator 迭代器，集合遍历的专用方式
Iterator中的常用方法：
E next():返回迭代器中的下一个元素
boolean hasNext():如果迭代具有更多的元素，则返回为true
所以的集合类都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，
也就是for-each，增强for循环本质上使用的也是iterator的功能
方法：
iterator();
foreach();
//外部类.this表示外部类对象 = 内部类调用外部类同名变量
ListIterator迭代器提供了向前和向后两种遍历方式
始终是通过cursor和lastret的指引来获取元素值和向下的遍历索引
当使用向前遍历的时候必须要保证指针的迭代器的结果，否则无法获取结果值
*/
public class IteratorDemo {
public static void main(String[] args) {
// //创建集合对象
// Collection<String> c =new ArrayList<String>();
//
// //添加元素
// c.add("1");
// c.add("123");
// c.add("456");
// Iterator<String>it = c.iterator();
// System.out.println(c.size());
//在迭代过程中，准备添加和删除元素
// ArrayList al = new ArrayList();
//添加对象
al.add("Hello");
al.add("java1");
al.add("java2");
//遍历
ListIterator it = al.listIterator();
while(it.hasNext()){
Object obj=it.next();
if (obj.equals("java2")) {
al.add("java9");
}
System.out.println("obj="+obj);
}
List list = new ArrayList();
list.add(123);
list.add("abc");
list.add(true);
list.add(100L);
// //遍历集合
// for (int i = 0; i <list.size() ; i++) {
// System.out.println(list.get(i));
// }
System.out.println("********************");
//使用迭代器遍历集合
Iterator iterator = list.iterator();
while(iterator.hasNext()){
Object o = iterator.next();
if(o.equals("abc")){
iterator.remove();
}
//ConcurrentModificationException并发式异常
// if (list.contains("abc")){
// list.remove("abc");
// }
System.out.println(list);
// System.out.println(iterator.next());
}
System.out.println("**********************");
//如果是遍历数组，那么使用增强for循环来进行遍历
//如果是其他方式，使用迭代器遍历是最佳选择
System.out.println(list);
//增强for循环
//这个可以在不知道数组的长度下也可以遍历
// for (Object o :list){
// System.out.println(o);
// }
}
}
ListIterator的作用-----解决并发操作异常
在迭代时，不可能通过集合对象的方法(al.add(?))操作集合中的元素， ▪ 会发生并发修改异常。 ▪ 所以，在迭代时只能通过迭代器的方法操作元素，但是Iterator的方法 是有限的，只能进行判断(hasNext)，取出(next),删除(remove)的操作， ▪如果想要在迭代的过程中进行向集合中添加，修改元素等就需要使用 ListIterator接口中的方法
上机练习1
创建一个Dog类，包含昵称，亲密度两上属性， ▪ 创建测试类，完成以下任务
需求说明： – 把多个Dog的信息添加到集合中
查看Dog的数量及所有Dog的信息
删除集合中部分Dog的元素判断集合中是否包含指定Dog
import java.util.Objects;
/**
* @Auther:Yuhai
* @Date:2022/3/17-03-17-18:04
* @Description:IntelliJ IDEA
* @version:1.0
*/
/*
//创建一个Dog类，包含昵称，亲密度两上属性， ▪ 创建测试类，完成以下任务
//▪ 需求说明： – 把多个Dog的信息添加到集合中
//– 查看Dog的数量及所有Dog的信息
//– 删除集合中部分Dog的元素
//– 判断集合中是否包含指定Dog
// */
public class Dog {
private String name;
private int intimacy;
public Dog(){
}
public Dog(String name, int intimacy) {
this.name = name;
this.intimacy = intimacy;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIntimacy() {
return intimacy;
}
public void setIntimacy(int intimacy) {
this.intimacy = intimacy;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", intimacy=" + intimacy +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Dog dog = (Dog) o;
return intimacy == dog.intimacy &&
Objects.equals(name, dog.name);
}
@Override
public int hashCode() {
return Objects.hash(name, intimacy);
}
}
创建测试类
import java.util.ArrayList;
import java.util.List;
/**
* @Auther:Yuhai
* @Date:2022/3/17-03-17-18:08
* @Description:IntelliJ IDEA
* @version:1.0
*/
public class Test {
public static void main(String[] args) {
List list = new ArrayList();``
list.add(new Dog("小黑",99));
list.add(new Dog("小花",88));
list.add(new Dog("小红",98));
list.add(new Dog("小白",77));
System.out.println(list);
System.out.println("*********");
if(list.contains(new Dog("小红",98))){
list.remove(new Dog("小红",98));
}
System.out.println(list);
}
}
总结
ArrayList – 遍历元素和随机访问元素的效率比较高
插入、删除等操作频繁时性能低下
LinkedList
插入、删除元素时效率较高
查找效率较低
