如何在java中打印循环列表中的数据？

我正在使用java中的循环列表。我试图打印列表中的数据，但没有得到所需的输出。我得到的输出是

CircularList@55f96302

CircularList@3d4eac69

CircularList@42a57993

请帮忙解决这个问题

谢谢

import java.util.Iterator;


public class CircularList<T> implements Iterable<T> {

    private static class myIterator<T> implements Iterator<T> {
        int i = 0;
        CircularList<T> myList;
        Entry<T> iter;

        public myIterator(CircularList<T> list) {   
            iter = list.head;
            myList = list;
        }

        public boolean hasNext() {
            return !(myList.size() == i)
        }

        public T next() {
            //System.out.println("next");
            i++;
            T nextvalue = iter.value;
            //Entry<T> nextnode = new Entry<T>();
            iter = iter.next;               
            return nextvalue;
        }

        public void remove() {
            if(myList.size() == 1) {
                myList.head = null;
                return;
            }

            if(iter == myList.head) {
                myList.head = myList.head.next;
            }
            iter.prev.next = iter.next;
            iter.next.prev = iter.prev;
        }
    } // end myIterator

    private static class Entry<T> {
        Entry<T> next;
        Entry<T> prev;
        T value;
    }

    private Entry<T> head;

    public int size() {
        int index = 0;

        Entry<T> before = head.prev;
        Entry<T> after = head;
        //System.out.println(head.value);
        //System.out.println(after.value);

        do {
            before = after;
            after = after.next;
            index++;
        } while (after != head);

        return index;
    }

    public boolean empty() {
        //System.out.println(head == null);
        return head == null;        
    }

    public void append(T value) {

        Entry<T> newnode = new Entry<T>();
        newnode.value = value;

        if (empty()) {
            head = newnode;
            head.next = head;
            head.prev = head;
        }
        else {
            Entry<T> before = head.prev;
            Entry<T> after = head;

            newnode.prev = head.prev;
            newnode.next = head;
            head.prev.next = newnode;
            head.prev = newnode;    
        }
    }


    public void insert(int index, T value) {

        Entry<T> newnode = new Entry<T>();
        newnode.value = value;

        if (empty()) {
            head = newnode;
            head.next = head;
            head.prev = head;
        }
        else {
            Entry<T> before = head.prev;
            Entry<T> after = head;

            if(index == 0) {
                head = newnode;
            }
            else {
                while(index > 0) {
                    before = after;
                    after = after.next;
                    index--;
                }

                 newnode.prev = before;
                 newnode.next = after;
                 newnode.prev.next = newnode;
                 newnode.next.prev = newnode; 
            }
        }
    } // end insert()


    public void remove(int index) {

        Entry<T> before = head.prev;
        Entry<T> after = head;

        while(index > 0) {
            before = after;
            after = after.next;
            index--;
        }   

        after.prev.next = after.next;
        after.next.prev = after.prev;
    }


    public void prepend(T value) {
        insert(0, value);
    }


    public void appendList(CircularList<T> list) {

        if (empty()) {
            head = list.head;
            return;
        }
        if (list.empty()) return;

        Entry<T> a = list.head;
        Entry<T> b = list.head.prev;
        Entry<T> c = head;      
        Entry<T> d = head.prev;

        a.prev = d;
        d.next = a;

        b.next = c;
        c.prev = b;
    }


    @Override
    public Iterator<T> iterator() {
        return new myIterator(this);        

        //throw new UnsupportedOperationException("Not implemented yet.");
    }

    public static void toString(CircularList<Integer> list) {

        String sol = "";        

        //for (CircularList<Integer> list : data) {
            sol = sol +"\n"+ String.valueOf(list);            

        //}

        System.out.println(sol);
        //return sol;
    }
}

