java第十五天
1.迭代器：
第一步；获取一个迭代器
第二步：判断是否有下一个元素
第三步：通过迭代器对象获取元素
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()) {
}
2.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是数据结构，用来存放数据的地方。
笔记
泛型：
泛型的好处：
1.避免类型转换麻烦 存储什么类型 取出就是什么类型
2.把运行期异常代码 提前到了编译期
案例：
list.add(1);
list.add("1");
list.add(new Student(1, "1"));
Student stu=list.get(0);
stu.age=100;
泛型的上限
格式：类型 对象名称
？extends类？ 一定是继承类
意义：只能接受该类型及其子类
泛型的下限
格式：类型 对象名称
意义：只能接收还类型及其父类
通用排序方法：
1任意类型的数组都可以参加排序 泛型
2.指定任意的排序条件 多态
public static void sort(T [] arr,CompareHandler com){
//Arrays.sort
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-1; j++) {
//父类的引用调用子类的方法：
if (com.compare(arr[i], arr[i+1])) {
T temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
}
}
通配符：
public static void getElement1(Collection coll){
}
链表：
长度：
private int m_unsize=0;
public int getM_unsize() {
return m_unsize;
}
链表的头
public Node m_head;
链表的尾
public Node m_end;
判空
public boolean isEmpty()
{
return m_head==null?true:false;//三元表达式判断链表空
}
添加
public void push_back(T data){
//给数据元素创建一个结点
Node pnewNode=new Node<>(data);
if (isEmpty()) {
m_head=pnewNode;//如果还没有元素 让新元素做头结点
}
else {
m_end.setM_pNext(pnewNode);
//不为空 设置尾、节点的下一个为新节点
}
m_end=pnewNode;//更新尾、节点
m_unsize++;//长度+1
}
插入 前插和后
public boolean InsertForward(T pdata,int pos){
if (isEmpty()) {
System.out.println("空链表");
return false;
}
//插入位置 超出 总链表长度
else if (pos>=m_unsize) {
System.out.println("去你的把");
return false;
}
案例：
if (pos==0)//如果插入位置为开始 代表有一个头元素
{
Node pnewNode=new Node<>(pdata);
pnewNode.setM_pNext(m_head);
//设置新节点的下一个为原来的头结点
m_head=pnewNode;
//更新头节点
m_unsize++;
}
else {
Node pFront=m_head;
//记录的插入位置结点的上一个 开始的时候是头节点
Node ptemp=m_head;
//遍历的
int tempPos=1;
//更新位置 tempPos pnewNode=new Node<>(pdata);//插入的数据结
pnewNode.setM_pNext(ptemp);
pFront.setM_pNext(pnewNode);
m_unsize++;
}
return true;
}
}
结点类
结点中存着数据date 和 指向下一个结点的引用
案例：
private T data;//需要保存的数据元素
private Node m_pNext;//后继结点的引用
private Node m_pFront;//前驱结点的引用
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node getM_pNext() {
return m_pNext;
}
public void setM_pNext(Node m_pNext) {
this.m_pNext = m_pNext;
}
public Node getM_pFront() {
return m_pFront;
}
public void setM_pFront(Node m_pFront) {
this.m_pFront = m_pFront;
}
构造函数
public Node(){
this.data=null;//初始化结点
m_pFront=m_pNext=null;//两个引用设置 为空
}
public Node(T data){
this.data=data;//初始化数据的
m_pFront=m_pNext=null;//两个引用设置 为空
}