黑马教程强化day1-2
目录
- 一、认识集合
-
- 1.定义
- 2.集合体系（总体架构）
- 3.集合（Collection）细致架构（主要，因为有很多）
- 4.Collection集合特点：
- 5.代码演示
- 二、Collection的功能
-
- 1.含义
- 2.代码演示
- 三、Collection遍历方式
-
- 1.迭代器遍历
- 2.增强for循环
- 3.Lambda表达式
- 4.代码演示
- 四、三种遍历的区别
-
- 1.前提：认识并发修改异常问题：
- 2.代码演示
- 五、List集合
-
- 1.定义
- 2.代码演示
- 六、ArrayList和LinkedList
-
- 1.ArrayList
- 2.LinkedList
- 3.代码演示
一、认识集合
1.定义
集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也非常常用。
2.集合体系（总体架构）
- Collection：单列集合：每个元素只包含一个值。（现在学习这个）
- Map：双列集合：每个元素包含两个值（键值对）
3.集合（Collection）细致架构（主要，因为有很多）
- 接口：Collection（老大）
- 实现类分支：List;Set（左右护卫）
- List：ArrayList;LinkedList（左护卫小弟）
- Set：HashSet;TreeSet（右护卫小弟）
- HashSet：LinkedHashSet（右护卫跑腿）
4.Collection集合特点：
- List系列集合：添加的元素是有序、可重复、有索引的。
- Set系列集合：添加的元素是无序、不重复、无索引的。
** Ha：无序、不重复，无索引；
** Lin：有序，不重复，无索引
** Tree：按照大小默认升序排序，不重复，无索引。
5.代码演示
package com.it.democollection;
import java.util.ArrayList;
import java.util.*;
public class democollection1 {
public static void main(String[] args) {
//1.List家族集合：添加的元素是有序、可重复、有索引的。
List<String> list=new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
System.out.println(list);
System.out.println(list.get(0));
System.out.println("--------");
//2.set家族集合：添加的元素是无序、不重复、无索引的。
Set<String> set=new HashSet<>();
set.add("hello");
set.add("adad");
set.add("adad");
set.add("adad1");//[hello, adad, adad1]
//set.get(0);报错，没有
System.out.println(set);
}
}
二、Collection的功能
1.含义
清楚Collection提供的通用集合功能，因为在这个体系之下，都是继承Collection的功能。
2.代码演示
package com.it.democollection;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
/**清楚Collection提供的通用集合功能，因为在这个体系之下，都是继承Collection的功能。*/
public class democollection2 {
public static void main(String[] args) {
Collection<String> collection=new ArrayList<>();
collection.add("hello");
collection.add("world");
collection.add("java");
System.out.println(collection);
//获取集合的元素个数
System.out.println(collection.size());
//删除集合元素
collection.remove("world");
System.out.println(collection);
//判断集合是否为空
System.out.println(collection.isEmpty());
//判断集合是否存在某个数据
System.out.println(collection.contains("java"));
//清空集合
collection.clear();
System.out.println(collection);
//把集合转化成数组
Object[] objects=collection.toArray();
System.out.println(objects);
//把集合转化为字符串数组
String[] strings=collection.toArray(String[]::new);
System.out.println(strings);
}
}
三、Collection遍历方式
1.迭代器遍历
迭代器是用来遍历集合的专用方式（数组中没有迭代器），在java中迭代器的代表是lterator.
2.增强for循环
格式：
for（元素的数据类型 变量名：数组或者集合{
}
增强for可以遍历集合或者数组。本质是迭代器遍历集合的简单写法。
3.Lambda表达式
需要调用forEach方法。
4.代码演示
package com.it.democollection;
import java.util.*;
import java.util.function.Consumer;
public class democollection3 {
public static void main(String[] args) {
Collection<String> names= new ArrayList<>();
names.add("张三");
names.add("张一");
names.add("张二");
names.add("张四");
System.out.println(names);//[张三, 张一, 张二, 张四]
//1.得到这个集合的迭代器对象
Iterator<String> it=names.iterator();
System.out.println(it.next());//Next取数据并移到下一位。
//判断集合hasNext（）中是否有数据
while(it.hasNext()){
String name=it.next();
System.out.println(name);
}
System.out.println("------------------");
//2.增强for
for(String name:names){
System.out.println(name);
}
System.out.println("------------------");
//3.Lambda
names.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});//需要看源码
System.out.println("------------------");
//简化
names.forEach(s-> System.out.println(s));
System.out.println("------------------");
//再简化
names.forEach(System.out::println);
}
}
四、三种遍历的区别
1.前提：认识并发修改异常问题：
含义遍历集合的同时又存在增删集合的行为时可能出现业务异常，这种现象被称之为并发修改异常问题。
2.代码演示
package com.it.democollection;
import java.util.* ;
public class democollection4 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("hello");
list.add("world");
list.add("枸杞");
list.add("枸杞子");
list.add("黑枸杞");
list.add("宁夏枸杞");
list.add("java");
//需求1，删除全部枸杞
for (int i = 0; i < list.size(); i++) {
if (list.get(i).contains("枸杞")){
list.remove(i);
}
}
//没有删除干净，所以有了并发修改异常
System.out.println(list);//[hello, world, 枸杞子, 宁夏枸杞, java]
System.out.println("==============");
//正确方法：演示正向，也可以是反向删除，但是要有索引
ArrayList<String> list2=new ArrayList<>();
list2.add("hello");
list2.add("world");
list2.add("枸杞");
list2.add("枸杞子");
list2.add("黑枸杞");
list2.add("宁夏枸杞");
list2.add("java");
for (int i = 0; i < list2.size(); i++) {
if (list2.get(i).contains("枸杞")){
list2.remove(i);
i--;
}
}
System.out.println(list2);//[hello, world, java],此时正确，因为删除的时候，后面数据跟上，导致数据错位。
System.out.println("============");
ArrayList<String> list3=new ArrayList<>();
list3.add("hello");
list3.add("world");
list3.add("枸杞");
list3.add("枸杞子");
list3.add("黑枸杞");
list3.add("宁夏枸杞");
list3.add("java");
//方案一：迭代器遍历删除全部枸杞，也存在并发删除异常
Iterator<String> it=list3.iterator();
while(it.hasNext()){
String name=it.next();
if(name.contains("枸杞")){
//list3.remove(name);//运行报错，因为迭代器对象在删除元素时，会报ConcurrentModificationException
it.remove();//这样不报错。
}
}
System.out.println(list3);
//方案三、二：用增强for还有Lambda（都没有办法解决修改并发异常）（不在演示）
//for和Lambda只适合做遍历，不适合修改。
}
}
五、List集合
1.定义
List系列集合：添加的元素是有序、可重复、有索引的。
ArrayList;LinkedList：添加的元素是有序、可重复、有索引的。
package com.it.democollection;
2.代码演示
import java.util.*;
public class democollection5 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("枸杞");
list.add("枸杞子");
System.out.println(list);
System.out.println("==============");
//在第三个位置插入一个数据，宁夏枸杞
list.add(2,"宁夏枸杞");
System.out.println(list);
System.out.println("==============");
//删除枸杞
list.remove("枸杞");
System.out.println(list);
System.out.println("==============");
//修改枸杞子为你好
list.set(2,"你好");
System.out.println(list);
System.out.println("==============");
//获取hello
System.out.println(list.get(0));
System.out.println("==============");
System.out.println("四种循环");
//1.for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("==============");
//2.增强for循环
for (String s : list) {
System.out.println(s);
}
System.out.println("==============");
//3.迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("==============");
//4.lambda表达式
list.forEach(lsit -> System.out.println(list));
}
}
六、ArrayList和LinkedList
1.ArrayList
底层是基于数组存储数据的。
特点：
- 1.查询速度块
- 2.增删数据效率低：可能需要把后面的很多数据进行迁移
2.LinkedList
底层是基于链表存储数据的。
特点：
- 1.链表中的数据是一个一个独立的结点组成的，结点在内存中是不连续的，每个结点包含数据值和下一个结点的地址。
- 2.查询慢，无论查询那个数据都要从头开始找
- 3.增删相对块
- 4.基于双向列表实现的。：所以新增了首位操作的特有方法
应用场景：
- 可以用来设计队列
- 可以用来设计栈
3.代码演示
主要展示LinkedList；ArrayList集合在前面已经基本都实现过。
package com.it.democollection;
import java.util.*;
public class democollection6 {
public static void main(String[] args) {
List<String> queue = new LinkedList<String>();
//入队
queue.add("hello");
queue.add("world");
queue.add("java");
queue.add("枸杞");
System.out.println(queue);
//出队
System.out.println(queue.removeFirst());//hello
System.out.println(queue.removeFirst());//world
System.out.println(queue);//java,枸杞
//做一个栈
LinkedList<String> stack = new LinkedList<>();
//压栈
stack.addFirst("hello");
stack.addFirst("world");
stack.addFirst("java");
System.out.println(stack);//[java, world, hello]
//出栈
System.out.println(stack.removeFirst());
System.out.println(stack.removeFirst());
System.out.println(stack.removeFirst());
System.out.println(stack);
}
}