重难点梳理
使用到的新单词:
1.collection[kəˈlekʃn]
聚集
2.empty[ˈempti]
空的
3.clear[klɪə(r)]
清除
4.iterator
迭代器
学习目标:
1、能够了解Java集合的继承体系结构(Collection和Map接口的继承体系结构)
2、能够了解Collection集合特点以及使用
3、能够掌握List集合的特点以及使用
4、能够掌握ArrayList集合特点以及使用(特点,使用以及原理)
5、能够掌握常见数据结构的特点(栈,队列,数组,链表)
知识重点梳理
超详细讲义及源代码
==知识点==
集合概述
Collection
List
数据结构
ArrayList
LinkedList
1.Collection集合
1.1数组和集合的对比【记忆】(视频01)(6‘’)
-
相同点
都是容器,可以存储多个数据
-
不同点
数组的长度是不可变的,集合的长度是可变的
-
数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Arrays;
public class MyCollectonDemo1 {
public static void main(String[] args) {
//数组可以存储基本数据类型也可以存储引用数据类型
int [] arr1 = {1,2,3};
String [] arr2 = {"a","b","c"};
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println(list1);
//如果集合要存储基本数据类型,那么实际存储的是他们的包装类
//ArrayList<int> list2 = new ArrayList<int>();
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(1);//
list2.add(2);
list2.add(3);
System.out.println(list2);
}
}
1.2集合类体系结构【熟悉】(视频02)(换双列) (3‘’)
1.3Collection 常用方法【重点】(视频03) (13‘’)
1.什么是Collection集合(*接口和特点单列)
Collection是单列集合的*接口,它没有直接的具体实现类,有两个子接口List和Set
2.如何创建Collection集合对象(Collection和ArrayList的关系)
多态的方式
具体的实现类ArrayList
3.Collection集合常用方法
方法名 | 说明 |
---|---|
boolean add(E e) | 添加元素 |
boolean remove(Object o) | 从集合中移除指定的元素 |
boolean removeIf(Object o) | 根据条件进行移除 |
void clear() | 清空集合中的元素 |
boolean contains(Object o) | 判断集合中是否存在指定的元素 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中元素的个数 |
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
public class MyCollectonDemo2 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<>();
// boolean add(E e) 添加元素
collection.add("aaa");
collection.add("bbb");
collection.add("ccc");
collection.add("dddd");
//System.out.println(collection);
//method1(collection);
//method2(collection);
//method3(collection);
//method4(collection);
//method5(collection);
//method6(collection);
}
private static void method6(Collection<String> collection) {
// int size() 集合的长度,也就是集合中元素的个数
int size = collection.size();
System.out.println(size);
}
private static void method5(Collection<String> collection) {
// boolean isEmpty() 判断集合是否为空
collection.clear();
boolean result = collection.isEmpty();
System.out.println(result);
}
private static void method4(Collection<String> collection) {
// boolean contains(Object o) 判断集合中是否存在指定的元素
boolean result = collection.contains("a");
System.out.println(result);
boolean result2 = collection.contains("aaa");
System.out.println(result2);
}
private static void method3(Collection<String> collection) {
// void clear() 清空集合
//就是将集合中所有的元素全部删除.
collection.clear();
System.out.println(collection);
}
private static void method2(Collection<String> collection) {
// boolean removeif(Object o) 根据条件进行删除
//removeif底层会遍历集合,得到集合中的每一个元素
//s依次表示集合中的每一个元素
//就会把这每一个元素都到lambda表达式中去判断一下
//如果返回的是true,则删除
//如果返回的是false,则保留不删除.
//boolean test(String t);
collection.removeIf(
(String s)->{
return s.length() == 3;
}
);
System.out.println(collection);
}
private static void method1(Collection<String> collection) {
// boolean remove(Object o) 从集合中移除指定的元素
//如果删除成功了,则返回true
//如果删除失败了,则返回false
boolean result1 = collection.remove("aaa");
boolean result2 = collection.remove("ddd");
System.out.println(result1);
System.out.println(result2);
System.out.println(collection);
}
}
1.4Collection-迭代器的基本使用【重点】(视频04 7‘’)
迭代器 的作用
用于集合的遍历(迭代器就是一个对象)
2.如何创建迭代器
Iterator<E> iterator(): 返回此集合中元素的迭代器,该迭代器器对象默认指向当前集合0索引
3.Iterator中的常用方法
boolean hasNext(): 判断当前位置是否有元素可以被取出 E next(): 获取当前位置的元素,同时将迭代器对象移向下一个索引位置
4.Collection集合的遍历
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyCollectonDemo3 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//1,获得迭代器的对象
//迭代器对象一旦被创建出来,默认指向集合的0索引处
Iterator<String> it = list.iterator();
//利用迭代器里面的方法进行遍历
//当前位置是否有元素可以被取出
// System.out.println(it.hasNext());
// //取出当前位置的元素 + 将迭代器往后移动一个索引的位置
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
while(it.hasNext()){
System.out.println(it.next());
}
}
}
1.5 迭代器的原理分析【重点、难点】(视频05)(5‘’)
迭代器原理(三个方法) ①. Iterator<E> iterator(): 获取迭代器对象,默认指向0索引 ②. boolean hasNext():判断当前位置是否有元素可以被取出 ③. E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
while(it.hasNext()){
System.out.println(it.next());
}
1.6 迭代器中删除的方法【重点】(视频06) (8‘’)
void remove(): 删除迭代器对象当前指向的元素
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Iterator;
public class MyCollectonDemo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
if("b".equals(s)){
//指向谁,那么此时就删除谁.
it.remove();
}
}
System.out.println(list);
}
}
1.7 增强for循环-基本应用【重点】(视频07)(6‘’)
1.增强for的作用
简化数组和Collection集合的遍历,比迭代器简单也比for循环也简单
2.如何使用?
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
3.增强for的原理
它是JDK5之后出现的,其内部原理是一个Iterator迭代器(数组是for,集合为Iterator)
4.增强for的应用场景
实现Iterable接口的类才可以使用迭代器和增强for(数组)
代码
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
//1,数据类型一定是集合或者数组中元素的类型
//2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
//3,list就是要遍历的集合或者数组.
for(String str : list){
System.out.println(str);
}
}
}
1.8 增强for-注意事项和三种遍历的应用场景【记忆】(视频08)(4‘’)
1.注意事项
在增强for循环中无法改变数组或集合中的元素(iterator)
2.三种遍历方式使用场景 增强for: 对集合进行只要简单遍历时使用 普通for: 遍历过程中需要操作索引时使用 迭代器: 遍历过程中需要删除元素时使用
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
public class MyCollectonDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//
// for(String str : list){
// str = "q";
// System.out.println(str);
// }
for (String s : list) {
System.out.println(s);
}
//System.out.println(list);
}
}
1.9 Collection练习【重点】(视频9)(4'')
注意:增强for可以操作数组和集合,而迭代器只能操作集合
package com.itheima.mycollectiondemo1;
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 +
'}';
}
}
package com.itheima.mycollectiondemo1;
import java.util.ArrayList;
import java.util.Iterator;
public class MyCollectonDemo8 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Student s1 = new Student("小皮同学",23);
Student s2 = new Student("小路同学",31);
Student s3 = new Student("小贾同学",33);
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器的方式进行遍历
Iterator<Student> it = list.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s);
}
System.out.println("-------------------------");
//增强for
for (Student student : list) {
System.out.println(student);
}
}
}
2.List集合
2.1List集合的概述和特点【记忆】(视频10) (4‘’)
-
List集合的特点
存取有序
可以重复
有索引
package com.itheima.mylistdemo1;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class MyListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("---------------------");
for (String s : list) {
System.out.println(s);
}
}
}
2.2List集合的特有方法【重点】(视频11) (7‘’)
-
方法介绍
方法名 描述 void add(int index,E element) 在此集合中的指定位置插入指定的元素 E remove(int index) 删除指定索引处的元素,返回被删除的元素 E set(int index,E element) 修改指定索引处的元素,返回被修改的元素 E get(int index) 返回指定索引处的元素 -
示例代码
package com.itheima.mylistdemo1;
import java.util.ArrayList;
import java.util.List;
public class MyListDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//method1(list);
//method2(list);
//method3(list);
//method4(list);
}
private static void method4(List<String> list) {
// E get(int index) 返回指定索引处的元素
String s = list.get(0);
System.out.println(s);
}
private static void method3(List<String> list) {
// E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
//被替换的那个元素,在集合中就不存在了.
String result = list.set(0, "qqq");
System.out.println(result);
System.out.println(list);
}
private static void method2(List<String> list) {
// E remove(int index) 删除指定索引处的元素,返回被删除的元素
//在List集合中有两个删除的方法
//第一个 删除指定的元素,返回值表示当前元素是否删除成功
//第二个 删除指定索引的元素,返回值表示实际删除的元素
String s = list.remove(0);
System.out.println(s);
System.out.println(list);
}
private static void method1(List<String> list) {
// void add(int index,E element) 在此集合中的指定位置插入指定的元素
//原来位置上的元素往后挪一个索引.
list.add(0,"qqq");
System.out.println(list);
}
}
3.数据结构
3.1数据结构之栈和队列【记忆】(视频12)(6‘’)
-
栈结构
先进后出
-
队列结构
先进先出
3.2数据结构之数组和链表【记忆】(视频13) (11‘’)
-
数组结构(内存,下标)
数组的特点
查询快、增删慢
-
链表结构(内存,下标)
什么是链表
-
链表的特点
查询慢、增删快
4.ArrayList源码解析【难点】(视频14)(16‘’)
1.ArrayList底层是一个数组
2.当初始化ArrayList,数组的长度为0
3.当第一次添加的时候,数组的长度为10
4.以后添加时,如果数组的长度不满足时,进行扩容 ,按1.5来进行扩容
5.扩容之后,将原数组中的元素拷贝到新的数组中
5.List集合的实现类
5.1LinkedList-基本应用【记忆】(视频15) (3‘’)
-
ArrayList集合的特点(加塞儿代码验证1万次)
底层是数组结构实现,查询快、增删慢
-
LinkedList集合特点
底层是链表结构实现,查询慢、增删快
比较添加
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
ArrayList<Integer> array=new ArrayList<>();
LocalDateTime arrayStartTime = LocalDateTime.now();
for (int i=0;i<100000;i++){
array.add(0,i);
}
LocalDateTime arrayEndTime = LocalDateTime.now();
Duration duration = Duration.between(arrayStartTime, arrayEndTime);
System.out.println(duration.toNanos());
LocalDateTime linkStartTime = LocalDateTime.now();
for (int i=0;i<100000;i++){
list.add(0,i);
}
LocalDateTime linkEndTime = LocalDateTime.now();
Duration duration1 = Duration.between(linkStartTime, linkEndTime);
System.out.println(duration1.toNanos());
}
package com.itheima.mylistdemo1;
import java.util.Iterator;
import java.util.LinkedList;
public class MyLinkedListDemo3 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("-------------------------");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("--------------------------");
for (String s : list) {
System.out.println(s);
}
}
}
5.2LinkedList集合的特有功能【重点】(视频16) (5‘’)
-
特有方法
方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾 public E getFirst() 返回此列表中的第一个元素 public E getLast() 返回此列表中的最后一个元素 public E removeFirst() 从此列表中删除并返回第一个元素 public E removeLast() 从此列表中删除并返回最后一个元素 -
示例代码
package com.itheima.mylistdemo1;
import java.util.LinkedList;
public class MyLinkedListDemo4 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// public void addFirst•(E e) 在该列表开头插入指定的元素
//method1(list);
// public void addLast•(E e) 将指定的元素追加到此列表的末尾
//method2(list);
// public E getFirst•() 返回此列表中的第一个元素
// public E getLast•() 返回此列表中的最后一个元素
//method3(list);
// public E removeFirst•() 从此列表中删除并返回第一个元素
// public E removeLast•() 从此列表中删除并返回最后一个元素
//method4(list);
}
private static void method4(LinkedList<String> list) {
String first = list.removeFirst();
System.out.println(first);
String last = list.removeLast();
System.out.println(last);
System.out.println(list);
}
private static void method3(LinkedList<String> list) {
String first = list.getFirst();
String last = list.getLast();
System.out.println(first);
System.out.println(last);
}
private static void method2(LinkedList<String> list) {
list.addLast("www");
System.out.println(list);
}
private static void method1(LinkedList<String> list) {
list.addFirst("qqq");
System.out.println(list);
}
}
5.3 LinkedList-源码解析【难点】 (视频17) (13‘’)
1.add方法解析:
1.new LinkedList
2.list.add("aaa")
3.list.add("bbb")
4.list.add("ccc")
2.get方法解析:
get(Index) 首先判断索引离头近还是离尾近,如果离头从头查,如果离尾近从尾查
扩展练习
问答题【Collection接口】
1.1 请问Collection接口下有哪些类型的集合?它们分别是什么?
List 有序,有索引,元素可重复
Set 元素不可重复;
1.2 请问Collection接口中定义的方法,它的所有子类是否都有,而且都会实现这些方法?
是
1.3 请问向Collection集合添加一个元素用什么方法?
类名.add(元素)
1.4 请问从Collection集合中删除一个元素用什么方法?这个方法有返回值吗?
类名.remove(元素)返回true/fasle
1.5 请问判断Collection集合中是否包含一个元素用什么方法?
contains(),判断集合是否存在元素
1.6 请问用什么方法可以获取Collection集合中元素的数量?
类名.size
问答题【数据结构】
1 请写出数组结构的特点;
查看快,增加删除慢
2 请写出链表结构的特点
查看慢,增加删除快
3 请写出栈结构的特点;
先进后出
4 请写出队列结构的特点;
先进先出
编程题【Collection集合、迭代器】
题目1
请定义一个Collection类型的集合,存储以下字符串: “JavaEE企业级开发指南”,”Oracle高级编程”,”MySQL从入门到精通”,”Java架构师之路” 要求: 请编程实现以下功能: 使用迭代器遍历所有元素,并打印 使用迭代器遍历所有元素,筛选书名小于10个字符的,并打印; 使用迭代器遍历所有元素,筛选书名中包含“Java”的,并打印 如果书名中包含“Oracle”,则删掉此书。删掉后,遍历集合,打印所有书名。 (注意:以上每个功能都单独写个方法,在main方法中逐个调用测试即可)
效果:
参考代码:
package day7.No_1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("JavaEE企业级开发指南");
list.add("Oracle高级编程");
list.add("MySQL从入门到精通");
list.add("Java架构师之路");
System.out.println("遍历");
Iterator<String> it = list.iterator();
System.out.println("遍历为:");
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
System.out.println("-----------");
Iterator<String> it2 = list.iterator();
System.out.println("长度小于10的为:");
while (it2.hasNext()) {
String s = it2.next();
if (s.length() < 10) {
System.out.println( s);
}
}
System.out.println("-----------");
Iterator<String> it1 = list.iterator();
System.out.println("包含Java为:");
while (it1.hasNext()){
String s = it1.next();
if (s.contains("Java")){
System.out.println(s);
}
}
System.out.println("-----------");
Iterator<String> it3 = list.iterator();
while (it3.hasNext()){
String s = it3.next();
if (s.contains("Oracle")){
it3.remove();
System.out.println("Oracle已成功删除!");
}
}
System.out.println("-----------");
System.out.println("删除后为:"+list);
}
}
运行效果:
题目2
请定义一个Collection类型的集合,存储以下分数信息: 88.5,39.2,77.1,56.8,89.0,99.0,59.5
要求:
请编程实现以下功能: 使用增强for遍历所有元素,并打印 使用增强for遍历所有元素,打印不及格的分数; 使用增强for遍历所有元素,计算不及格的分数的数量,和平均分,并打印计算结果。 使用增强for遍历所有元素,求出最高分,并打印;
效果:
参考代码:
package day7.No_2; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection; public class Demo {
public static void main(String[] args) {
Collection <Double>list=new ArrayList<>();
list.add(88.5);
list.add(39.2);
list.add(77.1);
list.add(56.8);
list.add(89.0);
list.add(99.0);
list.add(59.5);
System.out.println("增强for遍历所有为:");
for (Double d : list) {
System.out.println(d);
}
System.out.println("不及格的为:");
for (Double d : list) {
if (d<60){
System.out.println(d);
}
}
int sum=0;
int Num=0;
for (Double d : list) {
if (d<60){
Num++;
sum+=d;
}
}
System.out.println("不及格人数为"+Num);
System.out.println("不及格平均分为"+(sum/Num));
System.out.println("-----------");
double max = Double.MIN_VALUE;
for (Double d : list) {
if (d>max){
max=d;
}
}
System.out.println("最高分为:"+max);
}
}
运行效果:
题目3
请定义方法找出集合中所有姓张的人并且年龄大于18岁的并全部返回,然后在main方法中输出返回的人; 集合原始数据有: 张三,22 李四,26 张翠山,38 赵六,19 张三丰,103 张无忌,17 赵敏,16
要求:
集合中的人需要以对象的形式存在,人只要有姓名和年龄两个成员变量即可;
注意:仔细思考一下自定义的方法要不要设计参数和返回值;
效果:
参考代码:
package day7.No_3; import java.util.ArrayList; public class Demo {
public static void main(String[] args) {
ArrayList<Ren> list = new ArrayList<>();
Ren r1 = new Ren("张三", 22);
Ren r2 = new Ren("李四", 26);
Ren r3 = new Ren("张翠山", 38);
Ren r4 = new Ren("赵六", 19);
Ren r5 = new Ren("张三丰", 103);
Ren r6 = new Ren("张无忌", 17);
Ren r7 = new Ren("赵敏", 16);
list.add(r1);
list.add(r2);
list.add(r3);
list.add(r4);
list.add(r5);
list.add(r6);
list.add(r7);
get(list);
} private static void get(ArrayList<Ren> list) {
System.out.println("大于18的人为:");
for (Ren ren : list) {
if (ren.getAge() > 18) {
System.out.println(ren);
}
}
}
} class Ren {
private String name;
private int age; @Override
public String toString() {
return "Ren{" +
"name='" + name + '\'' +
", 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;
} public Ren(String name, int age) {
this.name = name;
this.age = age;
} public Ren() {
}
}