链表实现3

将链表变为对象数组：public 数据类型[]toArray()

   在任何情况下，不管什么样的类，都不可能在类中使用输出语句，只要是想输出数据，一定要
将数据返回到调用处进行输出，而由于链表属于动态对象数组，所以此处最好的做法是将链表以对

象数组的形式返回。

 先贴出上一篇链表实现2中的链表代码，如下：
 class Link{//链表类，外部能够看见的只有这一个

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

  通过分析发现，最终Link类的toArray()方法一定要返回一个对象数组，并且这个对象数组也一

 定要被Node类操作。那么这个对象数组最好定义在Link类的属性里面。

  范例：修改Link类的定义
        ·增加一个返回数组的属性内容，之所以将其定义为属性，是因为内部类和外部类都可以  
       访问。
          private String[]retArray;//返回数组
       ·增加toArray()方法
         public String[]toArray(){
                 if(this.root == null){
                    return null;
                 }
                 this.foot=0; //需要脚表控制
                 this.retArray = new String[this.count]; //根据保存内容开辟数组
this.root.toArrayNode(); //交给Node类处理
return this.retArray;
         }
   范例：在Node类里面处理数组数据的保存
         public void toArrayNode(){
                 Link.this.retArray[Link.this.foot++]=this.data;
                 if(this.next != null){
this.next.toArrayNode();
                 }
         }
    添加测试代码：
        public class LinkDemo{
               public static void main(String args[]){ 
     Link all = new Link();
     all.add("Hello");
     all.add("World");
     all.add("NIHAO");
     all.add("SHIJIE");
                      String data[]= all.toArray();
                      for(int i=0; i<data.length;i++){
                          System.out.println(data[i]);
}
               }
        }
     实现的前提：内部类与外部类之间可以直接进行私有属性的访问。
     链表数据变为对象数组取出是最为重要的功能，仅仅作为分析数据引用的原理。