文章目录
集合框架
概述：容器
作用：一次存储多个数据
特点：
长度可变
只能存储引用数据类型的数据
有很多的方法直接操作元素，方便
单列集合：一个元素由一部分构成
list.add("张三")
双列集合：一个元素由两部分构成------ key value形式 键值对形式
map.put("张三","18")
Collection接口
概述：Collection是单列集合的顶级接口
特点：
a.元素有序
b.元素可重复
c.没有索引
创建
Collection 集合名 = new ArrayList()
a.E:代表的是集合元素的具体类型
b.<>里面只能存储引用类型，如果啥也不写，默认为Object类型
----- 不对
---- 对
------对
等号右边的泛型可以空着
5.方法:
boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
void clear():清除集合中所有的元素
boolean contains(Object o) :判断当前集合中是否包含指定的元素
boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
boolean remove(Object o):将指定的元素从集合中删除
int size() :返回集合中的元素数。
Object[] toArray(): 把集合中的元素,存储到数组中
java
Collection<String> collection = new ArrayList<String>();
//往集合中添加元素
collection.add("李云龙");
collection.add("丁伟");
collection.add("孔捷");
collection.add("楚云飞");
System.out.println(collection);
//将另一个集合元素添加到当前集合中，集合合并
Collection<String> collection1 = new ArrayList<String >();
collection1.add("魏大勇");
collection1.add("大彪");
collection1.add("段鹏");
System.out.println(collection1);
//将另一个集合元素添加到当前集合中(集合合并)
collection1.addAll(collection);
System.out.println(collection1);
//清除集合中所有的元素
collection1.clear();
System.out.println(collection1);
//判断当前集合中是否包含指定元素
System.out.println(collection.contains("李云龙"));
//将指定的元素从集合中删除
collection.remove("孔捷");
System.out.println(collection);
//返回集合中的元素数
System.out.println("collection.size() = " + collection.size());
//将集合中的元素存储到数组中
Object[] array = collection.toArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);}迭代器
迭代器基本使用
概述：Iterator接口
作用: 遍历集合
获取 Collection中的方法 Iterator iterator()
方法： boolean hasNext（） ---- 判断集合还有没有下一个元素
E next ---- 获取下一个元素
java
public class test02 {
public static void main(String[] args) {
Collection<String> collection = new ArrayList<String>();
collection.add("李云龙");
collection.add("丁伟");
collection.add("孔捷");
//定义一个迭代器
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()){
String element1 = iterator.next();
//String element2 = iterator.next();
System.out.println("element1 = " + element1);
//System.out.println("element2 = " + element2);
}
}
}注意：使用i迭代器时尽量不要连续调用多次next方法获取元素，防止报错
迭代器底层原理
只有ArrayList集合使用迭代器的时候Iterator指向的是Itr，其他集合不一定，比如HashSet集合
java
public class test03 {
public static void main(String[] args) {
final HashSet<String> set = new HashSet<>();
set.add("孙悟空");
set.add("猪八戒");
set.add("唐僧");
set.add("沙和尚");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}并不是顺序输出
并发修改异常
我们定义一个集合，存储亮剑中三个团长，遍历集合，在遍历的过程中，如果获取出来的是李云龙，就直接在集合中添加"张大彪"
java
public class test04 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("李云龙");
list.add("孔捷");
list.add("丁伟");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String element = iterator.next();
if ("李云龙".equals(element)){
list.add("张大彪");
}
}
System.out.println(list);
}
}我么发现报错：ConcurrentModificationException
modCount：实际操作次数
expectionModCount:预期操作次数
结论：当实际操作次数和预期操作次数不相等时，出现并发修改异常
总结：当我们调用add方法，底层单独给modCount+1，但是没有重新将更改后的modCount赋值给二线expectionModCount
再调用next方法时，next方法底层做了一个判断，当实际操作次数和预期操作次数不相等时，出现并发修改异常
拓展：ArrayList集合中的方法：ListIterator()
数据结构
学过数据机构的同学们，对此章节可能会比较了解，这里不做详细的介绍，只简单的过一下 ·
栈
特点： 先进后出
队列
特点：先进先出
数组
特点 查询快，增删慢
查询快：有索引，我们可以通过索引获取对应的元素
增删慢：定长
添加元素：先创建一个新的数组，指定新长度，将老数组的元素复制到新数组中，再添加新的元素
删除元素：先创建一个新的数组，指定新新长度，将老数组的元素复制到新数组中
链表
特点：查询慢，增删快
分类：
单向链表：一个字节分两部分
前面的字节记录后面字节的地址
后面字节不记录前面字节的地址
如果集合底层数据结构用的是单向链表，无法保证元素有序
双向链表：一个字节分三部分
前面的字节机会后面字节的地址
后米娜的字节记录前面字节的地址
如果集合底层数据结构用的是双向链表，能够保证元素有序
List接口
概述：list接口是Collection接口的子接口
实现类
ArrayList，LinkedList，Vector
4.常用方法:
boolean add(E e) -> 将元素添加到集合中->尾部(add方法一定能添加成功的,所以我们不用boolean接收返回值)
void add(int index, E element) ->在指定索引位置上添加元素
boolean remove(Object o) ->删除指定的元素,删除成功为true,失败为false
E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的那个元素
E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素
E get(int index) -> 根据索引获取元素
int size() -> 获取集合元素个数
java
public class test05 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("李云龙");
list.add("丁伟");
list.add("孔捷");
list.add("张大彪");
list.add("魏大勇");
list.add("段鹏");
//往指定位置添加元素
list.add(3,"楚云飞");
//删除指定元素,删除成功返回true，失败返回false
list.remove("楚云飞");
//删除指定位置的元素，返回值为删除的元素
System.out.println(list.remove(0));
//将指定索引位置上的元素，修改为后面的元素,返回值为被替换元素的值
System.out.println(list.set(1, "李云龙"));
// System.out.println(list);
//根据索引获取元素
System.out.println(list.get(2));
//获取集合元素的个数
System.out.println(list.size());
//快速遍历集合的方法
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}底层源码分析
ArrayList是一个集合，集合的长度是可变的，ArrayList底层数据结构数组，所以需要进行数组扩容使得数组长度可变
rrayList有一个空参构造： ArrayList() 构造一个初始容量为10的空列表
注意：不是 new就创建一个长的为10的空列表
而是第一次add的时候才会创建长度为10的空列表
扩容方式为
elementData = Arrays.copyOf(elementData, newCapacity);->数组扩容,数组复制
扩容1.5倍
LinkList集合
基本使用
概述：是List接口下的实现类
特点：
a.元素有序
b.元素可重复
c.有索引
d.线程不安全
数据结构双向链表
LinkList 将来我们有可能有大量的首位元素的操作，LinkList有很多特有方法
这些特有防火阀都是直接操作首位元素的
.方法:
public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。
public boolean isEmpty()：如果列表不包含元素，则返回true。
java
public class test06 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
System.out.println("农药的龙年王者限定皮肤");
list.add("赵云");
list.add("孙尚香");
list.add("孙策");
list.add("安其拉");
list.add("大乔");
System.out.println(list);
//将指定元素插入到列表开头
list.addFirst("龙年限定");
//将指定元素插入得到列表结尾
list.addLast("就这五个");
//返回列表的第一个元素
System.out.println(list.getFirst());
//返回列表的最后一个元素
System.out.println(list.getLast());
//移出并返回列表的第一个元素
System.out.println(list.removeFirst());
//移出并返回列表的最后一个元素
System.out.println(list.removeLast());
//从此列表表示的堆栈处弹出一个元素，底层调用removFirst
list.pop();
//将元素推入到次列表所表示的堆栈，底层调用addFirst
list.push("龙年限定");
}
}LinkedList底层成员解释说明
1.LinkedList底层成员
transient int size = 0; 元素个数
transient Node first; 第一个节点对象
transient Node last; 最后一个节点对象
2.Node代表的是结点对象
private static class Node {
E item;//节点上的元素
Node next;//记录着下一个节点地址
Node prev;//记录着上一个节点地址
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}LinkedList中get方法的源码分析
java
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}LinkedList中add方法的源码分析
java
LinkedList<String> list = new LinkedList<>();
list.add("a");
list.add("b");
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}增强for
增强for的介绍以及基本使用发
作用 遍历集合或者数组
格式
for(元素的数据类型 变量名:要遍历的集合名或者数组名){
变量代表的就是每一个元素
}
快捷键
集合名或者数组名.,for
java
ArrayList<String> list = new ArrayList<>();
list.add("李云龙");
list.add("丁伟");
list.add("孔捷");
list.add("张大彪");
list.add("魏大勇");
list.add("段鹏");
for (String s : list) {
System.out.println(s);
}
int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println(i);
}2.使用增强for的注意事项
1.在使用增强for遍历集合的时候尽量也不要随意改变集合长度,不然也会出现"并发修改异常"
a.增强for在遍历集合的时候,实现原理为迭代器
b.增强for在遍历数组的时候,实现原理为普通for
java
public class test07 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("李云龙");
list.add("丁伟");
list.add("孔捷");
list.add("张大彪");
list.add("魏大勇");
list.add("段鹏");
for (String s : list) {
System.out.println(s);
}
int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
System.out.println(i);
}集合工具类
概述：Collections集合工具类
特点
构造私有
成员方法是静态的
使用
类名直接调用
常用方法
static boolean addAll(Collection<? super T> c, T... elements)->批量将元素存到集合中 static void shuffle(List<?> list) -> 将集合中的元素顺序打乱
static void sort(List list) ->将集合中的元素按照默认规则排序->ASCII
static void sort(List list, Comparator<? super T> c)->将集合中的元素按照指定规则排序
java
public class test01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//批量将元素存到集合中
Collections.addAll(list,"李玉龙","孔捷","丁伟");
System.out.println(list);
System.out.println("============================");
//将集合中的元素打乱
Collections.shuffle(list);
System.out.println(list);
//将集合中的元素按照默认规则排序 ASCII
Collections.sort(list);
System.out.println(list);
}
}比较器
概述 Comparator：接口--比较器
方法：
int compare(T o1,T o2) ----- 设置比较规则
o1-o2 ----- 升序
o2-o1 ------降序
相关代码，首先构造javabean
java
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
}
public Person(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 "Person{" + name + '\'' + ",age：" +age+'}';
}
@Override
public int compareTo(Person o) {
return o.getAge() - this.getAge();
}
}构建测试类
java
public class test01{
public static void main(String[] args) {
final ArrayList<Person> list = new ArrayList<>();
list.add(new Person("刘备",30));
list.add(new Person("关羽",48));
list.add(new Person("张飞",45));
System.out.println(list);
//由于sort继承comparable.调用重写的方法
Collections.sort(list);
System.out.println(list);
}
}泛型
使用
注意：
泛型中写的类型都是引用数据类型
如果<>中什么都不写，元素默认类型为Object类型
为什么要使用泛型
从使用上看，如果使用了泛型，规定了数据类型，那么数据类型是一致的，防止了类型转换异常
从定义上看，定义泛型以后，在使用的时候确定啥类型，泛型就是啥类型，通用
泛型的定义
含有泛型的类
定义格式：
piublc class 类名{ }
什么时候确定泛型类型
new对象的时候确定类型
java
public class MyArrayList <E>{
public void add(E e){
System.out.println(e);
}
}
java
public class test02 {
public static void main(String[] args) {
final MyArrayList<String> list = new MyArrayList<>();
list.add("李云龙");
final MyArrayList<Integer> list1 = new MyArrayList<>();
list1.add(123);
}
}含有泛型的方法
格式 修饰符 返回值类型 方法名(E e) { }
调用的时候确定类型
java
public class Mylist {
public <E> void add(E e){
System.out.println(e);
}
}测试类
java
public class test03 {
public static void main(String[] args) {
final Mylist mylist = new Mylist();
mylist.add(1);
mylist.add("李云龙");
}
}含有泛型的接口
格式 public interfa 接口名{}
什么时候确定类型
在实现类的时候确定类型 比如Scanner
在实现类的时候还不确定类型，只能在new的时候确定类型 ---- 比如 ArrayList
java
public interface MyList <E>{
public void add(E e);
}
java
public class MyScanner implements MyList<String>{
@Override
public void add(String s) {
System.out.println(s);
}
}
java
public class MyScanner implements MyList<String>{
@Override
public void add(String s) {
System.out.println(s);
}
}
java
public class Test01 {
public static void main(String[] args) {
MyScanner myScanner = new MyScanner();
myScanner.add("哈哈哈");
}
}泛型的高级使用
什么时候使用泛型通配符：参数位置当不知道接收什么类型时 ------ 一般用在集合方面
用在什么位置上 一般用在参数位置上
java
import java.util.ArrayList;
public class test06 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("李云龙");
list.add("孔捷");
list.add("丁伟");
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
method(list);
method(list1);
}
public static void method(ArrayList<?> list){
for (Object o : list) {
System.out.println(o);
}
}
}泛型的上限和下限
泛型通配符的高级使用 受限泛型
上限：
a.格式： 类型名称<? extends 类> 对象名
b,意义：？只能接收extends后面的本类以及子类
下限
a.格式：类型名称<? super 类> 对象名
b.意义： ？只能接受super后面的本类以及父类
java
import java.util.ArrayList;
import java.util.Collection;
public class test07 {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
Collection<Number> list3 = new ArrayList<>();
Collection<Object> list4 = new ArrayList<>();
getElement1(list1);
//getElement1(list2); 报错
getElement1(list3);
//getElement1(list4); 报错
System.out.println("================================");
//getElement2(list1); 报错
//getElement2(list2); 报错
getElement2(list3);
getElement2(list4);
}
// 上限 ？只能接受extends后面的本类以及子类
public static void getElement1(Collection<? extends Number> collection){
}
//下限 ？只能接受super后的本类以及父类
public static void getElement2(Collection<? super Number> collection){
}
}