Java语言入门到精通章节
笔记小结：见各个小节
笔记小结：
概述：集合分为单列集合与双列集合
特点：
单列集合：
- List系列集合：有序、可重复的集合
- Set系列集合：无序、不可重复的集合
- 详细：见各个小结
双列集合：
- HashMap: 基于哈希表实现，可以存储null键和null值，不保证元素的顺序
- TreeMap: 基于红黑树实现，按照键的自然顺序或者自定义的比较器排序，不允许有null键，但可以有null值
单列集合应用场景：
Java中的集合类是用于存储、操作和管理一组对象的容器。其中集合可分类为单列集合、双列集合
在 Java 中，单列集合指的是只能保存一个元素序列的集合，例如 List、Set 和 Queue 等。双列集合则指的是可以保存键值对的集合，例如 Map 等。单列集合和双列集合在保存和操作数据时的方式和目的有所不同
单列集合又分为：List系列集合、Set系列集合
补充：
- List系列集合：有序、可重复的集合。可以通过索引来访问其中的元素，可以存储重复的元素
- Set系列集合：无序、不可重复的集合。不能通过索引来访问其中的元素，不可以存储重复的元素
Java中的双列集合是指可以存储键值对数据结构的集合，也称为映射表或关联数组
补充：
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复
笔记小结：
概述：Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的
常用成员方法;add、clear、remove、contains、isEmpty、size
遍历方式
迭代器：
概述：迭代器是集合专用的遍历方式，迭代器在遍历集合的时候是不依赖索引的
使用：迭代器需要掌握三个方法
while (it.hasNext()) { String s = it.next(); System.out.println(s); }细节：
- 当迭代器中无元素或元素遍历完成，再次调用it.next()方法，则报错NoSuchElementException
迭代器遍历完毕，指针不会复位
- 循环中只能用一次next方法（因为next方法会做两件事，分别是获取元素和移动指针）
迭代器遍历时，不能用集合的方法进行增加或者删除，否则报错ConcurrentModificationException
原理：可参考知识加油站
增强for循环：
概述：其内部原理是一个Iterator迭代器
格式：
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可}//例如for(string s : list){System.out.println(s);}注意：**修改增强for中的变量，不会改变集合中原本的数据，**因为是通过第三方变量进行赋值
Lambda表达式
概述：更简单、更直接的遍历集合的方式
格式：
forEach(Consumer<? super T> action)//例如coll.forEach(s -> System.out.println(s));底层原理：其实也会自己遍历集合，依次得到每一个元素。把得到的每一个元素，传递给下面的accept方法。s依次表示集合中的每一个数据
Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的
注意：
ollection是一个接口,我们不能直接创建他的对象。所以，现在我们学习他的方法时，只能创建他实现类的对象
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| boolean removeIf(Object o) | 根据条件进行移除 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll);
Collection<String> coll = new ArrayList<>();
coll.clear();
Collection<String> coll = new ArrayList<>();
System.out.ve("aaa"));
System.out.println(coll);
Collection<String> coll = new ArrayList<>();
boolean result1 = ains("bbb");
System.out.println(result1);
Collection<String> coll = new ArrayList<>();
boolean result2 = coll.isEmpty();
System.out.println(result2);//false
Collection<String> coll = new ArrayList<>();
coll.add("ddd");
int size = coll.size();
System.out.println(size);//3
//1.创建集合的对象
Collection<Student> coll = new ArrayList<>();//2.创建三个学生对象
Student s1 = new Student("zhangsan",23);
Student s2 = new Student("lisi",24);
Student s3 = new Student("wangwu",25);//3.把学生对象添加到集合当中
coll.add(s1);
coll.add(s2);
coll.add(s3);//4.判断集合中某一个学生对象是否包含
Student s4 = new Student("zhangsan",23);
//因为contains方法在底层依赖equals方法判断对象是否一致的。
//如果存的是自定义对象，没有重写equals方法，那么默认使用Object类中的equals方法进行判断，而Object类中equals方法，依赖地址值进行判断。
//需求：如果同姓名和同年龄，就认为是同一个学生。
//所以，需要在自定义的Javabean类中，重写equals方法就可以了。
System.out.ains(s4));
概述：迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式
Collection集合获取迭代器
Iterator中的常用成员方法
代码示例：
public class IteratorDemo1 {public static void main(String[] args) {//创建集合对象Collection<String> c = new ArrayList<>();//添加元素c.add("hello");c.add("world");c.add("java");c.add("javaee");//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到Iterator<String> it = c.iterator(); // 1.获取迭代器//用while循环改进元素的判断和获取while (it.hasNext()) { // 2.判断是否有元素String s = it.next(); // 3.获取元素 // 4.移动指针System.out.println(s);}}
}
说明：
迭代器运行流程：
- 创建指针
- 判断是否有元素
- 获取元素
- 移动指针
注意：
1，当迭代器中无元素或元素遍历完成，再次调用it.next()方法，则报错NoSuchElementException
2，迭代器遍历完毕，指针不会复位
3，循环中只能用一次next方法（因为next方法会做两件事，分别是获取元素和移动指针）
4，迭代器遍历时，不能用集合的方法进行增加或者删除，否则报错ConcurrentModificationException
迭代器删除
void remove(): 删除迭代器对象当前指向的元素
示例：
public class IteratorDemo2 {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);}
}
注意：
迭代器遍历时，不能用集合的方法进行增加或者删除，否则报错ConcurrentModificationException
格式：
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
//例如
for(string s : list){System.out.println(s);
}
示例：
public class MyCollectonDemo1 {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);}}
}
注意：
**修改增强for中的变量，不会改变集合中原本的数据，**因为是通过第三方变量进行赋值
概述：得益于JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。
常用成员方法：
示例：
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
coll.forEach(s -> System.out.println(s));
注意：
底层原理：其实也会自己遍历集合，依次得到每一个元素。把得到的每一个元素，传递给下面的accept方法。s依次表示集合中的每一个数据
笔记小结：
概述：List是Java中常用的集合类型之一，用于存储有序、可重复的元素序列
常用成员方法：add、remove、set、get
遍历方式：参见Collection集合遍历方式
Collection的方法List都继承了集合的方法列表都继承了，List集合因为有索引，所以多了很多索引操作的方法。列出集合因为有索引，所以多了很多索引操作的方法。
特点
| 方法名 | 描述 |
|---|---|
| E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
| E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| E get(int index) | 返回指定索引处的元素 |
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");//1
list.add("ccc");
// 或者
list.add(1,"QQQ") // 在此集合中的指定位置插入指定的元素
注意：
原来索引上的元素会依次往后移
List<String> list = new ArrayList<>();
String remove = ve(0); //删除指定索引处的元素，返回被删除的元素
System.out.println(remove);//aaa
List<String> list = new ArrayList<>();
String result = list.set(0, "QQQ"); //修改指定索引处的元素，返回被修改的元素
System.out.println(result);
List<String> list = new ArrayList<>();
String s = (0); //返回指定索引处的元素
System.out.println(s);
public class MyListDemo {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 = (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 = ve(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);}
}
说明：此遍历方式，参考Collection集合遍历方式
基本用例
package com.itheima.a02mylist;import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;public class A03_ListDemo3 {public static void main(String[] args) {/*List系列集合的五种遍历方式：1.迭代器2.列表迭代器3.增强for4.Lambda表达式5.普通for循环*///创建集合并添加元素List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");//1.迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String str = it.next();System.out.println(str);}//2.增强for//下面的变量s，其实就是一个第三方的变量而已。//在循环的过程中，依次表示集合中的每一个元素for (String s : list) {System.out.println(s);}//3.Lambda表达式//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素//并把每一个元素传递给下面的accept方法//accept方法的形参s，依次表示集合中的每一个元素list.forEach(s->System.out.println(s) );//4.普通for循环//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素for (int i = 0; i < list.size(); i++) {//i:依次表示集合中的每一个索引String s = (i);System.out.println(s);}// 5.列表迭代器//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的//额外添加了一个方法：在遍历的过程中，可以添加元素ListIterator<String> it = list.listIterator();while(it.hasNext()){String str = it.next();if("bbb".equals(str)){//qqqit.add("qqq");}}System.out.println(list);}
}
笔记小结：
- 概述;ArrayList是Java中的一个类，它实现了List接口，是一种基于动态数组实现的集合类
- 常用成员方法：
- 构造方法：ArrayList()
- 成员方法：add、remove、set、get、size
- 底层原理：
- 利用空参创建的集合，在底层创建一个默认长度为0的数组
- 添加第一个元素时，底层会创建一个新的长度为10的数组存满时，会扩容1.5倍
- 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
什么是集合
提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
ArrayList集合的特点
长度可以变化，只能存储引用数据类型。
泛型的使用
用于约束集合中存储元素的数据类型
| 方法名 | 说明 |
|---|---|
| public ArrayList() | 创建一个空的集合对象 |
| 方法名 | 说明 |
|---|---|
| public boolean add(要添加的元素) | 将指定的元素追加到此集合的末尾 |
| public boolean remove(要删除的元素) | 删除指定元素,返回值表示是否删除成功 |
| public E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中的元素的个数 |
示例：
public class ArrayListDemo02 {public static void main(String[] args) {//创建集合ArrayList<String> array = new ArrayList<String>();//添加元素array.add("hello");array.add("world");array.add("java");//public boolean remove(Object o)：删除指定的元素，返回删除是否成功// System.out.ve("world"));// System.out.ve("javaee"));//public E remove(int index)：删除指定索引处的元素，返回被删除的元素// System.out.ve(1));//IndexOutOfBoundsException// System.out.ve(3));//public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素// System.out.println(array.set(1,"javaee"));//IndexOutOfBoundsException// System.out.println(array.set(3,"javaee"));//public E get(int index)：返回指定索引处的元素// System.out.(0));// System.out.(1));// System.out.(2));//System.out.(3)); //？？？？？？ 自己测试//public int size()：返回集合中的元素的个数System.out.println(array.size());//输出集合System.out.println("array:" + array);}
}
说明：
当长度为m(m<=10)的数组，添加少于n(n<10)个元素时，底层实际数组长度为10
当长度为m(m<=10)的数组，添加多余n(n>10)个元素时，底层实际长度为n+10
当长度为m(m>10)的数组，添加少于n(n<10)个元素时，底层实际数组长度为m*1.5
当长度为m(m>10)的数组，添加多余n(n>10)个元素时，底层实际数组长度为m+n
源码分析：
transient Object[] elementData; // non-private to simplify nested class accessArrayList底层是一个数组
添加一个元素
添加十个元素
笔记小结：
- 概述：LinkedList是Java集合框架中的一个双向链表实现类，可以用来存储一组有序的元素。LinkedList本身多了很多直接操作首尾元素的特有API
- 常用成员方法：addFirst、addLast、getFirst、getLast、removeFirst、removeLast
- 底层原理：底层数据结构是双链表，查询慢，增删快，但是如果操作的是首尾元素，速度也是极快的。
LinkedList是Java集合框架中的一个双向链表实现类，可以用来存储一组有序的元素。LinkedList的元素是通过链表连接在一起的，每个元素都包含了一个指向前一个元素和后一个元素的引用。因此，插入和删除元素的时间复杂度是O(1)的，而随机访问元素的时**间复杂度是O(n)**的，其中n是LinkedList中元素的个数。
| 方法名 | 说明 |
|---|---|
| public void addFirst(E e) | 在该列表开头插入指定的元素 |
| public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
| public E getFirst() | 返回此列表中的第一个元素 |
| public E getLast() | 返回此列表中的最后一个元素 |
| public E removeFirst() | 从此列表中删除并返回第一个元素 |
| public E removeLast() | 从此列表中删除并返回最后一个元素 |
示例：
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 = veFirst();System.out.println(first);String last = veLast();System.out.println(last);System.out.println(list);}private static void method3(LinkedList<String> list) {String first = First();String last = Last();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);}
}
说明：
当添加第1个元素时，会将头结点和尾结点指向第1个元素，并且第1元素的前索引和后索引都为空
说明：
当添加第n个元素时，会将尾结点指向第n个元素，并且第n个元素前索引为n-1,第n个元素后索引为空
笔记小结：
概述：它用于存储不重复的元素
常用成员方法：
方法名 说明 boolean add(E e) 添加元素 boolean remove(Object o) 从集合中移除指定的元素 boolean removeIf(Object o) 根据条件进行移除 void clear() 清空集合中的元素 boolean contains(Object o) 判断集合中是否存在指定的元素 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中元素的个数 遍历方式：
Set集合是Java集合框架中的一种，它用于存储不重复的元素，具有无序性。
特点：
| 方法名 | 说明 |
|---|---|
| boolean add(E e) | 添加元素 |
| boolean remove(Object o) | 从集合中移除指定的元素 |
| boolean removeIf(Object o) | 根据条件进行移除 |
| void clear() | 清空集合中的元素 |
| boolean contains(Object o) | 判断集合中是否存在指定的元素 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中元素的个数 |
说明：
Set集合的方法基本上雨Collection的API一致
此遍历方式，参考Collection集合遍历方式
示例：
public class A01_SetDemo1 {public static void main(String[] args) {/*利用Set系列的集合，添加字符串，并使用多种方式遍历。迭代器增强forLambda表达式*///1.创建一个Set集合的对象Set<String> s = new HashSet<>();//2,添加元素//如果当前元素是第一次添加，那么可以添加成功，返回true//如果当前元素是第二次添加，那么添加失败，返回falses.add("张三");s.add("张三");s.add("李四");s.add("王五");//3.打印集合//无序System.out.println(s);//[李四, 张三, 王五]//迭代器遍历Iterator<String> it = s.iterator();while (it.hasNext()){String str = it.next();System.out.println(str);}//增强forfor (String str : s) {System.out.println(str);}// Lambda表达式s.forEach( str->System.out.println(str));}
}
笔记小结：
- 概述：它是基于哈希表实现的，可以存储无序的、不重复的元素
- 底层原理：
- HashSet集合底层采取哈希表存储数据
- 哈希表是一种对于增删改查数据性能都较好的结构
- HashSet的三个问题;
- HashSet为什么存和取的顺序不一样?
- 答案：链表中添加的数据不是按照指定的顺序存储的，数据在链表中的添加顺序不同，因此存和取的顺序不一样。
- HashSet为什么没有索引?
- 答案：HashSet底层是由数组、链表、红黑树组成。此时，在1索引的位置下挂着一个链表，如此多的元素都为1索引，看起来不合适，因此就取消掉了索引的机制
- HashSet是利用什么机制保证数据去重的?
- 答案：HashSet是根据HashCode和equals方法，进行判断元素是否相同
哈希值
含义：对象的整数表现形式
概述：
对象的哈希值特点：
如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。(哈希碰撞)
int的取值范围用将近42亿中，如果此时创建50亿个对象，就有可能8亿hash值相同
示例：
//1.创建对象Student s1 = new Student("zhangsan",23);Student s2 = new Student("zhangsan",23);//2.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的// 如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的System.out.println(s1.hashCode());//-1461067292System.out.println(s2.hashCode());//-1461067292//在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。//哈希碰撞System.out.println("abc".hashCode());//96354System.out.println("acD".hashCode());//96354
HashSet底层原理
哈希表组成
JDK1.8以前：
JDK1.8以后：
节点个数少于等于8个
数组 + 链表
节点个数多于8个
数组 + 红黑树
说明：
加载因子：又叫HashSet的扩容时机
当数组内存储了16x0.75 = 12个元素时，次数数组的长度会扩容到原来的两倍，也就是32
当链表长度大于8而且数组长度大于等于64，链表就会转换为红黑树
底层流程：
说明：
当遍历数组时，下标为1索引时，存储为链表。链表中添加的数据不是按照指定的顺序存储的，数据在链表中的添加顺序不同，因此存和取的顺序不一样。HashSet的存储索引是 通过hashCode方法算出来的int类型的整数。
说明：
HashSet底层是又数组、链表、红黑树组成。此时，在1索引的位置下挂着一个链表，如此多的元素都为1索引，看起来不合适，因此就取消掉了索引的机制
说明：
HashSet是根据HashCode和equals方法，进行判断元素是否相同，若相同则不会添加到数组、链表或者红黑树当中。因此，在像HashSet中添加自定义对象是，一定要记得重写HashCode和equals方法，让底层的Hash值是根据对象的属性来生成
示例：
public class HashSetDemo02 {public static void main(String[] args) {//创建HashSet集合对象HashSet<Student> hs = new HashSet<Student>();//创建学生对象Student s1 = new Student("林青霞", 30);Student s2 = new Student("张曼玉", 35);Student s3 = new Student("王祖贤", 33);Student s4 = new Student("王祖贤", 33);//把学生添加到集合hs.add(s1);hs.add(s2);hs.add(s3);hs.add(s4);//遍历集合(增强for)for (Student s : hs) {System.out.Name() + "," + s.getAge());}}
}
注意：
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}Idea中重写，可Alt+Insert进行快捷重写
笔记小结：
- 概述：
LinkedHashSet是HashSet的一个子类，它使用了一个双向链表来维护插入顺序，同时也保持了HashSet的元素唯一性- 特点：有序、不重复、无索引。
- 底层原理：底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序
示例：
public class A04_LinkedHashSetDemo {public static void main(String[] args) {//1.创建4个学生对象Student s1 = new Student("zhangsan",23);Student s2 = new Student("lisi",24);Student s3 = new Student("wangwu",25);Student s4 = new Student("zhangsan",23);//2.创建集合的对象LinkedHashSet<Student> lhs = new LinkedHashSet<>();//3.添加元素System.out.println(lhs.add(s3));System.out.println(lhs.add(s2));System.out.println(lhs.add(s1));System.out.println(lhs.add(s4));//4.打印集合System.out.println(lhs);}
}
说明：
LinkedHashSet存入和取出的数据是有序的
笔记小节：
- 概述：TreeSet 是 Java 集合框架中的一个集合类，它实现了 SortedSet 接口，可以对元素进行排序
- 底层原理：TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好
- 两种比较方式：默认排序/自然排序、比较器排序
- 细节：比较方式使用原则:默认使用第一种，如果第一种不能满足当前需求，就使用第二种，自定义排序
特点：
TreeSet集合默认的规则：
类是于Set
基础示例：
//1.创建TreeSet集合对象TreeSet<Integer> ts = new TreeSet<>();//2.添加元素ts.add(4);ts.add(5);ts.add(1);ts.add(3);ts.add(2);//3.打印集合//System.out.println(ts);//4.遍历集合（三种遍历）//迭代器Iterator<Integer> it = ts.iterator();while(it.hasNext()){int i = it.next();System.out.println(i);}System.out.println("--------------------------");//增强forfor (int t : ts) {System.out.println(t);}System.out.println("--------------------------");//lambdats.forEach( i-> System.out.println(i));Javabean类实现Comparable接口指定比较规则
public class Student implements Comparable<Student>{private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}public String toString() {return "Student{name = " + name + ", age = " + age + "}";}@Override//this：表示当前要添加的元素//o：表示已经在红黑树存在的元素//返回值：//负数：表示当前要添加的元素是小的，存左边//正数：表示当前要添加的元素是大的，存右边//0 :表示当前要添加的元素已经存在，舍弃public int compareTo(Student o) {System.out.println("--------------");System.out.println("this:" + this);System.out.println("o:" + o);//指定排序的规则//只看年龄，我想要按照年龄的升序进行排列Age() - o.getAge();}
}
说明：
若需要将此类用于Treeset，需要实现Comparable接口，并在实现时指定泛型的类
public class A05_TreeSetDemo2 {public static void main(String[] args) {/*需求：创建TreeSet集合，并添加3个学生对象学生对象属性：姓名，年龄。要求按照学生的年龄进行排序同年龄按照姓名字母排列（暂不考虑中文）同姓名，同年龄认为是同一个人方式一：默认的排序规则/自然排序Student实现Comparable接口，重写里面的抽象方法，再指定比较规则*///1.创建三个学生对象Student s1 = new Student("zhangsan",23);Student s2 = new Student("lisi",24);Student s3 = new Student("wangwu",25);Student s4 = new Student("zhaoliu",26);//2.创建集合对象TreeSet<Student> ts = new TreeSet<>();//3.添加元素ts.add(s3);ts.add(s2);ts.add(s1);ts.add(s4);//4.打印集合System.out.println(ts);//TreeSet 底层是红黑树}
}
17.9.3底层原理：
创建TreeSet对象时候，传递比较器Comparator指定规则
public class A06_TreeSetDemo3 {public static void main(String[] args) {/*需求：请自行选择比较器排序和自然排序两种方式；要求：存入四个字符串， “c”, “ab”, “df”, “qwer”按照长度排序，如果一样长则按照首字母排序采取第二种排序方式：比较器排序*///1.创建集合//o1:表示当前要添加的元素//o2：表示已经在红黑树存在的元素//返回值规则跟之前是一样的TreeSet<String> ts = new TreeSet<>((o1, o2)->{// 按照长度排序int i = o1.length() - o2.length();//如果一样长则按照首字母排序i = i == 0 ? o1pareTo(o2) : i;return i;});//2.添加元素ts.add("c");ts.add("ab");ts.add("df");ts.add("qwer");//3.打印集合System.out.println(ts);}
}笔记小结：
概述：Map 是一种用于存储键值对的集合，每个键对应一个唯一的值
常用成员方法：put、remove、clear、containsKey、containsValue、isEmpty、size.
遍历方式：
键找值，API：
map.keySet()Set<String> keys = map.keySet(); for (String key : keys) {String value = (key); }键值对，API：
Set<Map.Entry<String, String>> entries = Set(); for (Map.Entry<String, String> entry : entries) {String key = Key();String value = Value(); }Lambda表达式，API：
map.forEach()map.forEach(new BiConsumer<String, String>() {@Overridepublic void accept(String key, String value) {System.out.println(key + "=" + value);} });
在 Java 中，Map 是一种用于存储键值对的集合，每个键对应一个唯一的值。它是一种非常常用的集合，可用于快速查找和访问数据。
格式：
interface Map<K,V> K：键的类型；V：值的类型
| 方法名 | 说明 |
|---|---|
| V put(K key,V value) | 添加元素 |
| V remove(Object key) | 根据键删除键值对元素 |
| void clear() | 移除所有的键值对元素 |
| boolean containsKey(Object key) | 判断集合是否包含指定的键 |
| boolean containsValue(Object value) | 判断集合是否包含指定的值 |
| boolean isEmpty() | 判断集合是否为空 |
| int size() | 集合的长度，也就是集合中键值对的个数 |
Map<String,String> map = new HashMap<String,String>();
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
Map<String,String> map = new HashMap<String,String>();
map.clear();
Map<String,String> map = new HashMap<String,String>();
String result = ve("郭靖");
Map<String,String> map = new HashMap<String,String>();
boolean keyResult = m.containsKey("郭靖");
System.out.println(valueResult);
Map<String,String> map = new HashMap<String,String>();
boolean valueResult = ainsValue("小龙女2");
System.out.println(valueResult);
Map<String,String> map = new HashMap<String,String>();
boolean result = map.isEmpty();
System.out.println(result);
Map<String,String> map = new HashMap<String,String>();
int size = map.size();
System.out.println(size);
public class MapDemo02 {public static void main(String[] args) {//创建集合对象Map<String,String> map = new HashMap<String,String>();//V put(K key,V value)：添加元素map.put("张无忌","赵敏");map.put("郭靖","黄蓉");map.put("杨过","小龙女");//V remove(Object key)：根据键删除键值对元素
// System.out.ve("郭靖"));
// System.out.ve("郭襄"));//void clear()：移除所有的键值对元素
// map.clear();//boolean containsKey(Object key)：判断集合是否包含指定的键
// System.out.ainsKey("郭靖"));
// System.out.ainsKey("郭襄"));//boolean isEmpty()：判断集合是否为空
// System.out.println(map.isEmpty());//int size()：集合的长度，也就是集合中键值对的个数System.out.println(map.size());//输出集合对象System.out.println(map);}
}
概述：通过Map集合的键来获得值
方法介绍：
| 方法名 | 说明 |
|---|---|
| V get(Object key) | 根据键获取值 |
| Set keySet() | 获取所有键的集合 |
| Collection values() | 获取所有值的集合 |
基本用例：
public class MapDemo01 {public static void main(String[] args) {//1.创建Map集合的对象Map<String,String> map = new HashMap<>();//2.添加元素map.put("尹志平","小龙女");map.put("郭靖","穆念慈");map.put("欧阳克","黄蓉");//3.通过键找值//3.1获取所有的键，把这些键放到一个单列集合当中Set<String> keys = map.keySet();//3.2遍历单列集合，得到每一个键for (String key : keys) {//System.out.println(key);//3.3 利用map集合中的键获取对应的值 getString value = (key);System.out.println(key + " = " + value);}//4.直接找值Collection<String> values = map.values();for(String value : values) {System.out.println(value);}}
}
概述：通过Map集合获取键值对
方法介绍：
| 方法名 | 说明 |
|---|---|
| Set<Map.Entry<K,V>> entrySet() | 获取所有键值对对象的集合 |
基本用例：
public class MapDemo03 {public static void main(String[] args) {//Map集合的第二种遍历方式//1.创建Map集合的对象Map<String, String> map = new HashMap<>();//2.添加元素//键：人物的外号//值：人物的名字map.put("标枪选手", "马超");map.put("人物挂件", "明世隐");map.put("御龙骑士", "尹志平");//3.Map集合的第二种遍历方式//通过键值对对象进行遍历//3.1 通过一个方法获取所有的键值对对象，返回一个Set集合Set<Map.Entry<String, String>> entries = Set();//3.2 遍历entries这个集合，去得到里面的每一个键值对对象for (Map.Entry<String, String> entry : entries) {//entry ---> "御龙骑士","尹志平"//3.3 利用entry调用get方法获取键和值String key = Key();String value = Value();System.out.println(key + "=" + value);}}
}
概述：得益于JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。
基本用例：
public class MapDemo03 {public static void main(String[] args) {//Map集合的第三种遍历方式//1.创建Map集合的对象Map<String,String> map = new HashMap<>();//2.添加元素//键：人物的名字//值：名人名言map.put("鲁迅","这句话是我说的");map.put("曹操","不可能绝对不可能");map.put("刘备","接着奏乐接着舞");map.put("柯镇恶","看我眼色行事");//3.利用lambda表达式进行遍历//底层：//forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值//再调用accept方法map.forEach(new BiConsumer<String, String>() {@Overridepublic void accept(String key, String value) {System.out.println(key + "=" + value);}});System.out.println("-----------------------------------");map.forEach((String key, String value)->{System.out.println(key + "=" + value);});System.out.println("-----------------------------------");map.forEach((key, value)-> System.out.println(key + "=" + value));}
}
笔记小结：
- 概述：HashMap 是 Java 中的一个集合类，它实现了 Map 接口，可以用来存储键值对
- 特点：无序的、 允许使用 null 作为键或值、键是唯一的，插入键相同则覆盖、线程不安全的、HashMap 的实现是基于哈希表的，使用哈希算法来确定键值对的存储位置，因此插入和查询的时间复杂度为 O(1)。
- 底层原理：
- HashMap底层是哈希表结构的
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象，需要重写hashCode和equals方法（此处注意！！！！）。如果值要存储的是自定义对象，不需要重写hashCode和equals方法0
- 待完善，详细参见视频！！！
HashMap 是 Java 中的一个集合类，它实现了 Map 接口，可以用来存储键值对。
特点：
基本用例：
public class HashMapDemo {public static void main(String[] args) {//创建HashMap集合对象HashMap<Student, String> hm = new HashMap<Student, String>();//创建学生对象Student s1 = new Student("林青霞", 30);Student s2 = new Student("张曼玉", 35);Student s3 = new Student("王祖贤", 33);Student s4 = new Student("王祖贤 ", 33);//把学生添加到集合hm.put(s1, "西安");hm.put(s2, "武汉");hm.put(s3, "郑州");hm.put(s4, "北京");//遍历集合Set<Student> keySet = hm.keySet();for (Student key : keySet) {String value = hm.get(key);System.out.Name() + "," + Age() + "," + value);}}
}
说明：
此图为HashMap底层源码的改写版本，通俗易懂
参考资料：集合进阶-13-HashMap源码超详细解析（一）_哔哩哔哩_bilibili
笔记小结：
- 概述：LinkedHashMap 是 HashMap 的一个子类
- 特点：不重复、无索引、有序性
- 底层原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。跟HashSet一样
LinkedHashMap 是 HashMap 的一个子类
特点：
底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。跟HashSet一样
笔记小结：
概述：TreeMap 是 Java 中的一种双列集合，它基于红黑树实现。TreeMap 通过 key-value 存储数据，支持根据 key 值进行排序和查找，可以保证元素有序，因此在需要对集合中的元素进行排序时，可以使用 TreeMap。
特点：
- TreeMap底层是红黑树结构
- 依赖自然排序或者比较器排序,对键进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
- 注意:默认按照键的从小到大进行排序，也可以自己规定键的排序规则
底层原理：待完善，详细参见视频！！！
特点：
基本用例：
public class Test1 {public static void main(String[] args) {// 创建TreeMap集合对象TreeMap<Student,String> tm = new TreeMap<>();// 创建学生对象Student s1 = new Student("xiaohei",23);Student s2 = new Student("dapang",22);Student s3 = new Student("xiaomei",22);// 将学生对象添加到TreeMap集合中tm.put(s1,"江苏");tm.put(s2,"北京");tm.put(s3,"天津");// 遍历TreeMap集合,打印每个学生的信息tm.forEach((Student key, String value)->{System.out.println(key + "---" + value);});}
}
也需要在student类中进行接口实现
public class Student implements Comparable<Student>{……………………@Overridepublic int compareTo(Student o) {//按照年龄进行排序int result = o.getAge() - Age();//次要条件，按照姓名排序。result = result == 0 ? o.getName()Name()) : result;return result;}
}
参考资料：集合进阶-17-TreeMap源码超详细解析（一）_哔哩哔哩_bilibili
笔记小结：
概述：是一个长度不可变，内容也无法修改的集合
特点：定义完成后
- 不可修改
- 不可添加
- 不可删除
常用成员方法：List、Set、Map接口中，都存在of方法可以创建不可变集合
三种方式的细节:
List:直接用
List<String> list = List.of("张三", "李四", "王五", "赵六");Set:元素不能重复
Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");Map:元素不能重复、键值对数量最多是10个。
少于10个用of方法
Map<String, String> map = Map.of("张三", "南京", "张三",……);超过10个用ofEntries方法
HashMap<String, String> hm = new HashMap<>(); hm.put("张三", "南京"); hm.put("李四", "北京"); Map<String, String> map = pyOf(hm); // 此方法为JDK10之后才拥有的
是一个长度不可变，内容也无法修改的集合
如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。
当集合对象被不可信的库调用时，不可变形式是安全的。
简单理解：
不想让别人修改集合中的内容
常用成员方法
public class ImmutableDemo1 {public static void main(String[] args) {/*创建不可变的List集合"张三", "李四", "王五", "赵六"*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作List<String> list = List.of("张三", "李四", "王五", "赵六");System.out.(0));System.out.(1));System.out.(2));System.out.(3));System.out.println("---------------------------");for (String s : list) {System.out.println(s);}System.out.println("---------------------------");Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("---------------------------");for (int i = 0; i < list.size(); i++) {String s = (i);System.out.println(s);}System.out.println("---------------------------");//ve("李四");//list.add("aaa");list.set(0,"aaa");}
}
public class ImmutableDemo2 {public static void main(String[] args) {/*创建不可变的Set集合"张三", "李四", "王五", "赵六"细节：当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");for (String s : set) {System.out.println(s);}System.out.println("-----------------------");Iterator<String> it = set.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("-----------------------");//ve("王五");}
}
public class ImmutableDemo3 {public static void main(String[] args) {/*创建Map的不可变集合细节1：键是不能重复的细节2：Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对细节3：如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海","赵六", "广州", "孙七", "深圳", "周八", "杭州","吴九", "宁波", "郑十", "苏州", "刘一", "无锡","陈二", "嘉兴");Set<String> keys = map.keySet();for (String key : keys) {String value = (key);System.out.println(key + "=" + value);}System.out.println("--------------------------");Set<Map.Entry<String, String>> entries = Set();for (Map.Entry<String, String> entry : entries) {String key = Key();String value = Value();System.out.println(key + "=" + value);}System.out.println("--------------------------");}
}
public class ImmutableDemo4 {public static void main(String[] args) {/*创建Map的不可变集合,键值对的数量超过10个*///1.创建一个普通的Map集合HashMap<String, String> hm = new HashMap<>();hm.put("张三", "南京");hm.put("李四", "北京");hm.put("王五", "上海");hm.put("赵六", "北京");hm.put("孙七", "深圳");hm.put("周八", "杭州");hm.put("吴九", "宁波");hm.put("郑十", "苏州");hm.put("刘一", "无锡");hm.put("陈二", "嘉兴");hm.put("aaa", "111");//2.利用上面的数据来获取一个不可变的集合
/*//获取到所有的键值对对象（Entry对象）Set<Map.Entry<String, String>> entries = hm.entrySet();//把entries变成一个数组Map.Entry[] arr1 = new Map.Entry[0];//toArray方法在底层会比较集合的长度跟数组的长度两者的大小//如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组//如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用Map.Entry[] arr2 = Array(arr1);//不可变的map集合Map map = Map.ofEntries(arr2);map.put("bbb","222");*///Map<Object, Object> map = Map.Set().toArray(new Map.Entry[0]));Map<String, String> map = pyOf(hm);map.put("bbb","222");}
}
笔记小结：
- 概述：java.util.Collections:是集合工具类
- 常用成员方法：
- 新增：addAll
- 顺序：打乱shuffle（）、排序sort（）、指定排序sort（）、交换swap（）
- 拷贝：copy（）
- 填充：fill（）
- 最大最小：max/min（）
- 查询：binarySearch（）
java.util.Collections:是集合工具类
作用：Collections不是集合，而是集合的工具类
案例1
public class CollectionsDemo1 {public static void main(String[] args) {//addAll 批量添加元素//1.创建集合对象ArrayList<String> list = new ArrayList<>();//2.批量添加元素Collections.addAll(list,"abc","bcd","qwer","df","asdf","zxcv","1234","qwer");//3.打印集合System.out.println(list);//shuffle 打乱Collections.shuffle(list);System.out.println(list);}
}
案例2
public class CollectionsDemo2 {public static void main(String[] args) {/*public static <T> void sort(List<T> list) 排序public static <T> void sort(List<T> list, Comparator<T> c) 根据指定的规则进行排序public static <T> int binarySearch (List<T> list, T key) 以二分查找法查找元素public static <T> void copy(List<T> dest, List<T> src) 拷贝集合中的元素public static <T> int fill (List<T> list, T obj) 使用指定的元素填充集合public static <T> void max/min(Collection<T> coll) 根据默认的自然排序获取最大/小值public static <T> void swap(List<?> list, int i, int j) 交换集合中指定位置的元素*/System.out.println("-------------sort默认规则--------------------------");//默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小打大的顺序排列//如果是自定义对象，需要自己指定规则ArrayList<Integer> list1 = new ArrayList<>();Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);Collections.sort(list1);System.out.println(list1);System.out.println("-------------sort自己指定规则规则--------------------------");Collections.sort(list1, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});System.out.println(list1);Collections.sort(list1, (o1, o2) -> o2 - o1);System.out.println(list1);System.out.println("-------------binarySearch--------------------------");//需要元素有序ArrayList<Integer> list2 = new ArrayList<>();Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);System.out.println(Collections.binarySearch(list2, 9));System.out.println(Collections.binarySearch(list2, 1));System.out.println(Collections.binarySearch(list2, 20));System.out.println("-------------copy--------------------------");//把list3中的元素拷贝到list4中//会覆盖原来的元素//注意点：如果list3的长度 > list4的长度，方法会报错ArrayList<Integer> list3 = new ArrayList<>();ArrayList<Integer> list4 = new ArrayList<>();Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);py(list4, list3);System.out.println(list3);System.out.println(list4);System.out.println("-------------fill--------------------------");//把集合中现有的所有数据，都修改为指定数据ArrayList<Integer> list5 = new ArrayList<>();Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);Collections.fill(list5, 100);System.out.println(list5);System.out.println("-------------max/min--------------------------");//求最大值或者最小值ArrayList<Integer> list6 = new ArrayList<>();Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);System.out.println(Collections.max(list6));System.out.println(Collections.min(list6));System.out.println("-------------max/min指定规则--------------------------");// String中默认是按照字母的abcdefg顺序进行排列的// 现在我要求最长的字符串// 默认的规则无法满足，可以自己指定规则// 求指定规则的最大值或者最小值ArrayList<String> list7 = new ArrayList<>();Collections.addAll(list7, "a","aa","aaa","aaaa");System.out.println(Collections.max(list7, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length();}}));System.out.println("-------------swap--------------------------");ArrayList<Integer> list8 = new ArrayList<>();Collections.addAll(list8, 1, 2, 3);Collections.swap(list8,0,2);System.out.println(list8);}
}
笔记小结：
概述：泛型是Java中的一种特性，它可以将类或方法中的数据类型作为参数进行传递和使用
格式
<E> <T>好处：
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
注意：在java中在编译为class文件时，是会擦除掉泛型的
细节：
- 泛型中不能写基本数据类型
- 指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型
- 如果不写泛型，类型默认是Object
分类：
泛型类
概念：在类名后面定义泛型，创建该类对象的时候，确定类型
格式：
修饰符 class 类名<类型>{ } // 例如 public class Arraylist<T>{ }泛型方法
概念：在修饰符后面定义方法，调用该方法的时候，确定类型
格式：
修饰符<类型> 返回值类型方法名(类型变量名){ } // 例如 public<T> void show (T t){ }泛型接口
概念：在接口名后面定义泛型，实现类确定类型，实现类延续泛型
格式：
修饰符 interface 接口名<类型>{ } // 例如 public interface List<E>{ }泛型通配符
泛型不具备继承性，但是数据具备继承性
public static void method( ArrayList<Animal> list) { } // 此处method方法所传入的任何参数，只能是Animal类的集合，其余任何类的集合都不行，包括子类继承的类集合也不行ArrayList<Ye> list1 = new ArrayList<>(); list1.add(new Ye()); list1.add(new Fu()); list1.add(new zi()); // 与泛型类形成对比，数据具备继承性泛型的通配符:?
// 格式 ? extend E // 传递子类 ? super E //传递父类 // 例如 public static void keepPet(ArrayList<? extends Animal> list){ } public static void keepPet(ArrayList<? super Animal> list){ }应用场景：
- 定义类、方法、接口的时候，如果类型不确定，就可以定义泛型
- 如果类型不确定，但是能知道是哪个继承体系中的，可以使用泛型的通配符
Java泛型是Java SE 5中引入的一种编程机制，它通过参数化类型来实现代码的重用。使用泛型可以让代码更加通用和类型安全，避免了在编译时期因类型转换错误导致的运行时异常。
格式：
好处:
说明：
在java中在编译为class文件时，是会擦除掉泛型的
细节：
说明：
因为泛型的基本数据类型是Object类型，基本数据类型无法自动转换为Object类型
概念：泛型类（Generic Class）指在类的定义中使用泛型类型参数的类，可以在类中使用泛型类型参数，从而增强代码的可重用性和类型安全性。
格式：
修饰符 class 类名<类型>{}
// 例如
public class Arraylist<T>{}
说明：
此处E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成T、E、K、V等
示例：
概述：泛型方法（Generic Method）指在方法定义中使用泛型类型参数的方法，可以在方法中使用泛型类型参数，从而增强代码的可重用性和类型安全性。
格式
修饰符<类型> 返回值类型方法名(类型变量名){
}
// 例如
public<T> void show (T t){
}
说明:
此处T可以理解为变量，但是不是用来记录数据的，而是记录类型的，可以写成:.E、K、V等
补充：
当使用 E … 作为参数时， … 表示可变参数，此时传入的参数个数也是不确定的
概念：泛型接口（Generic Interface）指在接口的定义中使用泛型类型参数的接口，可以在接口中使用泛型类型参数，从而增强代码的可重用性和类型安全性。
格式：
修饰符 interface 接口名<类型>{
}
// 例如
public interface List<E>{
}
使用：
概念：泛型的通配符指的是 Java 中的通配符类型（Wildcard Type），使用 ? 表示。通配符类型是一种类型实参，可以用于表示某个泛型类型的类型参数可以是任何类型。通配符类型可以用于方法参数类型、变量类型、返回值类型等。
通配符：?也表示不确定的类型
分类：
特点：
应用场景：
意义：限定类型的范围
代码：
public class Test1 {public static void main(String[] args) {/*需求：定义一个继承结构：动物| |猫 狗| | | |波斯猫 狸花猫 泰迪 哈士奇属性：名字，年龄行为：吃东西波斯猫方法体打印：一只叫做XXX的，X岁的波斯猫，正在吃小饼干狸花猫方法体打印：一只叫做XXX的，X岁的狸花猫，正在吃鱼泰迪方法体打印：一只叫做XXX的，X岁的泰迪，正在吃骨头，边吃边蹭哈士奇方法体打印：一只叫做XXX的，X岁的哈士奇，正在吃骨头，边吃边拆家测试类中定义一个方法用于饲养动物public static void keepPet(ArrayList<???> list){//遍历集合，调用动物的eat方法}要求1：该方法能养所有品种的猫，但是不能养狗要求2：该方法能养所有品种的狗，但是不能养猫要求3：该方法能养所有的动物，但是不能传递其他类型*/ArrayList<PersianCat> list1 = new ArrayList<>();ArrayList<LiHuaCat> list2 = new ArrayList<>();ArrayList<TeddyDog> list3 = new ArrayList<>();ArrayList<HuskyDog> list4 = new ArrayList<>();keepPet(list1);keepPet(list2);keepPet(list3);keepPet(list4);}//该方法能养所有的动物，但是不能传递其他类型public static void keepPet(ArrayList<? extends Animal> list){//遍历集合，调用动物的eat方法}/* // 要求2：该方法能养所有品种的狗，但是不能养猫public static void keepPet(ArrayList<? extends Dog> list){//遍历集合，调用动物的eat方法}*//*//要求1：该方法能养所有品种的猫，但是不能养狗public static void keepPet(ArrayList<? extends Cat> list){//遍历集合，调用动物的eat方法}*/
}
笔记小结：
- 概述：数据结构是计算机存储、组织数据的方式
- 栈:后进先出，先进后出。
- 队列:先进先出，后进后出。
- 数组:内存连续区域，查询快，增删慢。
- 链表:元素是游离的，查询慢，首尾操作极快。
- 树：请查看各个小节
数据结构是计算机存储、组织数据的方式，是指数据元素之间的相互关系，以及它们之间在计算机存储器中的组织方式。常见的数据结构包括数组、链表、栈、队列、树、图等，它们在实际的计算机程序设计中扮演着重要的角色
栈特点：先进后出，后进先出
java中方法
说明：
方法存在栈内存中，当function<-method<-main方法入栈后，会以function->methon->main的方式出栈
队列特点：先进先出，后进后出
说明：
类似于生活中的排队买票
特点：数组是一种查询快,增删慢的模型
特点：链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址
笔记小节：
概述：
节点: 在树结构中,每一个元素称之为节点
度: 每一个节点的子节点数量称之为度
二叉树：
每个节点最多有两个子节点，分别称为左子节点和右子节点。左子节点的值小于或等于父节点的值，右子节点的值大于父节点的值，这种性质使得二叉树在查找、排序等方面有很好的应用。二叉树的子树也是二叉树，即每个节点都可以看作是根节点
二叉查找数：
每个节点包含一个键值对（key-value）、左子树的所有节点的键值小于根节点的键值、右子树的所有节点的键值大于根节点的键值、左子树和右子树也是二叉查找树。
平衡二叉树：
叉树左右两个子树的高度差不超过1、任意节点的左右两个子树都是一颗平衡二叉树
红黑数:
特点：平衡二叉B树、每一个节点可以是红或者黑、红黑树不是高度平衡的,它的平衡是通过"自己的红黑规则"进行实现的
红黑规则：
每一个节点或是红色的,或者是黑色的。根节点必须是黑色。如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的。如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连 的情况)。对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点
树的演变
特点：二叉树中,任意一个节点的度要小于等于2
节点: 在树结构中,每一个元素称之为节点
度: 每一个节点的子节点数量称之为度
特点：
特点：
旋转：
旋转触发时机
左旋：
右旋：
平衡二叉树旋转的四种情况：
左左：当根节点左子树的左子树有节点插入,导致二叉树不平衡
如何旋转: 直接对整体进行右旋即可
左右: 当根节点左子树的右子树有节点插入,导致二叉树不平衡
如何旋转: 先在左子树对应的节点位置进行左旋,在对整体进行右旋
右右: 当根节点右子树的右子树有节点插入,导致二叉树不平衡
右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡
如何旋转: 先在右子树对应的节点位置进行右旋,在对整体进行左旋
参考资料：集合进阶-11数据结构（平衡二叉树旋转机制）_哔哩哔哩_bilibili
特点：
红黑规则：
每一个节点或是红色的,或者是黑色的
根节点必须是黑色
如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的
如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连 的情况)
对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点
红黑树添加节点的默认颜色：添加节点时,默认为红色,效率高
红黑树添加节点后如何保持红黑规则
笔记小结：
概述：可变参数是一种Java方法的参数类型，允许方法接受任意数量的参数
特点：可变参数本质上就是一个数组
作用：在形参中接收多个数据
格式：数据类型…参数名称
getSum(1,2,3,4,5,6,7,8,9,10);public static int getSum( int args) {return 0; }注意：
- 形参列表中可变参数只能有一个可变参数
- 形参列表中可变参数必须放在形参列表的最后面
可变参数是一种Java方法的参数类型，允许方法接受任意数量的参数。在方法声明中，可变参数使用省略号(…)来表示，它可以接收0个或多个相同类型的参数。使用可变参数的方法可以接受任意数量的参数，而无需提前声明它们的数量。在方法中，可变参数实际上是作为数组来处理的
格式
基本用例：
public class ArgsDemo4 {public static void main(String[] args) {//可变参数的小细节：//1.在方法的形参中最多只能写一个可变参数//可变参数，理解为一个大胖子，有多少吃多少//2.在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后getSum(1,2,3,4,5,6,7,8,9,10);}public static int getSum( int args) {return 0;}
}
Lambda表达式是Java编程语言中引入的一种语法特性，用于创建匿名函数或闭包。它允许您以更简洁的方式定义单个方法的接口实现。Lambda表达式在函数式编程和简化代码编写方面具有重要作用，特别是在集合处理和多线程编程中。
补充：
此处的单个方法的接口实现，简称函数式接口。该接口有且仅有一个抽象方法。有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加**@Functionallnterface**注解。
说明：
在本方法中，简化new出来的接口为箭头函数
把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。换句话说，简化函数式接口的匿名内部类的写法。
省略核心:可推导,可省略
函数式编程(Functional programming）是一种思想特点。面向对象∶先找对象，让对象做事情。
函数式编程思想，忽略面向对象的复杂语法，强调做什么，而不是谁去做。
格式：
() ->{ //( )对应着方法的形参 ->固定格式} //{ } 对应着方法的方法体
说明：
- Lambda表达式可以用来简化匿名内部类的书写
- Lambda表达式只能简化函数式接口的匿名内部类的写法
函数式接口是指只包含一个抽象方法的接口。在Java中，可以使用@FunctionalInterface注解来标记一个接口是函数式接口，这样做可以帮助编译器检查接口是否符合函数式接口的定义。
函数式接口在Java 8中引入了Lambda表达式和方法引用等新特性。Lambda表达式可以将函数式接口作为参数进行传递，从而简化代码实现。Java标准库中的一些函数式接口包括Consumer、Supplier、Predicate、Function等等，这些接口可以用于在Java中实现函数式编程的思想。
函数式接口，也就意味着，可以使用Lambad表达式或者匿名内部类进行传递，从而简化代码实现。
说明：
list.iterator()，每调用一次就会创建一个新的迭代器
hasNext()，判断当前指针位置是否和迭代对象的长度相同
next()，先判断是否使用了集合中的添加或者删除方法，然后返回当前索引的元素，然后将指针移动到下一个位置
方法和==`运算符区别equals()方法是用于比较两个对象的值是否相等，通常在自定义类中重写equals()方法来实现自定义的相等比较规则。默认情况下，equals()方法实际上等同于==运算符，即比较两个对象的引用是否相等。
而==运算符用于比较两个对象的引用是否指向同一内存地址。如果两个对象的引用指向同一个内存地址，那么它们是相等的，否则它们不相等。
String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");System.out.println(str1 == str2); // true，因为它们指向同一字符串常量池中的对象
System.out.println(str1 == str3); // false，因为它们指向不同的内存地址
System.out.println(str1.equals(str3)); // true，因为它们的值相等
需要注意的是，对于基本数据类型，==运算符可以用于比较它们的值是否相等，因为基本数据类型在内存中存储的是它们的值而不是引用。但对于对象类型，==运算符比较的是对象的引用，而不是值。因此，在比较对象相等性时，应该使用equals()方法而不是==运算符。
本文发布于:2024-01-27 18:41:27，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/17063520901952.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
