基于java.util.linkedlist创建我自己的有限linkedlist

我想做一些简单的事情，创建我自己的基于java.util.linkedlist的list类，但我想限制可以做的事情。现在，我只想使用addFirst方法。我正在创建一个单链接列表。我遇到的问题是addFirst似乎没有被识别，我不确定我是否在自己的构造函数中正确创建了列表。这是我到目前为止的代码

import java.util.LinkedList;


public class singleList {

singleList() {
     new LinkedList();
 }

//  void add(name addName) {
//      addFirst(addName);
//  }


public static void main(String[] args) {

singleList nameList = new singleList();

 name name1 = new name("John", "Smith");
 nameList.add(name1);


System.out.println("LinkedList contains : " + nameList);

 }
}

正如您所看到的，我要做的是创建一个名为nameList的列表，此时，它唯一能做的就是使用add方法，它应该调用LinkedList的addFirst方法，将元素添加到列表中的第一个位置。这有意义吗

我得到的第一个错误是，它无法从add方法中找到符号“addFirst”，而且我也不确定singleList的构造函数是否正确

如果有人想知道，这是学校作业。 这是修改后的代码，我从第一个答案中得到了一些建议，这个答案看起来与另一个答案相似

public class SingleList {

private LinkedList internalList;

SingleList() {
     internalList = new LinkedList();
 }

void add(name addName) {
    internalList.addFirst(addName);
}

String get(int index) {

    return internalList.get(index).toString();

}


public static void main(String[] args) {

    SingleList nameList = new SingleList();

    name name1 = new name("John", "Smith");
    nameList.add(name1);

    String getter = nameList.get(0);  
    System.out.println("LinkedList contains : " + nameList.get(0));

}
}

---

您的类应实现列表接口并将其方法重定向到链接列表：

public class singleList implements List {
    private LinkedList internalList;

    public singleList() {
        internalList = new LinkedList();
    }
    public boolean add(Object e) {
        return internalList.add(e);
    }

    public remove(Object o) {
        throw new RuntimeException("Not implemented.");
    }

    ...
}

---

对于要限制的方法，只需抛出一个异常。

您的类应实现列表接口并将其方法重定向到链接列表：

public class singleList implements List {
    private LinkedList internalList;

    public singleList() {
        internalList = new LinkedList();
    }
    public boolean add(Object e) {
        return internalList.add(e);
    }

    public remove(Object o) {
        throw new RuntimeException("Not implemented.");
    }

    ...
}

---

对于想要限制的方法，只需抛出一个异常。

您发布的代码的问题是，您没有将

LinkedList

分配给任何对象，然后

addFirst（）

方法被编写为

singleList

类的静态方法，而该类不存在。我相信你想做的是：

import java.util.LinkedList;

public class SingleList<T>
{
    private LinkedList<T> internal;

    SingleList()
    {
        this.internal = new LinkedList<>();
    }

    public void add(T addName)
    {
        this.internal.addFirst(addName);
    }

    @Override
    public String toString()
    {
        if(!this.internal.isEmpty())
        {
            return this.internal.get(0).toString();
        }
        else
        {
            return this.internal.toString();
        }
    }

    public static void main(String[] args)
    {
        SingleList<name> nameList = new SingleList<>();
        name name1 = new name("John", "Smith");
        nameList.add(name1);
        System.out.println("LinkedList contains : " + nameList);
    }
}

import java.util.LinkedList；
公共类单选列表
{
私有链接列表内部；
SingleList（）
{
this.internal=新建LinkedList（）；
}
公共无效添加（T addName）
{
this.internal.addFirst（addName）；
}
@凌驾
公共字符串toString（）
{
如果（！this.internal.isEmpty（））
{
返回this.internal.get（0.toString（）；
}
其他的
{
返回此.internal.toString（）；
}
}
公共静态void main（字符串[]args）
{
SingleList nameList=新的SingleList（）；
姓名1=新姓名（“约翰”、“史密斯”）；
名称列表。添加（名称1）；
System.out.println（“LinkedList包含：“+名称列表”）；
}
}

---

这还具有泛型的优点，这意味着它可以使用

