目录
前言:
Collection： 是所有集合的顶级接口,里面规定了集合操作元素的相关功能方法集合与数组一样,用于存储一组元素,但是集合又多个不同的实现类来实现不同的数据结构
1.概述:
集合和数组都是容器。
集合是java中存储对象数据的一种容器。
2.数组和集合的元素存储的个数问题？
数组定义后，类型确定、长度固定。
集合的大小不固定，类型也可以选择不固定。
3.数组和集合的元素存储元素的类型问题？
数组可以存储基本数据类型和引用数据类型的数据
集合只能存储引用数据类型的数据
4.数组和集合适合的场景？
数组适合做数据个数和类型确定的场景；
数据的个数不确定，且要做增删元素的时候。
①Collecttion集合的体系结构
1.Collecttion集合的体系结构:
①Collecttion单列集合，每个元素(数据)只包含一个值。
②Collection 是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。
③Map双列集合，每个元素包含两个值(键值对)。
2.Collecttion集合特点：
①List系列集合:添加的元素是有序、可重复、有索引。
ArrayList、LinkedList:有序、可重复、有索引。
②Set系列集合:添加的元素是无序、不重复、无索引。
HashSet:无序、不重复、无索引。
LinkedHashSet:有序、不重复、无索引。
TreeSet:按照大小默认升序排序、不重复、无索引。
3.代码演示:
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/**
* Collection 单列集合(祖宗接口) 每个数据只包含一个值
* 1、list: (Arraylist Linkedlist)有序、可重复、有索引
* 2、Set: (HashSet TreeSet有序 LinkedHashSet 按照大小默认升序排序)无序、不重复、无索引
* Map 双列集合 每个数据包含两个值
*/
/**单列集合API
* add() 添加元素
* clear() 清空元素
* isEmpty() 判断集合是否为空，是则返回true
* size() 获取集合的大小
* contains("") 判断集合是否包含某个元素
* remove("") 删除某个元素值：如果有多个重复元素，默认删除前面的第一个
* object[] arrs = c.toArray() 把集合转换成数组
* 扩展 :
* c1.addAll(c2) 把c2的集合元素传给c1（c2不会删去元素）
*/
public class Collection_Demo1 {
public static void main(String[] args) {
//有序、可重复、有索引
Collection list = new ArrayList<>();//多态
list.add("JAVA");
list.add("JAVA");
list.add(23);
list.add(23);
list.add(false);
list.add(false);
System.out.println(list);
System.out.println("=========================");
//无序、不重复、无索引
Collection list1 = new HashSet();//多态
list1.add("JAVA");
list1.add("JAVA");
list1.add(23);
list1.add(23);
list1.add(false);
list1.add(false);
System.out.println(list1);
System.out.println("=========================");
Collection <String>list2 = new ArrayList<>();
list2.add("JAVA");
list.addAll(list1);
}
}4.集合对于泛型的支持
集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型。
5.注意:
集合和泛型都只能支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。
6.Collecttion集合常用API
7.代码演示:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**单列集合API
* add() 添加元素
* clear() 清空元素
* isEmpty() 判断集合是否为空，是则返回true
* size() 获取集合的大小
* contains("") 判断集合是否包含某个元素
* remove("") 删除某个元素值：如果有多个重复元素，默认删除前面的第一个
* object[] arrs = c.toArray() 把集合转换成数组
* 扩展 :
* c1.addAll(c2) 把c2的集合元素传给c1（c2不会删去元素）
*/
public class Collection_Demo3 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
//1.添加元素，成功返回true
c.add("JAVA");
c.add("Python");
c.add("HTML");
System.out.println(c);
//2.清空集合的元素
c.clear();
System.out.println(c);
//3.判断集合是否为空，是则返回true
System.out.println(c.isEmpty());
//4.获取集合的大小
System.out.println(c.size());
//5.判断集合是否包含某个元素
System.out.println(c.contains("JAVA"));
System.out.println(c.contains("Python"));
System.out.println(c.contains("Html"));
//6.删除某个元素值：如果有多个重复元素，默认删除前面的第一个
System.out.println(c.remove("JAVA"));
System.out.println(c);
//7.把集合转换成数组
Object[] arrs = c.toArray();
System.out.println("数组: "+ Arrays.toString(arrs));
System.out.println("========扩展========");
Collection<String> c1 = new ArrayList<>();
c1.add("java1");
c1.add("java2");
Collection<String> c2 = new ArrayList<>();
c2.add("AK47");
c2.add("58同城");
//把c2的集合元素传给c1（c2不会删去元素）
c1.addAll(c2);
System.out.println(c1);
System.out.println(c2);
}
}②Collecttion集合的遍历方式
方式一:迭代器
1.迭代器的遍历概述:
①遍历就是一个一个的把容器中的元素访问一遍。
②迭代器在java中的代表是Iterator，迭代器是集合的专用遍历方式。
2.Collecttion集合获取迭代器
3.Iterator中的常用方法
4.代码演示:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**迭代器（Iterator） 是集合的专用迭代器
* Iterator<E> iterator() 得到迭代器对象，默认值向当前集合的索引0
* 迭代器取元素越界会报异常
*/
public class Iterator_Demo4 {
public static void main(String[] args) {
Collection<String> lists = new ArrayList<>();//多态
lists.add("JAVA");
lists.add("python");
lists.add("html");
System.out.println(lists);
//1、得到当前集合的迭代器
Iterator<String> it = lists.iterator();
//一次只能取出一个元素 取元素不要越界
String ele = it.next();
System.out.println(ele);
System.out.println(it.next());
System.out.println("==================================");
//2、定义while循环 取出全部元素
while (it.hasNext()){
String eles = it.next();
System.out.println(eles);
}
}
}方式二:foreach/增强for循环
1.概述:
①增强for循环既可以遍历数组也可以遍历集合。
②它是JDK5之后出现的，其内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法。
③实现Iterable接口的类才可以使用迭代器和增强for，Collection接口已经实现了Iterable接口。
2.增强for循环的遍历格式:
3.代码演示:
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
/**增强for循环 既可以遍历数组也可以遍历集合
* 内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法
* 实现Iterable接口的类才可以使用迭代器和增强for循环 Collection实现了Iterable接口
* for(元素数据类型 变量名 :数组或Collection集合){ 在此处使用变量 }
*/
public class Demo {
public static void main(String[] args) {
//举例:增强for循环 遍历
Collection<String> list = new ArrayList<>();
list.add("JAVA");
list.add("python");
list.add("html");
for (String ele: list){
System.out.println(ele);
}
System.out.println("============================");
double[] score = {100,99,23,14,56,14};
for (double sc : score) {
System.out.println(sc);
// if (sc == 100) {
// sc = 102;//修改无意义，不会影响数组的元素值
// }
}
System.out.println("======================");
//Lambda 遍历方式
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("=====================");
//简便遍历方法
list.forEach(System.out::println);
}
}方式三:Lambda表达式
1.Lambda表达式遍历集合
JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。
2.Collection结合Lambda遍历的API
例如:
3.代码演示:
/**Lambda 遍历方式
*
*/
public class Demo {
public static void main(String[] args) {
//举例:增强for循环 遍历
Collection<String> list = new ArrayList<>();
list.add("JAVA");
list.add("python");
list.add("html");
for (String ele: list){
System.out.println(ele);
}
System.out.println("============================");
double[] score = {100,99,23,14,56,14};
for (double sc : score) {
System.out.println(sc);
// if (sc == 100) {
// sc = 102;//修改无意义，不会影响数组的元素值
// }
}
System.out.println("======================");
//Lambda 遍历方式
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("=====================");
//简便遍历方法
list.forEach(System.out::println);
}
}4.案例:影片信息在程序中的表示
需求:
某电影院需要在后台存储上述三部电影，然后依次展示出来。
分析:
①定义一个电影类，定义一个集合存储电影对象；
②创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
③遍历集合中的3个对象，输出相关信息。
电影类:
public class Movie {
private String name;
private double score;
private String actor;
public Movie(){
}
public Movie(String name, double score , String actor) {
this.name = name;
this.score = score;
this.actor = actor;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}实现类:
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
//1定义电影类
//2.创建三个电影类
Movie m1 = new Movie("《肖申克的救赎》",9.7,"罗宾斯");
Movie m2 = new Movie("《霸王别姬》",9.7,"张国荣");
Movie m3 = new Movie("《阿甘正传》",9.5,"张丰毅");
//3.创建一个电影类型ArrayList集合，存储三部电影
ArrayList<Movie> movies = new ArrayList<>();
movies.add(m1);
movies.add(m2);
movies.add(m3);
//4.遍历电影类型的集合中的每个电影对象，访问它的信息即可
for (int i = 0; i < movies.size(); i++) {
Movie m = movies.get(i);
System.out.println("电影名称："+m.getName());
System.out.println("电影得分："+m.getScore());
System.out.println("电影导演："+m.getActor());
System.out.println("-----------------------------");
}
}
}5.集合中存储的元素是什么信息?
集合中存储的是元素对象的地址。
③常见数据结构
1.数据结构的概述:
数据结构是计算机底层存储、组织数据的方式。是指数据之间是以什么方式排列在一起的。
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。
2.常见的数据结构:
栈
队列
数组
链表
二叉树
二叉查找树
平衡二叉树
红黑树
......
3.栈数据结构的执行特点:
后进先出，先进后出
数据进入栈模型的过程称为:压/进栈。
4.常见数据结构之队列
先进先出，后进后出
数据从后端进入队列模型的过程称为:入队列；
数据从前端离开队列模型的过程称为:出队列；
5.常见数据结构之数组
①查询速度快:查询数据通过地址值和索引定位，查询任意数据耗时相同。(元素在内存中是连续存储的)
②删除效率低:要求原始数据删除，同时后面每个数据前移。
③添加效率极低:添加位置后的每个数据后移，再添加元素。
6.链表的特点
①链表中的元素是在内存中不连续存储的，每个元素节点包含数据值和下一个元素的地址。
②链表查询慢，无论查询哪个数据都要从头开始找。
③链表增删相对快。
7.链表的种类
单向链表:
双向链表:
8.二叉树、二叉查找树
①普通二叉树概述:
只能有一个根节点，每个节点最多支持2个直接子节点；
结点的度:节点拥有的子树的个数，二叉树的度不大于2，叶子节点度为0的节点，也称为终端节点；
高度:叶子节点的高度为1，则子节点的父节点高度为2，以此类推，根节点的高度最高；
层:根节点在第一层，以此类推；
兄弟节点:拥有共同父节点的节点互称为兄弟节点。
②二叉查找树又称为二叉排序树或者二叉搜索树
特点:
1.每一个节点上最多有两个子节点；
2.左子树上所有节点的值都小于根节点的值；
3.右子树上所有节点的值都大于根节点的值；
目的:提高检索数据的性能。
9.平衡二叉树
平衡二叉树 是在满足查找二叉树的大小规则下，让树尽可能矮小，以此提高查数据的性能。
10.平衡二叉树的要求
任意节点的左右两个子树的高度差不超过1，任意节点的左右两个子树都是一颗平衡二叉树。
平衡二叉树在添加元素后可能导致不平衡，基本策略是进行左旋，或者右旋保证平衡。
11.红黑树
红黑树增删改查的性能都很好。
概述:
红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。
1972年出现，当时被称为平衡二叉B树，1978年被修改为“红黑树”。
每一个节点可以是红或者黑；红黑树不是通过高度平衡的，它的平衡是通过“红黑规则”进行实现的。
12.红黑规则
每一个节点或是红色的，或是黑色的，根节点必须是黑色的；
如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，叶节点是黑色的；
如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)；
对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点；
13.添加节点
添加节点的颜色，可以是红色的，也可以是黑色的。
默认用红色效率高。
429
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
