链表与简单Java类的结合使用

class Book{
         private String title;
         private double price;
         Book (String title, double price){
              this.title = title;
              this.price = price;
         }
         public String getInfo(){
              return "图书名称："+ this.title+"，价格："+this.price;
 }
         public Boolean compare(Book book){ // 与String数据类型比较，多增加了个对象比较的方法
               if(this == book){ return true;}
               if(book == null){return false;}
               if(this.price == book.price && this.title.equals(book.title)){
                   return true;
               }
               return false;               
         }
} 
class Link{//链表类，外部能够看见的只有这一个

          private class Node{//定义节点类
private Book data; //保存数据
private Node next; //引用关系
public Node(Book data){
      this.data = data;
}
                public void addNode(Node newNode){
     if(this.next == null){//当前的下一个节点为空
         this.next = newNode;
                      }else{
  this.next.addNode(newNode);
     }
}
                //第一次调用（Link）：this = Link.root
//第二次调用（Node）: this = Link.root.next
public boolean containsNode(Book data){
             if(data.compare(this.data)){//当前节点数据为查询的数据
 return true;//后面不要查询了
}else{ //当前节点不满足查询要求
  if (this.next!= null){
      return this.next.containsNode(data);
  }else{ //没有后续节点
return false;
                           }
}
}
                 public Book getNode(int index){
                       if(Link.this.foot ++ == index){ //为要查询的索引
   return this.data;//返回当前节点数据
}else{ //现在应该继续向后查询
   return this.next.getNode(index);
}
}
                 public void setNode(int index, Book data){
                     if (Link.this.foot ++ == index){
                         this.data = data;//进行内容的修改
    }else{
                          this.next.setNode(index,data);
    }
        }
                 public void removeNode(Node previous, Book data){
                    if(data.compare(this.data)){ //当前节点为要删除节点
      previous.next = this.next;
   }else{ //应该继续向后查询
      this.next.removeNode(this, data);
   }
        }
         public void toArrayNode(){
                 Link.this.retArray[Link.this.foot++]=this.data;
                 if(this.next != null){
this.next.toArrayNode();
                 }
         }
 }
     //=====================以上为内部类================================
          private Node root; //需要根节点
          private int count=0;//保存元素的个数
          private int foot =0; //索引
          private Book[]retArray;//返回数组
          public void add(Book data){
Node newNode = new Node(data);//要保存的数据
if(this.root == null){
   this.root = newNode; //保存根节点
}else{ //根节点存在，其它节点交给Node类处理
   this.root.addNode(newNode);
}
                this.count ++;//每一次保存完数据count加1
 }
 public int size(){ //取得保存的数据量
      return this.count;
 }
 public boolean isEmpty(){
      return this.count==0;
 }
          public boolean contains(Book data){
   if (data ==null || this.root == null ){
                      return false;
   }
            return this.root.containsNode(data);//给Node类，从根节点开始查
 }
          public Book get(int index){
   if (index>this.count){ //超过了查询范围
     return null; //没有数据
   }
            this.foot =0; //表示从前向后查询
            return this.root.getNode(index);//查询过程交给Node类
          }
          public void set(int index, Book data){
   if (index > this.count){
return; //结束方法调用
   }
            this.foot = 0; //重新设置foot属性的内容，作为索引出现
   this.root.setNode(index,data); //交给Node类设置数据内容
 }
          public void remove(Book data){
              if(this.contains(data)){//主要是判断数据是否存在
         //要删除数据是否是根节点数据
 //root是Node类的对象，此处直接访问了内部类的私有操作
                  if(data.compare(this.root.data)){ //为要删除节点
      this.root = this.root.next; //空出当前根节点
 }else{ //不是根元素
//此时根元素已经判断过了，从第二个元素开始判断
this.root.next.removeNode(this.root, data);
 }
         this.count --;//个数要减少
     }


          }
          public Book[]toArray(){
                 if(this.root == null){
                    return null;
                 }
                 this.foot=0; //需要脚表控制
                 this.retArray = new Book[this.count]; //根据保存内容开辟数组
this.root.toArrayNode(); //交给Node类处理
return this.retArray;
         }
   }
        public class LinkDemo{
               public static void main(String args[]){ 
     Link all = new Link();
     all.add(new Book("Java开发",69.8));
     all.add(new Book("JSP开发",79.2));

     all.add(new Book("Oracle开发",59.2));

                     System.out.println(all.contains(new Book("Java开发",69.8)));
                     System.out.println(all.get(2).getInfo());
                      all.remove(new Book("Oracle开发",59.2));
                      Book [] data = all.toArray();
                      for(int i=0; i<data.length;i++){
                          System.out.println(data[i].getInfo());
}
               }

        }

从上面可以看出，链表最好的使用就是横向替代对象数组。