import java.util.Iterator；
公共类循环列表实现了Iterable{
私有静态类myIterator实现了迭代器{
int i=0；
循环型糜棱岩；
国际热核聚变实验堆；
公共myIterator（循环列表）{
iter=list.head；
myList=列表；
}
公共布尔hasNext（）{
返回！（myList.size（）==i）
}
公共交通工具{
//System.out.println（“下一步”）；
i++；
T nextvalue=iter.value；
//条目nextnode=新条目（）；
iter=iter.next；
返回下一个值；
}
公共空间删除（）{
如果（myList.size（）==1）{
myList.head=null；
回来
}
if（iter==myList.head）{
myList.head=myList.head.next；
}
iter.prev.next=iter.next；
iter.next.prev=iter.prev；
}
}//结束我的迭代器
私有静态类条目{
进入下一步；
进入前；
T值；
}
私人入口主管；
公共整数大小（）{
int指数=0；
输入之前=head.prev；
之后输入=头部；
//系统输出打印项次（头值）；
//System.out.println（在.value之后）；
做{
之前=之后；
after=after.next；
索引++；
}while（在！=头之后）；
收益指数；
}
公共布尔空（）{
//System.out.println（head==null）；
返回头==null；
}
公共无效附加（T值）{
Entry newnode=newentry（）；
newnode.value=值；
if（空（））{
头=新节点；
head.next=head；
head.prev=头；
}
否则{
输入之前=head.prev；
之后输入=头部；
newnode.prev=head.prev；
newnode.next=头部；
head.prev.next=newnode；
head.prev=newnode；
}
}
公共空白插入（整数索引，T值）{
Entry newnode=newentry（）；
newnode.value=值；
if（空（））{
头=新节点；
head.next=head；
head.prev=头；
}
否则{
输入之前=head.prev；
之后输入=头部；
如果（索引==0）{
头=新节点；
}
否则{
而（索引>0）{
之前=之后；
after=after.next；
索引--；
}
newnode.prev=before；
newnode.next=after；
newnode.prev.next=newnode；
newnode.next.prev=newnode；
}
}
}//结束插入（）
公共无效删除（整型索引）{
输入之前=head.prev；
之后输入=头部；
而（索引>0）{
之前=之后；
after=after.next；
索引--；
}   
after.prev.next=after.next；
after.next.prev=after.prev；
}
公共无效预结束（T值）{
插入（0，值）；
}
公共列表（循环列表）{
if（空（））{
head=list.head；
回来
}
if（list.empty（））返回；
条目a=list.head；
条目b=list.head.prev；
条目c=头部；
条目d=head.prev；
a、 prev=d；
d、 next=a；
b、 next=c；
c、 prev=b；
}
@凌驾
公共迭代器迭代器（）{
返回新的myIterator（this）；
//抛出新的UnsupportedOperationException（“尚未实现”）；
}
公共静态void toString（循环列表）{
字符串sol=“”；
//用于（循环列表：数据）{
sol=sol+“\n”+字符串.valueOf（列表）；
//}
System.out.println（sol）；
//返回溶胶；
}
}

String.valueOf未获取数据。它只打印对象的文本表示，其中包括存储在内存中的区域（

@55f96302

）。像这样的方法应该会奏效：

for(String str : list)
{
    System.out.println(str);
}

---

您的问题是，您将

toString

a

static

方法。您还可以将其返回类型设置为

void

，而不是

String

。您需要在

CircularList

类中编写一些非静态的、带有签名的

公共字符串toString（）

，并让它返回您想要输出的

字符串。我还建议使用
@Override
注释，以便编译器检查签名是否正确。
您需要在循环列表类中从
java.lang.Object
重写
toString（）
。
因为它还没有完成，所以java打印打印内存地址的
java.lang.Object.toString（）
。
作为提醒，Java中的每个对象都扩展了
Java.lang.object
，首先，我建议您不要以这种方式重写toString（）方法。您的方法用于打印，而不是“返回”字符串对象。它与原始的toString方法完全不同。不管怎样，我想你现在得到的结果是循环列表中对象的地址

for(Integer data : list){
    system.out.println(data.toString());
}

另外，如果在
toString（）
上有
@Override
注释（就像在
iterator（）
上一样），编译器会通知OP它没有被成功重写@