Java 尝试冒泡排序时出现空指针异常

我正在编写一个冒泡排序方法，该方法涉及对字符串进行标记，我不断得到一个神秘的空指针异常

该方法采用字符串数组。每个字符串包含四个标记：姓、名、社会保险号和年龄。该方法需要能够按这些令牌中的任何一个进行排序，因此它将每个字符串分解为令牌，将令牌放置在数组中，然后使用气泡排序对令牌进行排序，根据令牌排序重新排列数组中的每个字符串

当我尝试将第二个字符串拆分为令牌并将其保存到数组中时，会发生错误

这是密码

            for (int i=0; i< array.length;i++) {


              String s1 = sortedArray[i];
              String s2 = sortedArray[i+1];

              String[] holdingArray1;
              String[] holdingArray2;

              holdingArray1 = s1.split("\\s+");
              holdingArray2 = s2.split("\\s+");



              int result = holdingArray1[0].compareTo(holdingArray2[0]);



              if (result > 0)
              {

                  sortedArray[i] = s2;
                  sortedArray[i+1] = s1; 
              }


              System.out.println(sortedArray[i]);
              System.out.println(sortedArray[i+1]);
            }

for（int i=0；i0）
{
Darray[i]=s2；
射线[i+1]=s1；
}
System.out.println（SorterDarray[i]）；
System.out.println（sortedArray[i+1]）；
}

i

可能小于array.length，但

i+1

可能不小于array.length。当您仅检查是否存在

i

元素时，您假设存在

i+1

元素。因此，

i+1

转到

null

，您不能

。拆分
null
i
可能小于数组长度，但
i+1
可能不小于数组长度。当您仅检查是否存在
i
元素时，您假设存在
i+1
元素。因此，
i+1
转到
null
，您不能
。拆分
null
您需要在小于array.length-1的情况下执行循环，因为您正在执行sortedArray[i+1]

for (int i = 0; i < array.length-1; i++)
{
  // logic
}

for（int i=0；i

下面是一个完整的冒泡排序算法示例

    public static int[] bubbleSort(int[] arr, Boolean descending)
    {
         Boolean finished = false;

         while (!finished)
         {
             Boolean held = false;
             int hold;

             for (int i = 0; i < arr.length-1; i++)
             {
                  int curr = arr[i];
                  int next = arr[i+1];
                  Boolean test = curr > next;
                  if (descending) test = curr < next;

                  if (test)
                  {
                     held = true;
                     hold = next;
                     arr[i] = hold;
                     arr[i+1] = curr;
                  }             
             }

             if (!held) finished = true;
          }

          return arr;
     }

公共静态int[]bubbleSort（int[]arr，布尔降序）
{
布尔完成=假；
当（！完成）
{
布尔值=假；
int hold；
对于（int i=0；i下一步；
如果（下降）测试=电流<下一步；
如果（测试）
{
保持=正确；
保持=下一步；
arr[i]=保持；
arr[i+1]=当前汇率；
}             
}
如果（！hold）finished=true；
}
返回arr；
}
您需要在小于array.length-1时执行循环，因为您正在执行sortedArray[i+1]

for (int i = 0; i < array.length-1; i++)
{
  // logic
}

for（int i=0；i

下面是一个完整的冒泡排序算法示例

    public static int[] bubbleSort(int[] arr, Boolean descending)
    {
         Boolean finished = false;

         while (!finished)
         {
             Boolean held = false;
             int hold;

             for (int i = 0; i < arr.length-1; i++)
             {
                  int curr = arr[i];
                  int next = arr[i+1];
                  Boolean test = curr > next;
                  if (descending) test = curr < next;

                  if (test)
                  {
                     held = true;
                     hold = next;
                     arr[i] = hold;
                     arr[i+1] = curr;
                  }             
             }

             if (!held) finished = true;
          }

          return arr;
     }

公共静态int[]bubbleSort（int[]arr，布尔降序）
{
布尔完成=假；
当（！完成）
{
布尔值=假；
int hold；
对于（int i=0；i下一步；
如果（下降）测试=电流<下一步；
如果（测试）
{
保持=正确；
保持=下一步；
arr[i]=保持；
arr[i+1]=当前汇率；
}             
}
如果（！hold）finished=true；
}
返回arr；
}
显示堆栈跟踪。堆栈跟踪将给出导致
NullPointerException
的确切行号。显示堆栈跟踪。堆栈跟踪将给出导致
NullPointerException
的确切行号。更准确地说，他实际上是在检查
数组的大小，但他访问
sortedArray
，该数组似乎已初始化为
null
数组，因此NPE。如果
i+1
大于
sortedArray.length
则他将获得ArrayIndexOutOfBoundsException？错误甚至可能是由s1引起的。更准确地说，他实际上是在检查
数组的大小，但他访问了
sortedArray
，该数组似乎已初始化为
null
，因此NPE。如果
i+1
大于
sortedArray.length
则他将获得ArrayIndexOutOfBoundsException？错误甚至可能是由s1.split引起的