I hate NullPointerExceptions!

[Mario Martinez]

I keep getting a NullPointerException, on the FOR line. FindTeam is suppose to search through TeamList and find the matching team name, and if no match is found, return null so that teamlist can add the new team. The problem is, how is findteam suppose to search teamlist during the first try, if the list is empty? (teamlist adds to the arraylist after Findteam returns the statement). Its been bugging me all week.
I initilized teamList as ArrayList teamList = new ArrayList();

//Private method FindTeam(teamName)
//Search through teamList and return the TeamData object whose name is teamName
// Return null if teamName isn't found
private TeamData FindTeam(String teamName) {

CODE HERE
int i = 0;
TeamData teamStored;

int i;
for (i=0; i < teamList.size(); i++);{
teamStored = ((TeamData)teamList.get(i));
if (teamName.equalsIgnoreCase(teamStored.getName()));
return (TeamData)teamList.get(i);
}


}
//Look for winning team and losing team in teamList
//create/add or update the TeamData objects accordingly

test = new TeamData(winnerName, true, year);
TeamData winner = FindTeam(winnerName);
if (winner == null) {teamList.add(test);}
winner.updateRecord(true, year);
[ October 10, 2002: Message edited by: Mario Martinez ]

[Roger Gazdzicki]

try this

  
Boolean add = true;
int i;
for (i=0; i < teamList.size(); i++);{
teamStored = ((TeamData)teamList.get(i));
if (teamName.equalsIgnoreCase(teamStored.getName()));
add = false;
int found = i;
}
if(!add){
   return (TeamData)teamList.get(found); 
}else{
   test = new TeamData(winnerName, true, year);
}

Might work

[Mario Martinez]

hmmm, I talked with my proffessor, he said to initilize teamlist WITHOUT redeclaring it.
Arent I initilizing teamList by doing:
ArrayList teamList = new ArrayList()?

At the beginning of the program there is
private ArrayList teamList;

