1.对象数组的概述和使用
需求:我有3个学生,请把这个3个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息。
学生:Student
成员变量:name,age
构造方法:无参,带参
成员方法:getXxx()/setXxx()
学生类:
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 +
'}';
}
}
测试类:
public class MyTest {
public static void main(String[] args) {
/* 需求:我有3个学生,请把这个3个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息。
学生:Student
成员变量:name, age
构造方法:无参, 带参
成员方法:getXxx() / setXxx()
存储学生的数组 ? 自己想想应该是什么样子的 ?*/
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王五", 25);
//对象数组
Student[] students=new Student[3];
students[0]=s1;
students[1]=s2;
students[2]=s3;
for (int i = 0; i < students.length; i++) {
Student student = students[i];
String name = student.getName();
int age = student.getAge();
System.out.println("姓名:"+name+" 年龄:"+age);
}
//数组作为容器,来存储元素,但是有一些不方便的地方,数组的长度是固定的,一旦定义,就不能改变。
//有的时候,我们想要往数组中添加元素,或删除元素,就不是很方便了。
//Java考虑到,我们能够更加容易的操作容器中的元素,给我们提供了另外一种容器,就是集合。
//集合和数组的区别?
//数组长度是固定的,一旦定义,就不能改变。
//集合的长度是可变的。
//数组既可以存储基本数据类型,也可以存储引用数据类型
//集合只能存储引用数据类型,
//数组中的元素,只能是同一种数据类型的元素。
//集合可以存储不同类型的元素。
}
}
2.集合的由来及集合继承体系图
1.集合的由来
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,Java就提供了集合类。
2.数组和集合的区别
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
3.集合继承体系图
3.Collection集合的功能概述
1.Collection的功能概述(通过API查看即可得到)
a:添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素 则删除失败 返回false
c:判断功能
boolean contains(Object o):判断集合中是否包含指定的元素
boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
比如:1,2,3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty():判断集合是否为空
d:获取功能
Iterator<E> iterator()(重点)
e:长度功能
int size():元素的个数
面试题:数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
f:交集功能
//例如:A集合对B集合取交集,获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
//A集合对B集合取交集元素,如果没有取到交集元素A集合会被清空
boolean retainAll(Collection c):获取两个集合的交集元素(交集:两个集合都有的元素)
g:把集合转换为数组
Object[] toArray()
add():
public class MyTest {
public static void main(String[] args) {
//多态
Collection collection=new ArrayList();
//往集合中添加元素 ,添加成功返回true,添加失败返回false Integer int
boolean b = collection.add(100);
System.out.println(b);
collection.add(200);
collection.add(300);
collection.add(Integer.valueOf(400));
System.out.println(collection);
}
}
addAll():
public class MyTest2 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Collection list2 = new ArrayList();
list2.add("AAA");
list2.add("BBB");
list2.add("CCC");
list2.add("DDD");
//把两个集合中的元素放到一个集合中
list.addAll(list2);
System.out.println(list);
System.out.println(list2);
}
}
remove()和clear():
public class MyTest3 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//删除集合中的元素,删除成功返回true
boolean b = list.remove("ddd");
System.out.println(b);
System.out.println(list);
//全部清空集合中的元素
list.clear();
System.out.println(list);
}
}
removeAll():
public class MyTest4 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Collection list2 = new ArrayList();
list2.add("AAA");
list2.add("BBB");
list2.add("CCC");
list2.add("DDD");
list2.add("ccc");
list2.add("ddd");
/* 移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素 则删除失败 返回false*/
boolean b = list.removeAll(list2);
System.out.println(b);
System.out.println(list);
System.out.println(list2);
}
}
把多个对象直接添加到集合中:
public class MyTest5 {
public static void main(String[] args) {
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王五", 25);
Collection list = new ArrayList();
list.add(s1);
list.add(s2);
list.add(s3);
System.out.println(list);
}
}
contains()和isEmpty():
public class MyTest6 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//判断集合中是否包含该元素
boolean b = list.contains("aaaaa");
System.out.println(b);
list.clear();
boolean b1 = list.isEmpty(); //判断集合是否为空
System.out.println(b1);
}
}
contains()和size():
public class MyTest7 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
Collection list2 = new ArrayList();
list2.add("AAA");
list2.add("BBB");
list2.add("CCC");
list2.add("DDD");
list2.add("ccc");
list2.add("ddd");
//判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
// 比如:1,2,3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean b = list.containsAll(list2);
System.out.println(b);
//获取集合的长度
int size = list.size();
System.out.println(size);
}
}
retainAll():取两个集合的交集,放到list集合中,如果集合发生改变,返回true,不改变返回false
public class MyTest8 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("ccc");
list.add("ddd");
Collection list2 = new ArrayList();
list2.add("AAA");
list2.add("BBB");
list2.add("CCC");
list2.add("DDD");
list2.add("ccc");
list2.add("ddd");
//例如:A集合对B集合取交集,获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
//A集合对B集合取交集元素,如果没有取到交集元素A集合会被清空
boolean b = list.retainAll(list2);
System.out.println(b);
System.out.println(list);
System.out.println(list2);
}
}
4.集合的遍历之集合转数组遍历
1.集合的遍历
toArray() 把一个集合转成数组
其实就是依次获取集合中的每一个元素。
2.案例演示
把集合转成数组toArray(),遍历这个数组 可以实现集合的遍历
public class MyTest9 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
String[] strings = new String[list.size()];
Iterator iterator = list.iterator();
int i=0;
while (iterator.hasNext()){
String obj = (String) iterator.next();
strings[i++]=obj;
}
System.out.println(Arrays.toString(strings));
//把集合转换成数组
Object[] objects = list.toArray();
for (int j = 0; j < objects.length; j++) {
String object = (String) objects[j];
System.out.println(object);
}
}
}
5.迭代器的原理及源码解析
public class MyTest91 {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//遍历集合中的元素
/*
* java.util
接口 Iterator<E>
* 对 collection 进行迭代的迭代器。
* boolean hasNext()
如果仍有元素可以迭代,则返回 true。
E next()
返回迭代的下一个元素。
* */
Iterator iterator = list.iterator();
// java.util.ArrayList$Itr @1b6d3586
//Itr是 ArrayList集合的内部类
//内部类,可以访问外部类的成员,包括私有成员。
System.out.println(iterator);
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
}
}
6.Collection集合存储自定义对象并遍历
public class MyTest {
public static void main(String[] args) {
Collection list = new ArrayList();
list.add(new Student("张三",23));
list.add(new Student("李四", 24));
list.add(new Student("王五", 25));
list.add(new Student("赵六", 26));
//遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Student student = (Student) iterator.next();
System.out.println(student.getName()+"==="+student.getAge());
}
}
}
7.List概述及特点
List概述及特点: 元素有序,并且每一个元素都存在一个索引.元素可以重复.
8.List集合的特有功能概述和测试
1.List集合的特有功能概述
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。
List<E> subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
2.案例演示: 特有功能测试
指定索引,添加元素:
public class MyTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
list.add(200);
//可以在指定索引处,添加元素。
list.add(0,300);
System.out.println(list);
}
}
根据索引,删除元素:
public class MyTest2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("eee");
list.add("fff");
list.remove("aaa"); //根据元素来删掉
list.remove(0); //根据索引来删除集合中的元素
System.out.println(list);
}
}
根据索引,获取元素( get() ):
public class MyTest3 {
public static void main(String[] args) {
//List集合特点:元素有序(存取顺序是一致的),且允许重复元素
List list = new ArrayList();
list.add(100);
list.add(200);
list.add(200);
list.add(300);
list.add(400);
list.add(500);
list.remove(0);
list.remove(Integer.valueOf(200));
System.out.println(list);
//根据索引来获取元素
Object o = list.get(0);
System.out.println(o);
}
}
set() ,indexof(),lastindexof():
public class MyTest4 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("ddd");
list.add("ddd");
list.add("eee");
list.add("fff");
//根据索引来修改集合中的元素,返回的是你修改之前的旧元素
Object oldEle = list.set(0, "王老虎");
System.out.println(oldEle);
System.out.println(list);
//返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。
int index = list.indexOf("ddd");
System.out.println(index);
int i = list.lastIndexOf("ddd");
System.out.println(i);
}
}
subList():
public class MyTest5 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("ddd");
list.add("ddd");
list.add("eee");
list.add("fff");
//返回的是 SubList 他ArrayList的一个内部类
List list1 =list.subList(0, 4);
list1.add("rrrrr");
System.out.println(list1);
}
}
9.List集合存储字符串并遍历(三种遍历方法):
1.普通迭代器遍历;
2.for循环遍历:
3.list接口中迭代器遍历;
public class MyTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("ddd");
list.add("ddd");
list.add("eee");
list.add("fff");
//遍历方式1:
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String next = (String) iterator.next();
System.out.println(next);
}
System.out.println("=====================================");
//方式2:使用for
for (int i = 0; i < list.size(); i++) {
String o = (String) list.get(i);
System.out.println(o);
}
System.out.println("========================");
//方式3:使用 List接口中的迭代器
ListIterator listIterator = list.listIterator();
//java.util.ArrayList$ListItr@1b6d3586
System.out.println(listIterator);
while (listIterator.hasNext()) {
Object next = listIterator.next();
System.out.println(next);
}
}
}
10.List集合存储学生对象并遍历(三种遍历方法):
public class MyTest3 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("张三", 23));
list.add(new Student("李四", 24));
list.add(new Student("王五", 25));
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Student student = (Student) iterator.next();
System.out.println(student.getName()+"=="+student.getAge());
}
System.out.println("=====================");
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Student student = (Student) listIterator.next();
System.out.println(student.getName() + "==" + student.getAge());
}
System.out.println("=====================");
for (int i = 0; i < list.size(); i++) {
Student student = (Student) list.get(i);
System.out.println(student.getName() + "==" + student.getAge());
}
}
}
11.ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
1.ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素
2.案例演示: ListIterator的特有功能
public class MyTest2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
list.add("ddd");
list.add("ddd");
list.add("eee");
list.add("fff");
//正向迭代
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
Object next = listIterator.next();
System.out.println(next);
}
System.out.println("==============================");
//反向迭代。你先要进行正向迭代。
while (listIterator.hasPrevious()) {
Object previous = listIterator.previous();
System.out.println(previous);
}
}
}
12.并发修改异常产生的原因及解决方案
1.案例演示
需求:我有一个集合,请问,我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现。
2.ConcurrentModificationException出现
我们用Iterator这个迭代器遍历采用hasNext方法和next方法,集合修改集合 会出现并发修改异常
原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器 那么迭代器已经知道了集合的元素个数
这个时候你在遍历的时候又突然想给 集合里面加一个元素(用的是集合的add方法) 那迭代器不同意 就报错了
3.解决方案 我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
a:迭代器迭代元素,迭代器修改元素(ListIterator的特有功能add)
b:集合遍历元素,集合修改元素解决方案2 使用for循环遍历集合 添加元素 不会报错
当你用迭代器,迭代集合时,在迭代途中,调用集合 的add() remove() 方法来增删元素,就会出现 ConcurrentModificationException 这个异常:
public class MyTest {
public static void main(String[] args) {
/*A:
案例演示
需求:我有一个集合,请问,我想判断里面有没有 "world" 这个元素,
如果有,我就添加一个 "javaee" 元素,请写代码实现。*/
List list = new ArrayList();
list.add("java");
list.add("hello");
list.add("world");
// modCount++; 记录修改集合的次数
/*
if (list.contains("world")) {
list.add("javaee");
}
System.out.println(list);*/
//ConcurrentModificationException
//当你用迭代器,迭代集合时,在迭代途中,调用集合 的add() remove() 方法来增删元素,就会出现 ConcurrentModificationException 这个异常
ListIterator iterator = list.listIterator();
while (iterator.hasNext()) {
String ele = (String) iterator.next();
//ele.equal("java")
if("world".equals(ele)){
//list.add("javaee");
iterator.add("javaee");
}
}
//解决方式1:用迭代器遍历,如果你在迭代途中,想要在迭代途中,添加,或删除元素,使用迭代器自带的增删方法
System.out.println(list);
//2.for循环,遍历途中可以进行增删元素
for (int i = 0; i < list.size(); i++) {
String ele = (String)list.get(i);
//ele.equal("java")
if ("world".equals(ele)) {
//list.add("javaee");
list.add("javaee");
}
}
System.out.println(list);
}
}
13.数据结构之栈和队列
1.数据结构概述及常见数据结构
数据结构其实就是存储数据的格式
分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表 图
2.栈特点: 先进后出 弹夹3.队列: 先进先出
14.数据结构之数组和链表
1.数组特点: 查询快 , 增删慢
2.链表特点: 查询慢 , 增删快
public class MyTest {
public static void main(String[] args) {
//List 接口下面的 三个实现类
// ArrayList: 底层数据结构是数组,查询快,增删慢 ,线程不安全的,效率高
// Vector: 底层数据结构是数组,查询快,增删慢 线程安全,效率低。
// LinkedList 底层数据结构是链表,增删快,查询慢,线程不安全效率高
ArrayList list = new ArrayList();
list.add("abc");
}
}
15.List的三个子类的特点
1.List的三个子类的特点 List
ArrayList:
底层数据结构是数组,查询快,增删慢。
线程不安全,效率高。
Vector:
底层数据结构是数组,查询快,增删慢。
线程安全,效率低。
LinkedList:
底层数据结构是链表,查询慢,增删快。
线程不安全,效率高。