LinkedList

可以使用的任何类型。此外，我还随意更改了类名的大小写，因为Java标准是在类名上使用适当的大小写，而在变量上使用不合适的大小写。

您发布的代码的问题是没有将

LinkedList

分配给任何内容，然后是

addFirst（）

方法的编写方式就好像它是

singleList

类的静态方法一样，但该类并不存在。我相信你想做的是：

import java.util.LinkedList;

public class SingleList<T>
{
    private LinkedList<T> internal;

    SingleList()
    {
        this.internal = new LinkedList<>();
    }

    public void add(T addName)
    {
        this.internal.addFirst(addName);
    }

    @Override
    public String toString()
    {
        if(!this.internal.isEmpty())
        {
            return this.internal.get(0).toString();
        }
        else
        {
            return this.internal.toString();
        }
    }

    public static void main(String[] args)
    {
        SingleList<name> nameList = new SingleList<>();
        name name1 = new name("John", "Smith");
        nameList.add(name1);
        System.out.println("LinkedList contains : " + nameList);
    }
}

import java.util.LinkedList；
公共类单选列表
{
私有链接列表内部；
SingleList（）
{
this.internal=新建LinkedList（）；
}
公共无效添加（T addName）
{
this.internal.addFirst（addName）；
}
@凌驾
公共字符串toString（）
{
如果（！this.internal.isEmpty（））
{
返回this.internal.get（0.toString（）；
}
其他的
{
返回此.internal.toString（）；
}
}
公共静态void main（字符串[]args）
{
SingleList nameList=新的SingleList（）；
姓名1=新姓名（“约翰”、“史密斯”）；
名称列表。添加（名称1）；
System.out.println（“LinkedList包含：“+名称列表”）；
}
}

这还具有泛型的优点，这意味着它可以使用

LinkedList

可以使用的任何类型。此外，我还随意更改了类名的大小写，因为Java标准是在类名上使用适当的大小写，在变量上使用大小写

• 除非您的类

  扩展
  链接列表
  类（或其他
  列表
  类）或
  实现
  列表
  接口，否则它不会是
  列表
  

• 如果您的类不是

  列表

  ，那么它就不会有

  addFirst

  方法（除非您定义了一个）。这就是为什么在

  add

  方法中不能调用

  addFirst

  方法

• 您的构造函数正在创建一个

  LinkedList

  实例。。。然后把它扔掉。这是毫无意义的。我想你应该把它分配给。。。某物（提示）

• 语句

  println（“LinkedList包含：“+nameList”）

  将调用

  nameList

  对象上的

  toString（）

  方法将其转换为字符串。由于您创建的类不扩展现有的

  列表

  类，因此需要重写

  对象

  提供的

  toString

  。'因为那个版本不会显示你列表的内容

这里您可以使用两种方法。您可以创建一个重写父类（

List

）行为的类，也可以创建一个包含真正的

List

类的“包装器”类。你两个都不做

包装器类可能会更简单地解决您当前的需求。。。假设您不需要真正的

列表

类。另一种方法将要求您覆盖您想要阻止的每个方法，让它抛出异常（通常是…），这样做对于

LinkedList

API中的所有操作都会很乏味

最后，请注意，Java类名应该总是以大写字母开头。

从哪里开始System.out.println("LinkedList contains : " + nameList);

@Override
public String toString() {
    return listName.toString();
}

import java.util.LinkedList;

class Name {
    private String firstName;
    private String secondName;

    public Name(String firstName, String secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }

    @Override
    public String toString() {
        return "Name [firstName=" + firstName + ", secondName=" + secondName + "]";
    }
}

public class SingleList { //should have a better name perhaps

    private LinkedList<Name> listName = new LinkedList<>();

    public SingleList() {
    }

    void addFirst(Name name) {
        listName.addFirst(name);
    }

    @Override
    public String toString() {
        return listName.toString();
    }

    public static void main(String[] args) {
        SingleList listName = new SingleList();

        Name newName = new Name("John", "Smith");
        listName.addFirst(newName);

        System.out.println("LinkedList contains : " + nameList);
    }
}