集合(一)~集合概述、List
2020-04-10 本文已影响0人
Anwfly
- List集合序列排序方法
①集合中是简单整型
ArrayList<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(3);
nums.add(2);
Collections.sort(nums);
输出为：1 2 3
②集合中为对象
public static void main(String[] args) {
ArrayList<ProductBean> list = new ArrayList<>();
list.add(new ProductBean("b", 2));
list.add(new ProductBean("a", 1));
list.add(new ProductBean("c", 3));
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + ":" + list.get(i).getPrice());
}
Collections.sort(list, new Comparator<ProductBean>() {
@Override
public int compare(ProductBean o1, ProductBean o2) {
return o2.getPrice().compareTo(o1.getPrice());
}
});
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + ":" + list.get(i).getPrice());
}
}
实体类要实现Comparable接口
public class ProductBean implements Comparable<ProductBean> {
private String name;
private Integer price;
public ProductBean(String name, Integer price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
@Override
public int compareTo(ProductBean o) {
return this.price.compareTo(o.price);
}
}
- 集合中顺序打乱
ArrayList<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Collections.shuffle(list);
- 集合中随机获取一个下标，该方法随机出来的整型是左闭右开的
randomPos = (int) (Math.random() * list.size());
- 集合中随机获取部分数据
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
list.add("3");
Collections.shuffle(list);
list = list.subList(0, 2);
最后的list大小是2，可能是123中的任意两个
一、集合概述
1. 集合的由来
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
2. 集合和数组有什么区别
- 集合长度是可变的,数组长度是不可变的。
- 数组中可以存储基本数据类型和引用类型，集合只能存储对象
- 同一个数组只能存储一种引用类型数据，同一个集合可以存储不同引用数据类型(不建议,遍历不方便)
3. 集合的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
4.集合继承体系
Java.util 包中提供了一些集合类，这些集合类又被称为容器，提到容器不难想到数组，集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的；数组用来存放基本数据类型和引用类型数据；集合用来存放引用数据类型；常用的集合有List集合、Set集合和Map集合，其中分为两类，单列和双列。单列集合的顶层接口是Collection。List接口和set接口继承Collection。
List和set分别提供了实现类ArrayList、LinkedList、Vector，HashSet、TreeSet、LinkedHashSet等实现类体系。Map是双列集合，键值对的形式存储数据，Map是一个集合顶层接口，常用实现类HashMap，TreeMap，LinkedHashMap等体系。
collection.png
二、Collection接口
Collection接口概述及方法
Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
Collection.png
因为 Collection 是一个接口，在使用它的方法的时候，选择其中一个实现类ArrayList来做演示
Collection 接口中的常用方法
1. 添加：
// 向集合中添加一个元素
// e表示要向集合中添加的对象, 添加成功返回true, 添加失败返回false
boolean add(E e)
案例：
Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合添加一个元素
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]
2. 移除：
// 移除集合中指定的元素
// o 表示要从集合中删除的对象 删除成功返回true 返回失败(集合中把本来就没有这个对象)发挥false
boolean remove(Object o)
Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合 添加一个元素
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]
coll.remove("hello");// 删除 集合中 hello 这个//元素
System.out.println(coll);// [world]
3. 清除
//清除集合中的元素, 集合会还原回刚创建的状态
void clear()
案例：
Collection coll = new ArrayList<>();//创建集合
coll.add("hello");//给集合 添加一个元素
coll.add("world");//给集合再添加一个元素
System.out.println(coll);// 显示 [hello, world]
coll.clear();;// 删除 集合中所有元素
System.out.println(coll);// [] 所有数据都删除了
4. 是否包含
//集合中是否包含该元素
//判断集合中是否包含o对象 如果集合中含有o对象,返回true; 如果不含有o对象,返回false
boolean contains(Object o)
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合再 添加一个元素
System.out.println(coll);// [hello,world]
boolean contains1 = coll.contains("hello");//集合中是否包含该元素
System.out.println(contains1);//true 包含
boolean contains2 = coll.contains("张三");//集合中是否包含该元素
System.out.println(contains2);//false 不包含
5. 集合是否为空
// 判断集合是否为空, 如果集合中没有数据返回true, 如果有数据返回false
boolean isEmpty()
案例：
Collection coll = new ArrayList<>();//创建一个集合
System.out.println(coll.isEmpty());// false 集合 没有元素
coll.add("hello");//给集合中 添加一个元素
System.out.println(coll.isEmpty());// true 集合有元素 不为 空
6. 集合大小
// 获取集合存有几个元素 如果集合中存储有5个元素,则返回5
int size()
案例：
Collection coll = new ArrayList<>();//创建一个集合
System.out.println(coll.size());// 0 集合 没有元素
coll.add("hello");//给集合中 添加一个元素
System.out.println(coll.size());// 1 集合有1个元素
coll.add("world");//给集合中 添加一个元素
System.out.println(coll.size());// 2 集合有2个元素
7. 将该集合中的元素添加到另一个集合中
//将该集合中的元素添加到另一个集合中
//把集合c中的所有数据加入到集合中, 添加成功返回true 添加失败返回false
boolean addAll(Collection c)
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
System.out.println(coll2);//[]
coll2.add(coll); // 将 集合 coll 中的元素 都添加到 集合 coll2中
System.out.println(coll2);//[[hello, world]] 把集合coll的元素都添加进入了coll2
8. 移除另一个集合中包含该集合的元素
//移除另一个集合中包含该集合的元素
//如果本集合中有的对象,另外一个集合中也存在,则把这些对象删除, 如果删除了数据返回true; 没有删除数据返回false
boolean removeAll(Collection c)
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
System.out.println("coll: "+coll);
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中 添加一个元素
coll2.add("world");// 给集合 添加一个元素
coll2.add("java");// 给集合 添加一个元素
System.out.println("coll2: "+coll2);
coll2.removeAll(coll); //从集合 coll2 中 移除 与 集合 coll 相同的元素
System.out.println("coll2删除以后: "+coll2);//[java]
9.另一个集合是否包含指定的集合
//另一个集合是否包含指定的集合
//判断集合中是否包含有c集合中的所有元素,如果包含返回true,否则返回false
boolean containsAll(Collection c)
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中 添加一个元素
coll2.add("world");// 给集合 添加一个元素
coll2.add("java");// 给集合 添加一个元素
boolean b = coll2.containsAll(coll); //集合 coll2 是否包含 集合 coll
System.out.println(b);//true 包含
10. 移除 集合中与指定集合不同的元素
// 移除 集合中与指定集合不同的元素
//找到两个集合中不相同的元素删除 有删除的数据返回true ,否则为false
boolean retainAll(Collection c)
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
Collection coll2 = new ArrayList<>();//创建一个集合
coll2.add("hello");//给集合中 添加一个元素
coll2.add("world");// 给集合 添加一个元素
coll2.add("java");// 给集合 添加一个元素
coll2.retainAll(coll); // 移除 集合 coll2 与 集合 coll 不同的元素
System.out.println(coll2);//[hello, world]
11. 把集合转成数组，可以实现集合的遍历
//把集合转成数组，可以实现集合的遍历
//把集合转换成存储相同元素的数组
Object[] toArray()
案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
Object[] array = coll.toArray(); // 转成 Object 数组
for (int i = 0; i < array.length; i++) {
// 存入的是 字符串
// 所有要将 object 转成 string
System.out.println((String)array[i]);
}
三、Iterator接口
1. Iterator接口概述及使用
迭代器，集合的专用遍历方式，对 collection 进行迭代的迭代器，依赖于集合而存在
Iterator接口的成员方法:
//如果仍有元素可以迭代，则返回 true。
boolean hasNext():
//获取元素,并移动到下一个位置。
Object next():
//没有这样的元素，因为你已经找到最后了。
NoSuchElementException()：
实际使用案例：
Collection coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
//获得迭代器
Iterator iterator = coll.iterator();
while(iterator.hasNext()){// 如果有下一个元素
Object next = iterator.next();// 获取下一个元素
// 存入的是 字符串
// 所有要将 object 转成 string
System.out.println((String)next);
}
四、List接口
List接口概述及方法
有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素，存取元素有序。
List接口的特殊成员方法（根据索引进行操作）
1. 添加
//添加指定元素 把要添加进集合的element对象,添加到指定索引位置index
void add(int index,E element)
案例：
List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
System.out.println(coll);// [hello, world]
2.移除指定元素
// 移除指定元素 删除集合中指定index位置处元素对象
E remove(int index)
案例：
List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
coll.remove(1);// 移除 1 这个位置的 元素，集合元素也是从 0 开始计算索引
System.out.println(coll);//[hello]
3. 获取 指定位置的元素
// 获取 指定位置的元素
//index 集合索引值,从0开始,不能大于等于集合中元素个数
E get(int index)
案例：
List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
System.out.println(coll.get(1));//world 获取指定位置的元素
3. 修改指定位置的元素
// 修改指定位置的元素
// index 要修改元素的索引值
// element 此对象会替换掉原来集合中制定索引位置的元素对象
E set(int index,E element)
案例：
List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
System.out.println(coll);//[hello, world]
coll.set(1, "java");// 把 1 位置的 元素 设置成 java
System.out.println(coll);//[hello, java]
4. 获得专用迭代器
// 获得专用迭代器
ListIterator listIterator()
案例：
List coll = new ArrayList<>();//创建一个集合
coll.add("hello");//给集合中 添加一个元素
coll.add("world");// 给集合 添加一个元素
ListIterator listIterator = coll.listIterator();//获取 迭代器
while(listIterator.hasNext()){// 如果有下一个 返回 true
//获取下一个元素
Object next = listIterator.next();
System.out.println((String)next);
}
五、ListIterator接口
1. ListIterator概述及使用
系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
ListIterator接口的成员方法:
// 是否有上一个元素
boolean hasPrevious()
// 获取上一个元素
E previous()
使用以上两个方法时 先使用 迭代器 正向遍历(使位置移动到 最后一个), 无法循环获取 因为位置就在第一个的前面
六、ConcurrentModificationException（异常）简介及处理
1. 简介及处理
ConcurrentModificationException: 不允许这种修改时，抛出此异常
*为什么出现此异常:
在迭代时候, 使用集合对象去修改集合中的元素出现的这种异常；
在迭代过程中 修改集合元素时 迭代器不知道集合被修改发生错误。
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
ListIterator<Integer> it = list.listIterator();
list.add(7);//当获取listIterator对象后修改了集合
while(it.hasNext()){
//如果再使用it对象获取元素,导致ConcurrentModificationException异常
System.out.println(it.next());
}
运行效果:
Concurrent_1.PNG
如何去解决此异常:
使用 ListIterator 迭代 集合 并且 使用 ListIterator 对象去修改 集合元素
ListIterator 提供了 对应的 添加方法
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
ListIterator<Integer> it = list.listIterator();
// list.add(7);
while(it.hasNext()){
System.out.println(it.next());
}
it.add(7);//
//逆向遍历列表
while(it.hasPrevious()){
System.out.println(it.previous());
}
八、ArrayList 类
1. ArrayList类的概述
底层数据结构是数组，查询快，增删慢
线程不安全，效率高，有序的,可重复
2. ArrayList的使用
构造方法摘要 :
//构造一个初始容量为 10 的空列表。
ArrayList()
//构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(Collection<? extends E> c)
//构造一个具有指定初始容量的空列表。
ArrayList(int initialCapacity)
常用方法参考List(使用方式几乎一致)
//创建 ArrayList 集合 对象
ArrayList arr = new ArrayList();
arr.add("hello1");// 给集合添加一个元素
arr.add("hello2");// 给集合添加一个元素
3. ArrayList的常用案例-添加整数遍历集合
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
//把指针移到集合最后
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
4. ArrayList的常用案例-添加字符串遍历集合
ArrayList<String> list=new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
//把指针移到集合最后
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
5. ArrayList的常用案例-添加对象遍历集合
Student.java
public class Student {
private String name;
private int age;
private String sex;
public Student(String name, int age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
}
Test.java
public class Test {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("张三", 18, "男"));
list.add(new Student("李四", 11, "女"));
list.add(new Student("王五", 19, "男"));
list.add(new Student("赵六", 21, "女"));
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
九、Vector 类
1. Vector类概述及使用
底层数据结构是数组，查询快，增删慢, 线程安全，效率低
*Vector类特有功能 :
1. 添加
//添加一个元素
//把obj对象添加进入集合 等效add(E e)方法
public void addElement(E obj)
案例
//创建 Vector 集合 对象 在集合中存入 字符串
Vector v = new Vector();
System.out.println(v);//[]
v.add("hello");
System.out.println(v);//[hello]
2. 获取指定位置的元素
//获取指定位置的元素
//index 制定位置索引值
//返回值为得到制定索引位置的集合元素
public E elementAt(int index)
案例
//创建 Vector 集合 对象 在集合中存入 字符串
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
// 获取 1 这个位置的 元素 并输出在控制台
System.out.println(v.get(1));//world
3. 获取指定位置的元素
// 获取Vector 迭代器
public Enumeration elements()
案例
//创建 Vector 集合 对象 在集合中存入 字符串
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
//获取迭代器
Enumeration elements = v.elements();
//有没有下一个元素 与 ListIterator 用法一样
while(elements.hasMoreElements()){
// 获取下一个元素
Object nextElement = elements.nextElement();
System.out.println((String)nextElement);
}
*Vector的常用案例:
案例1：Vector存入String对象
// 创建 Vector 集合 对象 在集合中存入 字符串
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
// 普通for遍历
for (int i = 0; i < v.size(); i++) {
// 多态 向下转型
System.out.println((String) v.get(i));
}
案例2：Vector存入自定义对象
Vector v = new Vector();
v.add(new Student("赵云",18,"男"));// 给集合添加一个元素
v.add(new Student("张飞",19,"女"));// 给集合添加一个元素
v.add(new Student("关于",20,"男"));// 给集合添加一个元素
v.add(new Student("刘备",21,"女"));// 给集合添加一个元素
//普通for遍历 集合
for (int i = 0; i < v.size(); i++) {
//获取的时候 获取的是 object对象 父类接收子类 多态
Object object = v.get(i);// 集合中的一个元素 是一个 Student 对象
//多态 向下转型
Student s = (Student)object;
System.out.println(s.getName()+"---"+s.getAge());
}
十、 LinkedList类
LinkedList类概述
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
LinkedList类的特有功能
1. 在集合的开始位置插入一条数据
//在集合的开始位置插入一条数据
//e表示要插入集合最开始位置的元素
public void addFirst(E e)
//在集合的末尾添加元素
//e表示要添加进入集合中的元素
addLast(E e)
案例
//创建 LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
System.out.println(link);//[hello, world]
link.addFirst("java");// 在第一个位置插入 一个元素
System.out.println(link);//[java, hello, world]
link.addLast("lvoe");//在集合最后的位置加入一个 元素
System.out.println(link);//[java, hello, world, lvoe]
2. 获取集合的第一个元素
//获取集合的第一个元素
public E getFirst()
//获取集合的最后一个元素
public E getLast()
案例
//创建 LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
link.add("java");
//获取集合中 第一个元素 hello
System.out.println(link.getFirst());
//获取集合中 最后一个元素 java
System.out.println(link.getLast());
3. 获取集合的第一个元素
//删除集合中的第一个元素
public E removeFirst()
//删除集合中的最后一个元素
public E removeLast()
案例
//创建 LinkedList 对象
LinkedList link = new LinkedList();
link.add("hello");//添加一个元素
link.add("world");
link.add("java");
//移除第一个元素 并得到该元素
Object removeFirst = link.removeFirst(); System.out.println(removeFirst);// hello
System.out.println(link);// [world, java]
//移除最后一个元素 并得到该元素
Object removeLast = link.removeLast(); System.out.println(removeLast);//java
System.out.println(link);//[world]
案例一、LinkedList类的常用案例-首尾添加
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.addFirst(0);//在最前面添加
list.addLast(5);//在最后添加 等价add()方法
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
案例二、 LinkedList类的常用案例-指定位置插
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(1,12);//在索引为1的位置插入一个12
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
案例三、 LinkedList类的常用案例-首尾删除
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------删除以后效果------------------");
list.removeFirst();//删除第一个元素
list.removeLast();//删除最后一个元素
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
