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 类> 对象名称

​ ？extends类？ 一定是继承类

意义：只能接受该类型及其子类

泛型的下限

格式：类型<? super 类> 对象名称

意义：只能接收还类型及其父类

通用排序方法：

1任意类型的数组都可以参加排序 泛型

2.指定任意的排序条件 多态

public static <T> void  sort(T [] arr,CompareHandler<T> 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<T>  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<T>  pnewNode=new Node<>(pdata);			
			pnewNode.setM_pNext(m_head);
			//设置新节点的下一个为原来的头结点			
			m_head=pnewNode;
			//更新头节点
			m_unsize++;
		}		
		else {
			Node<T> pFront=m_head;
			//记录的插入位置结点的上一个 开始的时候是头节点
			Node<T> ptemp=m_head;
			//遍历的					
			int tempPos=1;
			//更新位置  tempPos<pos 10
			
		    while (ptemp.getM_pNext()!=null&&tempPos<=pos) {
				//获取插入位置的结点和他的前结点
		    	//因为要在插入位置结点和他的前结点之间插入元素了
		    	pFront=ptemp;
		    	
		    	ptemp=ptemp.getM_pNext();		    	
		    	tempPos++;		    	
			} 
		    //插入元素  
		    Node<T> pnewNode=new Node<>(pdata);//插入的数据结 
		    pnewNode.setM_pNext(ptemp);   
		    pFront.setM_pNext(pnewNode);	    	    
		    m_unsize++;		
		}	
		return true;	
	}	
}

结点类

结点中存着数据date 和 指向下一个结点的引用

案例：

	private T  data;//需要保存的数据元素
	
	private Node<T>  m_pNext;//后继结点的引用
	
	private Node<T>  m_pFront;//前驱结点的引用

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}

	public Node<T> getM_pNext() {
		return m_pNext;
	}

	public void setM_pNext(Node<T> m_pNext) {
		this.m_pNext = m_pNext;
	}

	public Node<T> getM_pFront() {
		return m_pFront;
	}

	public void setM_pFront(Node<T> 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;//两个引用设置 为空
	}