and in:
private TournamentArchive (BufferedReader reader) throws IOException {
//Initialize teamList
ArrayList teamList = new ArrayList();

.
.
.
.
.
TeamData winner = FindTeam(winnerName);
if (winner == null) {teamList.add(winnerName);}

[Roger Gazdzicki]

It seems to me that you are initializing the array but you are trying to call the arraysize. the size is null which is not valid in a for loop. the for loop will require an integer. there needs to be some sort of check to see if it is null before you try to use it. if it is null then there is no sense in entering the loop. I cannot be too much help but I hope this helps.

[Mario Martinez]

Originally posted by Roger Garner:
It seems to me that you are initializing the array but you are trying to call the arraysize. the size is null which is not valid in a for loop. the for loop will require an integer. there needs to be some sort of check to see if it is null before you try to use it. if it is null then there is no sense in entering the loop. I cannot be too much help but I hope this helps.

Yea thats what I was thinking, I was told that I should initilize teamlist without redclaring it (to solve the problem) but I dont know how

Thanks for your help though!

[Barry Gaunt]

if (teamName.equalsIgnoreCase(teamStored.getName()));
Is that semicolon really there?

[Mario Martinez]

Originally posted by Barry Gaunt:
if (teamName.equalsIgnoreCase(teamStored.getName()));
Is that semicolon really there?

Damn those diry little habits
Say, would you happen to know how to initinize an array list without redeclaring it?

[Marilyn de Queiroz]

What if you initialize the ArrayList in a static block.

[Sayed Ibrahim Hashimi]

hmmm, I talked with my proffessor, he said to initilize teamlist WITHOUT redeclaring it.
Arent I initilizing teamList by doing:
ArrayList teamList = new ArrayList()?

At the beginning of the program there is
private ArrayList teamList;

and in:
private TournamentArchive (BufferedReader reader) throws IOException

Based on that then your problem is a scope issue, because in the method that you are "initializing" it you are actually declaring and initializing another variable. Here's an example, compile and run this and see what happens.

import java.util.*;
public class MyClass
{
    private ArrayList list;
   
    public void init()
    {
        ArrayList list = new ArrayList();
        //when you redeclare it you are creating a new variable that can only be
        //seen in this method.
        list.add("1");    //adding to the local list variable
        list.add("2");
        list.add("3");        
        System.out.println("Size: " + list.size() );
    }
    public void test()
    {
        //this will throw null pointer exception
        System.out.println("Size: " + list.size() );
    }
    public void initCorrect()
    {
        //this will initialize the instance variable list.
        list = new ArrayList();
        list.add("1");    //adding to the local list variable
        list.add("2");
        list.add("3");        
        System.out.println("Size: " + list.size() );        
    }
    public static void main(String args[])
    {
        MyClass obj = new MyClass();
        //first lets do it wrong
        obj.init();
        System.out.println("Calling test() after init()");
        try
        {
            obj.test();
        }
        catch(NullPointerException npe)
        {
            System.out.println("NullPointerException\n");
        }
       
        //now lets do it right
        obj.initCorrect();
        try
        {
            obj.test();
        }
        catch(NullPointerException npe)
        {
            System.out.println("NullPointerException");
        }
    }
}//end MyClass

Hope this helps.

[Dirk Schreckmann]

would you happen to know how to initinize an array list without redeclaring it?
An example of redeclaring it:

private ArrayList list = new ArrayList() ;
 
public void someMethod() 
{
  ArrayList list = new ArrayList() ;
  ...
}

An example of not redeclaring it:

private ArrayList list = new ArrayList() ;
 
public void someMethod() 
{
  list = new ArrayList() ;
  ...
}

[ October 10, 2002: Message edited by: Dirk Schreckmann ]

[Jim Yingst]

It sounds like you've actually created two different teamList variables without realizing it. The original

    private ArrayList teamList;

creates a member variable teamList and sets it to null. Then in:

    private TournamentArchive (BufferedReader reader) throws IOException {
        // Initialize teamList
        ArrayList teamList = new ArrayList();
}

you create a new local variable temaList and initialize it. This is an unfortunate "feature" in java - if you declare a variable twice, once as a local variable and once as a member (or class) variable, the compiler assumes you're talking about two different variables. It would be best to avoid this confusing situation, which is why your instructor suggests initializing without redeclaring:

    private TournamentArchive (BufferedReader reader) throws IOException {
        // Initialize teamList
        teamList = new ArrayList();
}

Simply omit the type specifier "ArrayList", and the compiler no longer thinks you're trying to declare a new variable.
An even eaier approach, IMO, is to initialize the variable when you first declare it:

    private ArrayList teamList = new ArrayList();

Now there's no need to do anything else to teamList inside the TournamentArchive constructor - it's already done.

[Mario Martinez]

right-o guys, I did as you said, but im still getting a nullpointerexception. The error happends in TeamData FindTeam which is used to search through teamlist for teams and return with team, or null if not found. But as said earlier, this cant be done beacuse at first try, teamlist has a size of 0. Here is the code: # 4 and #2 is the cause of the nullpoint

import java.io.*;
import java.util.*;
public class TournamentArchive {
  
  
//  Declare an ArrayList (of TeamData Objects)
  private ArrayList teamLis;

/////////////////////////////////////////////////////////////////////////////////////
// (3)  //////////////////////////////////////////////////////////////////////
//    
//  DatafileException class
  private class DatafileException extends RuntimeException {
//  
    private String message = "";
    private int lineNum;
//    
    public DatafileException(String m, int line) {
//      
//      initialize message and lineNum
//      CODE HERE 
      lineNum = line;
      message = m;
    }
//    
    public String toString() {
//      
//      return a String representation of this DatafileException object
//      CODE HERE ????????????????
      return message + lineNum; // (Change this)
    } 
  }
////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
// (4)   //////////////////////////////////////////////////////////////////////
//    
//  Private method FindTeam(teamName)
//  Search through teamList and return the TeamData object whose name is teamName
//  Return null if teamName isn't found
//
  private TeamData FindTeam(String teamName) {
//    
//    CODE HERE
  //  int i = 0;

//[B]NULLPOINT AT FOR DAMMIT DAMMIT DAMMIT DAMMIT[/B]
      TeamData teamStored;
  
    int i = 0;
    for (i=0; i < teamList.size(); i++);{
    teamStored = ((TeamData)teamList.get(i));
    if (teamName.equalsIgnoreCase(teamStored.getName()));
      return (TeamData)teamList.get(i);    
    }
      
      
      } 
  
////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// (2)  
//////////////////////////////////////////////////////////////////////
//
//  Private constructor - only called from main().
//  Load data from the file wrapped in reader.
//  Might throw IOException
  private TournamentArchive (BufferedReader reader) throws IOException {
//
    StringTokenizer st;
    int year = 0;
    String winnerName = "";
    String runnerUpName = "";
    String nextGame = reader.readLine();
    int lineCount = 0;
  
//    Initialize teamList
//[B]ININTILIZE WITHOUT REDECLARING?![/B]   
teamList = new ArrayList();
    TeamData test;
    while (nextGame != null) {
      lineCount++;
//      Try to tokenize nextLine and extract the year and the two teams that played
//      might throw DatafileFormatException, NoSuchElementException
      try {
        st = new StringTokenizer(nextGame, ":");
//        
        year = Integer.parseInt(st.nextToken());
//      
//        Read team names from st
        winnerName = st.nextToken();
        runnerUpName = st.nextToken();
        if (winnerName.equalsIgnoreCase(runnerUpName))
          throw new DatafileException("Error: " + winnerName + " couldn't have played itself", lineCount);
        
//        Look for winning team and losing team in teamList
//        create/add or update the TeamData objects accordingly
        
      
    
        TeamData winner = FindTeam(winnerName);
        if (winner == null) {teamList.add(winnerName);}
        winner.updateRecord(true, year);
        TeamData runner = FindTeam(runnerUpName);
        if (runner == null){teamList.add(runnerUpName);}
        runner.updateRecord(false, year);
  
      }
      catch (DatafileException e) {
        System.out.println(e);
        System.out.println(nextGame);
      }
      catch (NoSuchElementException e) {
        System.out.println(new DatafileException("File format error", lineCount));
        System.out.println(nextGame);
      }

//        update nextGame
        nextGame = reader.readLine(); 
    } 
        
  }
//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// (6)  ///////////////////////////////////////////////////////////////////////
//
//  Comparator classes
//
  private class CompareTeamsByName implements Comparator {
//    
    public int compare(Object firstObject, Object secondObject) {
//      
//      Cast the arguments back to TeamData objects
      TeamData team1 = (TeamData)firstObject;
      TeamData team2 = (TeamData)secondObject;
//
//      Return some negative int if team1's name is "less than" team2's name
//      Return 0 if team1's name "equals" team2's name
//      Return some positive int if team1's name is "greater than" team2's name
      return team1.getName().compareTo(team2.getName());
    }
//  
  }
//
  private class CompareTeamsByWins implements Comparator {
//
    public int compare(Object firstObject, Object secondObject) {
//
//      Cast the arguments back to TeamData objects
      TeamData team1 = (TeamData)firstObject;
      TeamData team2 = (TeamData)secondObject;
//
//      Return some positive int if team1 has fewer wins than team2
//      Return 0 if team1 and team2 have the same number of wins
//      Return some negative int if team1 has more wins than team2
//      CODE HERE 
    
    
      return team1.getName().compareTo(team2.getName());
    
    }
//  
  }
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
// (5)  //////////////////////////////////////////////////////////////////////////
//
//  Private method SortTeamList()
//  Sort teams by name and by number of wins, print result to file
  private void SortTeamList()  {
//    
    int numTeams = teamList.size();
    int i;
//        
//    Sort teamList alphabetically by name
    String outputByName = "";
    Collections.sort(teamList, new CompareTeamsByName());   
//    
    for (i=0; i<numTeams; i++)
      outputByName += ((TeamData)teamList.get(i)).toString();
//    
//    
//    Sort teamList by number of wins
    String outputByWins = "";
//
//    CODE HERE
    Collections.sort(teamList, new CompareTeamsByWins());
    for (i=0; i<numTeams; i++)
      outputByWins += ((TeamData)teamList.get(i)).toString();
//    
    System.out.println(outputByName);
    System.out.println(outputByWins);
//        
    String outFilename = "teams-by-name.txt";
    PrintWriter writer;
//    
//    Try to open outFilename and write output
//    Might throw IOException
    try {
      writer = new PrintWriter( new FileWriter(outFilename));
      writer.print(outputByName);
      writer.close();
      outFilename = "teams-by-wins.txt";
//            Create a FileWriter object for outFilename.  Wrap it in a PrintWriter.  Assign it to writer.
//      print outputByWins through writer
      writer = new PrintWriter( new FileWriter(outFilename));
      writer.print(outputByWins);
      writer.close();
    }
    catch (IOException e) {
      System.out.println("Unable to open " + outFilename);
      return;
    }
      
  }
//
///////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////// MAIN  ///////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
  public static void main(String[] args) {
        
    TournamentArchive archive;
    BufferedReader br = null;
    String filename = "";
    String read;
    
    System.out.println("NCAA Men's Basketball Tournament Archive\n");
    // Prompt the user for a data file name from the System.out console
    System.out.print("Please enter the tournament data file.. ");
    System.out.println("eg ncaa-test.data, ncaa2001.data, etc.");
    
    
    
/////////////////////////////////////////////////////////////////////////////////////
// (1)  //////////////////////////////////////////////////////////////////////
//    Create a InputStreamReader for System.in.  Wrap it in a new BufferedReader.
//    Assign br to the new BufferedReader..
//
//    CODE HERE ??????????????????
    br = new BufferedReader(new InputStreamReader(System.in));
//    
    try {
//      
//    Try to read the input from the BufferedReader (an IOException may be thrown)
//
//    CODE HERE ???????????????????
    read = br.readLine();         
//
//    Try to open filename by creating a FileReader (a FileNotFoundException may be thrown).
//    Wrap the FileReader in a new BufferedReader.  Assign br to the new BufferedReader
    
        
  
    br = new BufferedReader(new FileReader(read));
    //  throw new FileNotFoundException();  // (Change this)
    }
//    If opening filename fails, catch the FileNotFoundException,
//    print an error message, and return from main.
    catch (FileNotFoundException e) {
      System.out.println("Error when opening " + filename + ".  Exiting..");
      return;
    }
//    If readLine() fails for some weird reason, catch the IOException,
//    print an error message to System.out and return from main.
    catch (IOException e) {
      System.out.println("Error when reading from System.in.  Exiting..");
      return;
    }
//
//
//
//    If we can read the file ok, try to create a TournamentArchive object using br.
//    Might throw IOException
    try {
      archive = new TournamentArchive(br);
    }
    catch (IOException e) {
      System.out.println("Error when reading from " + filename + ".  Exiting..");
      return;
    }
//
    archive.SortTeamList();
//
/////////////////////////////////////////////////////////////////////////////////////
    
  } 
  
}

[ edit to remove those evil tab characters -ds ]
[ October 10, 2002: Message edited by: Dirk Schreckmann ]

[Mario Martinez]

Yay!!! Thanks to all of your fine help, ive manage to get rid of that annoying NullPointerException.
But you know what they they...more code, more problems
I added if (lineCount ==1){teamList.add(winnerName);} right before FindTeam is tested. That way the first time its excuted, the array will add the object to be used in findteam.
But...

NCAA Men's Basketball Tournament Archive
Please enter the tournament data file.. eg ncaa-test.data, ncaa2001.data, etc.
ncaa-test.data.txt
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size:
1
        at java.util.ArrayList.RangeCheck(ArrayList.java:508)
        at java.util.ArrayList.get(ArrayList.java:320)
        at TournamentArchive.FindTeam(TournamentArchive.java:68)
        at TournamentArchive.<init>(TournamentArchive.java:120)
        at TournamentArchive.main(TournamentArchive.java:311)
Press any key to continue...

now I get a new error

[Barry Gaunt]

if (teamName.equalsIgnoreCase(teamStored.getName()));
Why is that semicolon there? Think about the impact of that semicolon being in that particular place.
Here too:
for (i=0; i < teamList.size(); i++);{

anArrayListInstance.clear() will remove all the contents from an ArrayList Instance.
-Barry
[ October 10, 2002: Message edited by: Barry Gaunt ]

[Barry Gaunt]

BTW, NullPointerExceptions point along the road to
Java Enlightenment. Close your eyes, relax, breath slowly and think:
OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO OO ...