java第十六天

复习

面向对象的三大特性：

封装：private get/set

继承：extends 抽取共性 实现代码复用

多态：1.存在继承关系 2.重写 3.父类引用指向子类

实现形式： 普通父类 抽象类 接口

java常用接口：

Comparable

 public interface Comparable<T> {

    public int compareTo(T o);

}

Comparator

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

Iterator

Iterator接口：是定义了迭代逻辑的接口，即：用于遍历Collection（集合类）中数据的标准访问方法。

Iterable

Iterable接口：从继承结构中可以看出，Iterable接口是Collection的顶层接口，所以Iterable是数据结构，用来存放数据的地方。

final关键字

权限修饰符：public protected default private

类与类之间的关系：泛化 实现 组合/聚合 依赖

Object两个方法：toString equals

内部类：匿名内部类

API ： Date DateFormat 1990-10-10 01:00:10 Calender System StringBuilder和String

​ 毫秒 格式化 日历

装箱和拆箱

装箱：基本数据类型 转换为引用类型

拆箱：吧引用类型转换为基本数据类型

泛型：

泛型接口 ： lterator<> 泛型方法 sort 泛型类Nade T date LinkedList

迭代器：

1.获取迭代器

2.判断 hasNext

3.获取元素 next

	Can only iterate over an array or an instance of java.lang.Iterable
	Hand需要实现一个接口  Iterable
	第一步:满足迭代的条件 实现一个接口Iterable
	for (IThrowing i : hand) {
		System.out.println(i);
	}

	增强for循环的内部脚本
	1获取迭代器对象   对象指向数据
	Iterator<IThrowing>  iterator=hand.iterator();
	2.迭代器移动   判断是否有下一个元素
	重复做一件事  不知道多少次
	while (iterator.hasNext()) {
		获取迭代器的数据
		IThrowing i=iterator.next();
		System.out.println(i);		
	}
	
	if (iterator.hasNext()) {
		IThrowing i=iterator.next();
		3获取迭代器的数据
	}
	if (iterator.hasNext()) {
        获取迭代器的数据
		IThrowing i=iterator.next();
	}
	if (iterator.hasNext()) {
	}

集合：

笔记

数组，栈，队列，链表，树的特点

1.数组：

优点：按照索引查阅速度快

缺点：1.数组固定，无法扩容 2.只能存储一种类型 3.增添删除麻烦，需要移动其他元素

使用场景：查阅多，对空间要求不大，增添删除少

2.栈：

栈是一种特殊的线代表，仅能在线性代表的一端操作，栈顶允许操作，栈底不允许

特点：先进后出，例：网页浏览记录

使用场景：栈常应用于实现递归功能方面的场景。

3.队列：

队列是一种线性表不同的是，队列可以在一端添加元素，在另一端取出元素 。

特点：先进先出

使用场景 ： 因为队列先进先出的特点，在多线程阻塞队列管理中非常适用。

4.链表

链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域（内存空间），另一个是指向下一个结点的指针域。根据指针的指向，链表能形成不同的结构。例如：单链表，双向链表，循环链表等。

优点：

1.不需要初始化容量，可以任意加减元素；

2.添加或删除元素时只需要改变前后两个元素结点的指针域指向地址即可，所以添加删除速度很快。

缺点：

1.因含有大量的指针域，占用空间较大；

2.查找元素需要遍历链表来查找，非常耗时。

使用场景：数据量较小，需要频繁添加删除操作的场景。

5.树

二叉树：分支不超过两个的树

二叉排序树：排序和查找

二叉排序树：log2的n次方 例：log2^4 2 log2^8 2 log2^16 4 log2^64 6

平衡树 = 二叉树

红黑树：趋近于平衡树，查询速度非常快，查询叶子结点最大次数和最小次数不能超过2倍

特点：

1.结点可以是红色或者黑色

2.根结点是黑色的

3.叶子是黑色的

4.每个红色节点的子节点是黑色的

5.任何一个节点到每一个叶子节点所有路径上的黑节点相同

ArrayList LinkedList Stack(链栈) Vector

ArrayList 动态数组

LinkedList 链表

Stack 链栈

Vector 动态数组

Vector Java1.0开始

其他都是在Java1.2开始的 比如 ArrayList替换了Vector

LinkedList类 本质就是链表

Java.util包

LinkedList类实现了List接口

构造方法:LinkedList

方法:

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。

案例：

public static void main01(String[] args) {
		List<Integer> list=new LinkedList<>();
		//体现了多态的弊端  父类/接口类不能访问子类独有的成员
		LinkedList<Integer> list1=new LinkedList<>();
		
		
		list1.addFirst(1);
		list1.addFirst(3);
		list1.addFirst(5);
		list1.addLast(10);//5  3  1  10
		
		for (Integer i : list1) {
			System.out.println(i);
		}
		System.out.println("===============");
		System.out.println(list1.getFirst());
		System.out.println(list1.getLast());
	}
	public static void main02(String[] args) {
		//链栈
		LinkedList<Integer> list1=new LinkedList<>();
		list1.push(1);
		list1.push(2);
		list1.push(3);//存 123   取 321
		for (int i = 0; i <3; i++) {
			System.out.println(list1.pop());//pop取出元素了
		}
		
		for (Integer integer : list1) {
			//迭代器无法修改集合元素
		}
		int number=100;
		int iter=number;
		iter=1000;	
	}
	public static void main(String[] args) {
		Vector<Integer> vector=new Vector<>();
		Stack<Integer> stack=new Stack<>();
		stack.push(1);//入栈
		stack.pop();//出栈
		stack.peek();//访问栈顶元素		
	}

HashSet

实现了Set接口 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持

在Java.util下

1.不允许存储重复元素

2.是一个无序的及格 存储元素和取出元素的顺序可能不一致

3.没有索引

4.底层就是一个哈希表结构(查询速度非常快)

案例：