集合框架
对象数组
对象数组的概述和使用
需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 +
'}';
}
}
import java.util.Arrays;
public class MyTest {
public static void main(String[] args) {
Student s1 = new Student("鹿秀儿", 18);
Student s2 = new Student("秀儿", 15);
Student s3 = new Student("鹿鹿", 22);
//对象数组： 数组即可以存储基本数据类型，也可以存储引用数据类型
Student[] students = {s1, s2, s3};
for (int i = 0; i < students.length; i++) {
Student student = students[i];
System.out.println(student.getName() + "===" + student.getAge());
}
//数组作为容器的不好之处，就是对容器中的元素，进行操作时，不够方便，比如要增删数组中的元素，就不是那么方便了。
//因为数组一旦定义，长度就不能改变了
Student[] students1 = new Student[3];
students1= Arrays.copyOf(students, 3);
System.out.println(Arrays.toString(students1));
//Java为了我们更加方便的去操作容器中的元素，给我们提供了一种新的容器，叫做集合。
//集合和数组的区别？
//数组的长度，一旦定义固定了，集合的长度是可变的。
//数组既可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用数据类型。
//数组只能存储同一种数据类型的元素。集合可以存储多种数据类型的元素。
}
}
集合
集合的由来及集合继承体系图
集合的由来
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
数组和集合的区别
-
长度区别：
数组的长度是固定的；而集合的长度是可变的
-
存储数据类型的区别：
数组可以存储基本数据类型，也可以存储引用数据类型；而集合只能存储引用数据类型
-
内容区别：
数组只能存储同种数据类型的元素，集合可以存储不同类型的元素
Collection集合的功能概述
Collection的功能概述
- 添加功能
- boolean add（Object obj）：添加一个元素
- boolean addAll（Collection c）：添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
//添加单个对象
collection.add("鹿秀儿");
collection.add("0609");
collection.add(1996);
System.out.println(collection);//[鹿秀儿, 0609, 1996]
Collection collection1 = new ArrayList();
//添加一个集合的元素
boolean b = collection1.addAll(collection);
//把两个集合中的元素，归并到一个集合里面去 返回值是有没有添加成功
System.out.println(b);//true
collection1.add("秀儿");
System.out.println(collection);//[鹿秀儿, 0609, 1996, 秀儿]
}
}
- 删除功能
- void clear（）：移除所有元素
- boolean remove（Object o）：移除一个元素
- boolean removeAll（Collection c）移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素；如果没有交集元素 则删除失败 返回false
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("0609");
collection.add(1996);
collection.add("你真棒");
System.out.println(collection);//[鹿秀儿, 0609, 1996, 你真棒]
//移除一个指定元素，可以使用元素内容或者索引删除
collection.remove("0609");
System.out.println(collection);//[鹿秀儿, 1996, 你真棒]
Collection c = new ArrayList();
c.add(1996);
//移除一个交集的元素
boolean b = collection.removeAll(c);
//移除元素返回true，无交集元素返回false
System.out.println(b);//true
System.out.println(collection);//[鹿秀儿, 你真棒]
//移除所有元素
collection.clear();
System.out.println(collection);//[]
}
}
- 判断功能
- boolean contains（Object o）：判断集合中是否包含指定的元素
- boolean containsAll（Collection c）：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
- boolean isEmpty（）：判断集合是否为空
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("秀秀");
collection.add("1996");
collection.add("0609");
Collection c = new ArrayList();
collection.add("鹿秀儿");
collection.add("1996");
collection.add("0609");
//判断集合中是否包含指定元素
boolean a = collection.contains("鹿秀儿");
System.out.println(a);//true
//判断集合中是否包含指定集合，要求包含所有元素
boolean b1 = collection.containsAll(c);
System.out.println(b1);//true
boolean b2 = c.containsAll(collection);
System.out.println(b2);//false
//判断是否为空
boolean empty = collection.isEmpty();
System.out.println(empty);//false
}
}
- 获取功能
- Iterator iterator()(重点)
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("秀秀");
collection.add("1996");
collection.add("0609");
//iterator 是迭代器
Iterator iterator = collection.iterator();
//迭代器要先hasNest（）（判断有没有元素），再next（）（获取当前元素）
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
}
}
- 长度功能
- int size（）：元素的个数
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("秀秀");
collection.add("1996");
collection.add("0609");
//获取集合中的元素个数
int size = collection.size();
System.out.println(size);//4
}
}
- 交集功能
- boolean retainAll（Collection c）：获取两个集合的交集元素(交集：两个集合都有的元素)
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection a = new ArrayList();
a.add("鹿秀儿");
a.add("秀秀");
a.add("1996");
a.add("0609");
Collection b = new ArrayList();
b.add("鹿秀儿");
b.add("秀秀");
//两个集合取交集
boolean i = a.retainAll(b);
//判断前边的集合有无变化
System.out.println(i);//true
//取得的交集元素放进前面的集合
System.out.println(a);//[鹿秀儿, 秀秀]
boolean j = b.retainAll(a);
System.out.println(j);//false
System.out.println(b);//[鹿秀儿, 秀秀]
}
}
- 集合转换数组
- Object[ ] toArray（）
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("秀秀");
collection.add("1996");
collection.add("0609");
//把集合转换为数组
Object[] objects = collection.toArray();
System.out.println(Arrays.toString(objects));//[鹿秀儿, 秀秀, 1996, 0609]
}
}
Collection存储对象并遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyTest {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("鹿秀儿");
collection.add("秀秀");
collection.add("1996");
collection.add("0609");
Iterator i = collection.iterator();
while (i.hasNext()){
Object next = i.next();
System.out.println(next);
}
}
}
List集合的特有功能概述和测试
List集合的特有功能概述
- void add（int index，E element）：在指定索引处添加元素
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("A:我是第一位");
System.out.println(arrayList.toString());//[A:我是第一位]
arrayList.add(0, "B:我会插队");
System.out.println(arrayList.toString());//[B:我会插队, A:我是第一位]
}
}
- E remove（int index）：移除指定索引处的元素，返回的是移除的元素
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//移除索引处的元素
Object o = arrayList.remove(1);
//返回被移除的元素
System.out.println(o);//BBB
System.out.println(arrayList.toString());//[AAA, CCC]
}
}
- E get（int index）：获取指定索引处的元素
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//获取指定索引处的元素
Object o = arrayList.get(0);
System.out.println(o);//AAA
System.out.println(arrayList.toString());//[AAA, BBB, CCC]
}
}
- set（int index，E element）：更改指定索引处的元素 返回的而是被替换的元素
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//更改索引处的元素
Object o = arrayList.set(1, "DDD");
//返回被替换掉的元素
System.out.println(o);//BBB
System.out.println(arrayList.toString());//AAA, DDD, CCC]
}
}
- int indexOf（Object o）：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//返回指定元素第一次出现的索引
int i = arrayList.indexOf("AAA");
int j = arrayList.indexOf("aaa");
System.out.println(i);//0
//不包含此元素返回-1
System.out.println(j);//-1
}
}
- int lastIndexOf（Object o）：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//返回最后出现的指定元素的索引
int i = arrayList.lastIndexOf("AAA");
int j = arrayList.lastIndexOf("aaa");
System.out.println(i);//3
//不包含此元素返回-1
System.out.println(j);//-1
}
}
ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
-
ListIterator的特有功能
- boolean hasPrevious（）：前面是否存在元素
- E previous（）：返回列表中的前一个元素
以上两个方法可以实现反向遍历。但是注意，要完成反向遍历之前，要先进行正向遍历，这样指针才能移到最后（反向遍历和hasNext（）+next（）使用方法相同）
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素
import java.util.ArrayList;
public class MyTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
arrayList.add("AAA");
arrayList.add("BBB");
arrayList.add("CCC");
//判断指定索引前是否有元素
boolean b = arrayList.listIterator(5).hasPrevious();
System.out.println(b);
//返回指定索引的前一个元素
Object o = arrayList.listIterator(3).previous();
System.out.println(o);
}
}
并发修改异常产生的原因及解决方案
需求：
我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"java"元素，请写代码实现。
现象：
在使用迭代器遍历后通过list.add()方法添加元素就会出现并发修改异常
public static void main(String[] args) {
List list= new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("world");
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Object o = listIterator.next();
if (o.equals("world")){
//ConcurrentModificationException并发修改异常
list.add("java");
}
}
System.out.println(list);
}
报错：
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at blog.BlogMath.main(BlogMath.java:16)
Process finished with exit code 1
原因：当我们使用迭代器遍历集合的时候，我们的迭代器已经事先知道集合元素的个数，突然在迭代途中增加或者删除元素，就会打乱原来集合的顺序，迭代器也就无所适从，就会抛出并发修改异常；
解决方式有两种：
1、方式一：
迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
将`list.add("java“);`修改为`listIterator.add("java");`
集合遍历元素，集合修改元素
案例：
public static void main(String[] args) {
List list= new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("world");
if (list.contains("world")){list.add("java");}
System.out.println(list);
}
}
执行结果：
[aaa, bbb, world, java]
Process finished with exit code 0
2、方式二：
使用for循环遍历，就可以使用集合自己的增加和删除方式
public static void main(String[] args) {
List list= new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("world");
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals("world"))list.add("java");
}
System.out.println(list);
}
执行结果：
[aaa, bbb, world, java]
Process finished with exit code 0
数据结构之栈和队列
数据结构概述及常见数据结构
数据结构其实就是存储数据的格式
- 分类：栈，队列，数组，链表，树，哈希表
- 栈特点：先进后出
- 队列：先进先出
数据结构之数组和链表
- 数组特点：查询快，增删慢
- 链表特点：查询慢，增删快
List的三个子类的特点
List的三个子类的特点
-
ArrayList：
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
-
Vector：
底层数据结构是数组，查询快，增删慢
线程安全，效率低
-
LinkedList：
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
具体该使用哪个子类？
主要看：
- 要安全还是要效率
- 查找多还是增删多
完
扫一扫
2285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
