Java 回路中返回

我必须编写一个函数来从linkedlist（我的，而不是Collections框架的）中删除元素，因此这是我的第一次尝试：

public void remove(E element) {
    Cell<E> cell = sentinel;
    int i = 0;
    while (i < count) {
        if (cell.getElement().equals(element)) {
            cell.getPrevious().setNext(cell.getNext());
            --count;
            return;
        }
        ++i;
        cell = cell.getNext();
    }
}

但是，由于它不是非常可读，而且每个人都说可读性是java中的首要问题，所以我不得不考虑另一种方法。所以我改变了条件，使用了一个额外的布尔值

public void remove(E element) {
    boolean found = false;
    Cell<E> cell = sentinel;
    int i = 0;
    while (!found && i < count) {
        if (cell.getElement().equals(element))
            found = true;
        else {
            ++i;
            cell = cell.getNext();
        }
    }
    if (found) {
        cell.getPrevious().setNext(cell.getNext());
        --count;
    }
}

公共作废删除（E元素）{
布尔值=false；
细胞=哨兵；
int i=0；
而（！found&&i

这样，就不会有奇怪的

返回

，指令只有在必须执行时才会执行。如果我再次遇到这个问题，我想我必须像这样重新编写循环。

---

也许我完全错了，第一种方法更好。你觉得怎么样？

在我看来，如果不太复杂的话，早点回来是完全可以的。类似于使用break语句提前中断循环

你可以看看程序员的这个问题，他们每个人都提出了正确的观点。

---

在我看来，如果不太复杂的话，早点回来是完全可以的。类似于使用break语句提前中断循环

你可以看看程序员的这个问题，他们每个人都提出了正确的观点。

---

这完全是一个选择的问题，他们所提到的任何走出循环的方法都没有错，只需要记住两件事

当您不想在特定方法的循环外执行其余代码并返回调用方时，可以使用Return

当您不想执行该命令时，可以使用布尔值

true或false

循环，但您仍然希望继续使用中的其余代码 这种方法

---

这完全是一个选择的问题，他们所提到的任何走出循环的方法都没有错，只是要记住两件事

当您不想在特定方法的循环外执行其余代码并返回调用方时，可以使用Return

当您不想执行该命令时，可以使用布尔值

true或false

循环，但您仍然希望继续使用中的其余代码 这种方法

---

在函数中分离逻辑，有些只读取，有些只更改状态。如果你有一个查找功能的话，在搜索过程中，你可以很清楚地返回。 比如说

public void remove(E element) {
    Cell<E> cell = FindCell(element);
    if (cell != null)
        RemoveCell(cell);
}

private <E> FindCell(E element) {
    <E> cell = sentinel;
    int i = 0;
    while (i < count) {
        if (cell.getElement().equals(element)) {
            return cell;
        }
        ++i;
        cell = cell.getNext();
    }

    return null;
}

private void RemoveCell(<E> cell) {
    cell.getPrevious().setNext(cell.getNext());
    --count;
}

公共作废删除（E元素）{
单元=FindCell（元素）；
如果（单元格！=null）
去除细胞（细胞）；
}
专用FindCell（E元素）{
细胞=哨兵；
int i=0；
而（我<计数）{
if（cell.getElement（）.equals（element））{
返回单元；
}
++一,；
cell=cell.getNext（）；
}
返回null；
}
专用void RemoveCell（单元格）{
cell.getPrevious（）.setNext（cell.getNext（））；
--计数；
}

这种分离给了你一些好处。您可以根据需要多次调用只读函数（可能在并行线程中），并且您肯定知道不会发生任何事情。举例来说，C++有const函数

---

当您需要中断两个或多个嵌套循环时，return非常方便

函数中的独立逻辑，其中一些只读取，另一些只更改状态。如果你有一个查找功能的话，在搜索过程中，你可以很清楚地返回。 比如说

public void remove(E element) {
    Cell<E> cell = FindCell(element);
    if (cell != null)
        RemoveCell(cell);
}

private <E> FindCell(E element) {
    <E> cell = sentinel;
    int i = 0;
    while (i < count) {
        if (cell.getElement().equals(element)) {
            return cell;
        }
        ++i;
        cell = cell.getNext();
    }

    return null;
}

private void RemoveCell(<E> cell) {
    cell.getPrevious().setNext(cell.getNext());
    --count;
}

公共作废删除（E元素）{
单元=FindCell（元素）；
如果（单元格！=null）
去除细胞（细胞）；
}
专用FindCell（E元素）{
细胞=哨兵；
int i=0；
而（我<计数）{
if（cell.getElement（）.equals（element））{
返回单元；
}
++一,；
cell=cell.getNext（）；
}
返回null；
}
专用void RemoveCell（单元格）{
cell.getPrevious（）.setNext（cell.getNext（））；
--计数；
}

这种分离给了你一些好处。您可以根据需要多次调用只读函数（可能在并行线程中），并且您肯定知道不会发生任何事情。举例来说，C++有const函数

---

当您需要中断两个或多个嵌套循环时，return非常方便

return

在您的第一种方法中非常完美这主要是基于观点的。我更喜欢在循环的中间返回，因为我认为额外的变量（即布尔<代码>发现）会降低可读性。另外，请注意，您的第二种方法与您调用的第一个布尔值不同，

cell=cell.next（）

。。谁说这不可读？我想它比第二种更具可读性。如果您使用

break

而不是

return

，您是否仍然认为第一种样式的可读性较差？它在功能上是相同的，并且避免了额外的变量，但只有一个返回点。可读性总体上是一个相当主观的领域，但有一些代理可以使用：更少的变量、更少的语句/表达式、更简单的条件、更少的分支和更少的嵌套块通常会导致更好的可读性。所有这些似乎都表明，您的第一个解决方案对于大多数人来说可能更具可读性，尽管来自循环的

返回在某种程度上混淆了控制流。但是如果你在不同的地方有多个
return
语句，情况可能会相反。
return
在你的第一种方法中是完美的，这主要是基于观点的。我更喜欢在循环的中间返回，因为我认为额外的变量（即布尔<代码>发现）会降低可读性。另外，请注意，第二种方法与您调用的第一个布尔值
cell=cell不同