Java：按完整与否对1d对象数组排序

我试图压缩一组对象，这些对象将有空项和完整项。我想把所有完整的元素放在开头，顺序与开头相同，空元素放在结尾

所讨论的对象使用字符串字段“name”和int字段“weight”。空版本分别有“无名称”和0。因此，该方法需要处理的类型的数组将包含以下内容：

• 弗雷德| 4
• 鲍勃| 3
• 没有名字| 0
• 吉娜| 9
• 没有名字| 0
• Yuki | 7

通过该方法输入后，数组应该是Fred、Bob、Gina、Yuki，没有名字，没有名字

我对第一步的想法是找出哪些是满的，哪些不是满的，所以我想出了这个：

public void consolidate() {
    boolean[] fullSlots = new boolean[spaces.length];

    // pass 1: find empties
    for (int i = 0; i < spaces.length; i++) {
        fullSlots[i] = spaces[i].getName().equals("no name");
    }
}

公共作废合并（）{
boolean[]fullSlots=新的boolean[spaces.length]；
//第1关：找到空的
for（int i=0；i

空格是对象的数组，getName（）从对象中检索名称字段

我不知道接下来该怎么办。建议

编辑：好的，下面是Infested想出的：

public void consolidate()
{
    int numberOfEmpties = 0, spacesLength = spaces.length;
    Chicken[] spaces2 = new Chicken[spacesLength];
    for(int i = 0; i < spaces.length; i++)
    {
        spaces2[i] = new Chicken(spaces[i].getName(),
                                        spaces[i].getWeight());
    }

    // pass 1: find empties
    for (int i = 0, j = 0; i < spacesLength; i++)
    {
        if (spaces2[i].getName().equals("no name") == false)
        {
            spaces[j] = new Chicken(spaces2[i].getName(),
                                        spaces2[i].getWeight());
            j++;
        }
        else
        {
            numberOfEmpties++;
        }
    }
    for (int i = spacesLength - 1; numberOfEmpties > 0 ; numberOfEmpties--, i--)
    {
       spaces[i] = new Chicken("no name", 0);
    }
}

公共作废合并（）
{
int numberofputtings=0，spacesLength=spaces.length；
鸡肉[]空格S2=新鸡肉[空格长度]；
for（int i=0；i0；NumberOfPenttings--，i--）
{
空格[i]=新鸡（“没有名字”，0）；
}
}

---

测试并运行。

Java的

array.sort

是稳定的，这意味着相等元素的相对顺序不会改变

这种排序保证是稳定的：相等的元素不会因排序而重新排序

您可以使用排序算法的此属性，使用简单的比较器对所有元素进行排序：

Arrays.sort(
    spaces
,   new Comparator() {
          public int compare(Object o1, Object o2) {
              MyClass a = (MyClass)o1;
              MyClass b = (MyClass)o2;
              boolean aIsEmpty = "no name".equals(a.getName());
              boolean bIsEmpty = "no name".equals(b.getName());
              if (aIsEmpty && !bIsEmpty) {
                  return 1;
              }
              if (!aIsEmpty && bIsEmpty) {
                  return -1;
              }
              return 0;
          }
    }
);

这将在名称为空的项目之前对名称为非空的所有项目进行排序，使两组对象在各自组中的相对顺序保持不变

---

如果您的空间限制允许您创建一个新的

MyClass

数组，那么您可以使用更简单的算法：遍历原始数组一次，并对非空项进行计数。然后创建一个新数组，并创建两个索引：

idxNonEmpty=0

，和

idxEmpty=NonEmptyCount+1

。然后再次检查原始数组，将非空对象写入

idxNonEmpty++

，将空对象写入

idxEmpty++

Java的

数组。sort

是稳定的，这意味着相等元素的相对顺序不会改变

这种排序保证是稳定的：相等的元素不会因排序而重新排序

您可以使用排序算法的此属性，使用简单的比较器对所有元素进行排序：

Arrays.sort(
    spaces
,   new Comparator() {
          public int compare(Object o1, Object o2) {
              MyClass a = (MyClass)o1;
              MyClass b = (MyClass)o2;
              boolean aIsEmpty = "no name".equals(a.getName());
              boolean bIsEmpty = "no name".equals(b.getName());
              if (aIsEmpty && !bIsEmpty) {
                  return 1;
              }
              if (!aIsEmpty && bIsEmpty) {
                  return -1;
              }
              return 0;
          }
    }
);

这将在名称为空的项目之前对名称为非空的所有项目进行排序，使两组对象在各自组中的相对顺序保持不变

---

如果您的空间限制允许您创建一个新的

MyClass

数组，那么您可以使用更简单的算法：遍历原始数组一次，并对非空项进行计数。然后创建一个新数组，并创建两个索引：

idxNonEmpty=0

，和

idxEmpty=NonEmptyCount+1

。然后再检查一次原始数组，将非空对象写入

idxNonEmpty++

，将空对象写入

idxEmpty++

我假定它是类的一种方法：

public void consolidate()
{
    int lengthOfSpaces = spaces.length , i, numberOfEmpties = 0;
    Type[] spacesNumberTwo = new Type[lengthOfSpaces ];

    // pass 1: find empties
    for (i = 0; i < lengthOfSpaces ; i++)
    {
        if(spaces[i].getName().equals("no name") == false)
             spacesNumberTwo[i] = new Type(spaces[i].getName(), spaces[i].getInt());
        else
          numberOfEmpties++;
    }
    for (i = lengthOfSpaces - 1; numberOfEmpties > 0 ; numberOfEmpties--, i--)
    {
           spacesNumberTwo[i] = new Type("no name", 0);
    }
    spaces = spacesNumberTwo
}

公共作废合并（）
{
int lengthOfSpaces=spaces.length，i，numberofexports=0；
类型[]spacesNumberTwo=新类型[Lengthofspace]；
//第1关：找到空的
对于（i=0；i0；NumberOfPenttings--，i--）
{
spacesNumberTwo[i]=新类型（“无名称”，0）；
}
spaces=spacesNumberTwo
}

我将假定它是类中的一种方法：

public void consolidate()
{
    int lengthOfSpaces = spaces.length , i, numberOfEmpties = 0;
    Type[] spacesNumberTwo = new Type[lengthOfSpaces ];

    // pass 1: find empties
    for (i = 0; i < lengthOfSpaces ; i++)
    {
        if(spaces[i].getName().equals("no name") == false)
             spacesNumberTwo[i] = new Type(spaces[i].getName(), spaces[i].getInt());
        else
          numberOfEmpties++;
    }
    for (i = lengthOfSpaces - 1; numberOfEmpties > 0 ; numberOfEmpties--, i--)
    {
           spacesNumberTwo[i] = new Type("no name", 0);
    }
    spaces = spacesNumberTwo
}

公共作废合并（）
{
int lengthOfSpaces=spaces.length，i，numberofexports=0；
类型[]spacesNumberTwo=新类型[Lengthofspace]；
//第1关：找到空的
对于（i=0；i0；NumberOfPenttings--，i--）
{
spacesNumberTwo[i]=新类型（“无名称”，0）；
}
spaces=spacesNumberTwo
}

你在哪里整理你的字符串？我没有。其思想是在不改变完整对象顺序的情况下，将完整对象排序到开头，将空对象排序到结尾。您将字符串排序到哪里？我没有。其思想是在不改变完整对象顺序的情况下，将完整对象排序到开头，将空对象排序到结尾。我们还没有研究比较器。“我相信这会奏效，但不幸的是，我不知道这意味着什么。”“星剑”试试第二种算法，它更容易接近。如果是