为什么 is.binary 搜索返回随机负值，即使它以前有效

Question

I've been writing this program that reads in from a text file consisting of names and phone numbers. I created 2 arraylists both containing Item objects. names array list contains Item object haveing names as the key value and phone numbers as the value value. While the numbers array list is the opposite having the key value being phone numbers and the value value names.

Here is the code:

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
import java.io.FileNotFoundException;

public class Test 
{
    
public static void main(String[] args) throws FileNotFoundException
{
    File inputFile = new File("directory.txt");
    ArrayList<Item> names = new ArrayList<Item>();
    ArrayList<Item> numbers = new ArrayList<Item>();
    
    Scanner in1 = new Scanner(inputFile);
    while(in1.hasNextLine())
    {
        String name = in1.nextLine();
        String num = in1.nextLine();
        Item item = new Item(name , num);
        names.add(item);
    }
    
    Scanner in2 = new Scanner(inputFile);
    while(in2.hasNextLine())
    {
        String name = in2.nextLine();
        String num = in2.nextLine();
        Item item = new Item(num, name);
        numbers.add(item);
    }
    
    Collections.sort(names);
    Collections.sort(numbers);
    
    Scanner in = new Scanner(System.in);
    
    System.out.println("Enter number: ");
    String num = in.next();
    int index = Collections.binarySearch(numbers, new Item(num, null));
    System.out.println(index);
    System.out.println(numbers.get(index).getValue()); 
    
    System.out.println("Enter name: ");
    num = in.next();
    index = Collections.binarySearch(names, new Item(num, null));
    System.out.println(index);
    System.out.println(names.get(index).getValue());
        

}

}


public class Item implements Comparable<Item>
{
  
   public Item(String k, String v)
   { 
      key = k;
      value = v;
   }
   
   
   public String getKey()
   { 
      return key;
   }
   
   
   public String getValue()
   { 
      return value;
   }

   public int compareTo(Item otherObject)
   {
      Item other = (Item) otherObject;
      return key.compareTo(other.key);
   }

   private String key;
   private String value;
}

When testing entering the phone number it outputs the correct name and since it.binarysearch got the correct index but when entering a name outputs a random negative index value and I have no clue why. [Here is how the console looks like][1] [1]: https://i.stack.imgur.com/rrVEk.png

Sorry if this post is not so good. This is my first post and I really need help. Can't figure this out

Answer 1

In the part where you enter a number, you then search by a number.

In the second part where you enter a name, you search for a number. That will not find a name.

Your Item class only compares numbers (you call them key and value rather than number and name, it will be clearer if you fix that). You might want two classes (eg NumberItem and NameItem ), one which compares by number, the other which compares by name (make them inherit from Item , which doesn't implement Comparable ).

Another strategy is to use the existing tools, and store each type of Item in a Map , one indexed by number, the other by name. The internal implementation will probably be more efficient than what you come up with.

Answer 2

By using IntelliJ and a debugger I was able to discover the issue:

num = in.next();

If you debug right after and you look at num value, you will see it will be: Smith,

Seems that the whitespace is the problem here

Let's find out why:

If we take a look at Scanner.next() documentation:

Finds and returns the next complete token from this scanner. A complete token is preceded and followed by input that matches the delimiter pattern. This method may block while waiting for input to scan, even if a previous invocation of hasNext returned true.

This means that the scanner will take only the text until it encounters the delimiter. Who is the delimiter? It should be a default one if you didn't provide it, right? Let's take a look again in Scanner class and search for the default delimiter.

Right at the top of the class the documentation states:

A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace . The resulting tokens may then be converted into values of different types using the various next methods.

So, the whitespace cuts your input from the keyboard.

Bonus some easy tips & tricks that will help you:

• Name the variables simple and easy to understand. Check out some guides on naming best practices(especially in Java) and naming conventions in Java.
• Use the debugger.
• When your code is not doing what you think it should and you are using "3rd party classes", try to look at what and how are they doing the things under the hood. It is enough in most of the cases just to read their documentation(and IDEs like IntelliJ facilitate this by just holding ctrl and pressing click on the method name, it will point you right to the implementation where you can see the method's documentation).