We Keep Coding

How to Create Objects Using Records in a Text File (Java)

I'm working on a program for my Java class where I'm using a file of objects (clothing items) that represents inventory for a store. Each Retail_Item has four attributes: int itemNumber, String description, int numInInventory, and double price.
What I'm trying to figure out is how to read in each line from the file and turn each line into an object. My first thought was to create a while loop with vars like currentItemNumber, currentDescription, etc. So I tried this:
while (file.hasNextLine()) {
currentItemNumber = file.nextInt();
currentDescription = file.next
} // end while
But I got stuck there because every other time I've read in a String to a Scanner, I've always used nextLine. Can't use that here though, because each line contains multiple attributes of the object, not a String within a line. Is there a way to do this in the structure I'm trying to use, or should I be doing this a different way? I know I've seen and done some things where I parsed a String into separate pieces which I've seen people refer to as "tokens." Would people recommend reading each line in and then parsing it into separate tokens, then assigning each token to its appropriate attribute? Then I guess I'd have to cast those tokens into the appropriate object, since I think reading the whole line in and then parsing it would make each piece a String.
Here's a sample of what's in the text file (which can't be changed in any way, per the professor's instructions):
1000 Pants 10 19.99
2000 Jeans 2 25.95
3000 Shirt 12 12.50
Thanks in advance for your sage wisdom if you've got it.

The following code fulfills your requirement as stated in your question, namely how to create an instance of class RetailItem from a line of text from your text file. I presume it uses things that you may not have learned yet, like class Paths and try-with-resources. This is just used to scan through your file.
First, class RetailItem contains the members you described in your question. Next, I wrote a constructor for class RetailItem that creates a new instance and initializes the instance members. Then I wrote a toString() method that displays the contents of a RetailItem object in "human readable" form. Finally a main() method that reads your text file (which I named "clothes.txt"), line by line - using a Scanner. For each line read, the code splits it using a delimiter which consists of at least one whitespace character. (I presume you haven't yet learned about regular expressions in java.) Then I convert the elements of the String array returned by method split() into appropriate data types that are required by the RetailItem constructor. Then I call the constructor, thus creating an instance of class RetailItem (as you requested) and I print the created instance.
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Scanner;
public class RetailItem {
private static final int FIELDS = 4;
private int itemNumber;
private String description;
private int numInInventory;
private double price;
public RetailItem(int itemNumber, String description, int numInInventory, double price) {
this.itemNumber = itemNumber;
this.description = description;
this.numInInventory = numInInventory;
this.price = price;
}
#Override // java.lang.Object
public String toString() {
return String.format("%4d %-5s %2d %2.2f", itemNumber, description, numInInventory, price);
}
public static void main(String[] args) {
try (Scanner file = new Scanner(Paths.get("clothes.txt"))) {
while (file.hasNextLine()) {
String record = file.nextLine();
String[] fields = record.split("\\s+");
if (fields.length == FIELDS) {
int itemNumber = Integer.parseInt(fields[0]);
String description = fields[1];
int numInInventory = Integer.parseInt(fields[2]);
double price = Double.parseDouble(fields[3]);
RetailItem item = new RetailItem(itemNumber, description, numInInventory, price);
System.out.println(item);
}
}
}
catch (IOException xIo) {
xIo.printStackTrace();
}
}
}

I think the way that I would do is, like you said, parse each line into separate strings and then assign each piece to instance variables of the object you are building.
I have done something like this before, maybe it can be helpful.
Scanner fileScan;
File babyNameFile = new File("yob2015.txt");
try {
fileScan = new Scanner(babyNameFile);
} catch (FileNotFoundException e) {
System.out.println("File does not exist");
return;
}
String currentLine;
int numberOfGirlsNames = 0;
while (fileScan.hasNextLine()) {
String[] values;
currentLine = fileScan.nextLine();
values = currentLine.split(",");
if (values[1].equals("F")) {
numberOfGirlsNames = numberOfGirlsNames+1;
}
}
System.out.println("Number of female names was "+numberOfGirlsNames);

How to specify a class property from a string in java

So I am reading from a file with scanner it has the similar format:
title, name, age
Mr, Matthew, 20
mr, Paul, 30
miss, Anne, 24
CSV^
class person{
String name, title;
int age;
public crimeData(String csv){
String[]list = csv.split(",", -1);
name = list[0];
title = list[1];
age = list[2];
}
}
Console Program
Scanner input = new Scanner(System.in);
System.out.println("Please select what data you want to load:");
String selection = input.next();
int temp = 0;
for(int i=0; i< header.length; i++){
if(header[i].equals(selection)){
temp = i;
break;
}
}
temp will give us the index of the option specified so if it is 2 we will want to access the age property
When my console application runs I prompt them(the user) for the data that they want.
So they may enter "age" So I am lost on how I may take this "age" String and access the person object with it.
The ideal case for the program output should be: 20,30,24 going through each age and printing
I take their input so String input = scanner.nextLine();
Then I loop through my array of person objects to get the index of the input. Once I have this index I then want to access the property of person at the index. So like if my index was 1 I would want to access the property 'name'.
In javascript I could take the string and say person['age'] although java's a whole different story. I have looked into java's "reflection API" although it's a heavy learning curve.

I have looked into java's "reflection API" although it's a heavy learning curve.
Well, Reflection is the way to go. It's widely used in many frameworks.
But perhaps a simpler solution will fit your needs. Use a switch to decide which attribute to return, and encapsulate this in a method of the Person class:
class Person {
private String name, title;
private int age;
public loadData(String csv){
String[] list = csv.split(",");
name = list[0];
title = list[1];
age = Integer.parseInt(list[2]);
}
public Object attribute(String attribute) {
switch (attribute) {
case "name": return this.name;
case "title": return this.title;
case "age": return this.age;
default: throw new RuntimeException("Invalid attribute: " + attribute);
}
}
}
Encapsulating the switch inside the method is in line with OOP principles, since it hides how attributes are stored from other objects, only exposing an interface to query them. Reflection breaks all encapsulation.

Though in general I am not in favor of using Map for holding fields for an object, if the number of properties is large and could even potentially vary across CSV files (e.g., some file has the University a person attended, another does not), then using a Map to hold the properties might be appropriate.
In this case, one would define a simple Person class:
public class Person {
Map<String, String> props = new HashMap<>();
public void addProperty(String propertyName, String value) {
// could add error checking to ensure propertyName not null/emtpy
props.put(propertyName, value);
}
/**
* returns the value of the property; may return null
*/
public String getProperty(String propertyName) {
return props.get(propertyName);
}
}
If it is know that certain attributes/properties will always be loaded, then accessors such as getName() could be added:
public String getName() {
return props.get("name");
}
public int getAge() {
String age = props.get("age");
// or throw exception if missing
return (age != null ? Integer.parseInt(age) : -1);
}
Though note I would expect name to not be a single entry for most datasets, as there typically would be last name, first name, etc. Nonetheless, the pattern for a limited number of commonly expected values is the same. Also, you can adapt so that you could get integer values directly for certain well-known fields.
Then, when you parse the file, you keep the title row that has the attribute definitions. Then for each row that you subsequently read, you create a new Person object, and then add the properties in order.
List<Person> allPersons = new ArrayList<>();
while ( (line = READ_NEXT_LINE) ) {
// NOTE: this is not a safe way to handle CSV files; should really
// use a CSV reader as fields could have embedded commas
attrs[] = line.split(",");
Person p = new Person();
for (int i = 0; i < titleRow.length; ++i) {
p.addProperty(titleRow[i], attrs[i]);
}
allPersons.add(p);
}
You can then get a specific Person by Person myPerson = allPersons.get(index_of_person), and much akin to the way you would have used Javascript, you can do String val = myPerson.getProperty("age").
If you need to search by a given attribute, you can then stream/loop over the allPersons and check of equivalence based upon a given property.
// find all people of a given age
List<Person> peopleAge20 = allPersons.stream()
.filter(p -> p.getAge() == 20)
.collect(Collectors.toList());
System.out.println(peopleAge20);
// summary statics (average age) for all people
IntSummaryStatistics stats =
allPersons.stream().mapToInt(p -> p.getAge()).summaryStatistics();
System.out.printf("Average age: %f\n", stats.getAverage());
Note that this approach does break the idea of a Javabean, but that may or may not be an issue depending upon your requirements.

First thing, we should add a constructor to your Person class.
class Person {
public Person(String name, String title, int age) {
this.name = name;
this.title = title;
this.age = age;
}
}
Now while you read the input you can use a Map as follows. Here after reading each line, we create a Person object and then using that person's age we make an entry in the map with key as age and value as Person.
Map<Integer, Person> mapOfPeople = new HashMap<>();
while (input.hasNextLine()) {
String line[] = input.nextLine().split(",");
Perso person = new Perso(line[1], line[0], Integer.parseInt(line[2].trim()));
mapOfPeople.put(person.getAge(), person);
}
Now to fetch a particular Person by age just do
mapOfPeople.get(20);

java selecting an instance of an object

I have a fleet. fleet.java
Each fleet has a set of ships. ship.java
Each ship has a set of crewmembers. crewmember.java
Within Main I am adding Ships to the fleet and Crewmembers to the ships, read in from a roster of both.
From the first file I add a new ship to an arraylist.
From the second file I add a new crewmember to an arraylist.
this.addships(ship)
this.shipname.addcrewmember(crewmember)
How do I change the shipname in the above statement based on the token from the input file?
public void loadStarships( String filename ) {
File file = new File( filename );
Scanner scan;
try {
scan = new Scanner( file );
while( scan.hasNextLine() ) {
String line = scan.nextLine();
String[] tokens = line.split(",");
Starship star = null;
star = new Starship( tokens[0], tokens[1], tokens[2]);
this.addStarship( star );
}
scan.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void loadCrew( String filename ) {
File file = new File( filename );
Scanner scan;
try {
scan = new Scanner( file );
while( scan.hasNextLine() ) {
String line = scan.nextLine();
String[] tokens = line.split(",");
CrewMember member = null;
member = new CrewMember( tokens[0], tokens[1], tokens[2], tokens[4]);
this.tokens[3].addCrewMember( member );
}
scan.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Starship( String name, String registry, String level) {
this.name = name;
this.registry = registry;
this.level = level;
this.crewmembers = new ArrayList<CrewMember>();
}
//adds new crew members
public void addCrewMember( CrewMember crewmembers ) {
this.crewmembers.add( crewmembers );
this.numberOfCrewMembers++;
}
public CrewMember( String name, String position, String rank, String species ) {
this.name = name;
this.position = position;
this.rank = rank;
this.species = species;
}
//set the fleet name and the maximum number of starships
public Fleet(String name) {
this.name = name;
this.starships = new ArrayList<Starship>();
}

The first rule of software design is "use the correct data structure for the job." As it stands, you're saving instances of ship to an ArrayList, which only allows you to retrieve elements by index.
Although you didn't provide the sample data requested, it's easy enough to infer that token[3] is the name of the ship to which the crew member belongs, so you need to figure out how to retrieve an object by name.
Luckily, Java provides you with the HashMap, which stores key-value pairs. You can use the ship's name as a key. When you pass that key to the HashMap, it'll return the value associated with that key -- in your case, the instance of ship that you need.
1) Make sure your class imports java.util.HashMap;
2) Declare your HashMap. Instead of:
ArrayList<Starship> ships = new ArrayList<Starship>();
use:
HashMap<String, Starship> = new HashMap<String, Starship>();
In this situation, a String representing the name of the ship is the key. The instance of ship with that name is the value.
3) When adding a new ship, you're going to have to update your addStarship() method to take a String arg in addition to the Starship arg it already takes:
public void addStarship(String name, Starship ship)
4) In the body of addStarship() you have to add the ship using the put() method:
ships.put(name, ship);
Remember, here, ships is the instance of HashMap that you're using to store your ships. name is a String representing the name of the ship, and ship is the ship object.
5) When you're trying to retrieve the ship, you use the get() method:
ships.get(name);
In your case, the code might look like this:
ships.get(tokens[3].addCrewMember(member));
Keep in mind that with HashMap, you can no longer retrieve values by index like you could with ArrayList. HashMap is by definition, and unordered collection, meaning the first element of the structure may or may not be the the first object you added, and even if you accessed an object at the first position, there's no guarantee that it'll still be in that slot if you try to access it later -- its position in the HashMap may have changed, so you'll typically only be retrieving values using the key.
Please make sure you read the official documentation that I linked, above.

How to read a text file into an array with private fields using mutators in Java

I have Googled this for a couple of days without much luck. I am trying to read a text file and use that information to populate the private fields of an array for a class object. I am new to Java and pretty new to programming in general.
What I've come up with for reading into the array seems really clunky and I feel there must be a better way, but I cannot find a good example for this particular kind of case case.
Creating a bunch of string variables was the only way I could get this to work. Perhaps main is a bad place to do this; perhaps Scanner is a poor choice here?
What better ways are there to implement this situation?
My text file that contains Strings and integers separated by whitespace on lines is similar to this:
Joe 2541 555-1212 345 1542 Type
Bob 8543 555-4488 554 1982 Type
... etc.
Here's my majority of my code thus far which is within main:
Scanner in = new Scanner(new FileReader("accounts.txt")); //filename to import
Accounts [] account = new Accounts [10];
int i = 0;
while(in.hasNext())
{
account[i] = new Accounts();
String name = in.next();
String acct_num = in.next();
String ph_num = in.next();
String ss_num = in.next();
int open_bal = in.nextInt();
String type = in.next();
account[i].setName(name);
account[i].setAcctNum(acct_num);
account[i].setPhoneNum(ph_num);
account[i].setSSNum(ss_num);
account[i].setOpenBal(open_bal);
account[i].setType(type);
i++;
}
class Accounts
{
public Accounts()
{
}
public Accounts(String n, String a_num, String ph_num,
String s_num, int open_bal, String a_type, double close_bal)
{
name = n;
account_number = a_num;
phone_number = ph_num;
ssn = s_num;
open_balance = open_bal;
type = a_type;
close_balance = close_bal;
}
public String getName()
{
return name;
}
public void setName(String field)
{
name = field;
}
public String getAcctNum()
{
return account_number;
}
public void setAcctNum(String field)
{
account_number = field;
}
//And so forth for the rest of the mutators and accessors
//Private fields
private String name;
private String account_number;
private String phone_number;
private String ssn;
private int open_balance;
private String type;
private double close_balance;
}

I believe you need to split each line in order to get the data contained in each line. You can use the split() of the string class which will return a string[]. Then you can go through each index of the string array and pass them to the mutator methods of the account class.
Something like this maybe.
while(in.hasNext())
{
// will take each line in the file and split at the spaces.
String line = in.next();
String[] temp = line.split(" ");
account[i].setName(temp[0]);
account[i].setAcctNum(temp[1]);
account[i].setPhoneNum(temp[2] + "-" + temp[3]);
account[i].setSSNum(temp[4]);
account[i].setOpenBal((int)temp[5]);
account[i].setType(temp[6]);
// will account for blank line between accounts.
in.next();
i++;
}
The phone number gets split into two separate indices so you have to rejoin the phone number by accounting for the first 3 digits being in one index and the last 4 being in the next.

Replacing Accounts[] with Set<Accounts> would be more flexible solution as you can process either 10 lines or 10000 accounts without code changes. In general: Consider Collections vs arrays
Using Scanner seems to be reasonable in this particular case, however take a look at the others ways of processing text (performance vs convenience): Scanner vs. StringTokenizer vs. String.Split
Setting up account parameters with mutators or constructor might not be the best choice: Effective Java: Consider a builder when faced with many constructor parameters

Assigning a String to an ArrayList pulled from file

I imported a List of Strings from a file and put them into an arrayList. I am trying to chop of the end of these arrays, so I'm putting them into a separate String format
Here is where i set x
x = new ArrayList<BankAccounts>();
try {
Scanner reader;
reader = new Scanner( new File("F:\\myCreditUnion.txt") );
while ( reader.hasNext() )
{
String inputLine = reader.nextLine();
first = inputLine.substring(0, 3);
second = Double.parseDouble(inputLine.substring(5, inputLine.length()));
x.add(new BankAccounts(first, second));
}
reader.close();
}
and this is where i try to chop off the end
double howmuch;
for(int i = 0; i < x.size(); i++)
{
list.equals(x.get(i));
howmuch = Double.parseDouble(list.substring(5, list.length()));
}
// x is the list
I am getting a nullpointerexception. Wondering how to fix this, as I am pretty new to programming.
Document i am importing contains a combinations of # and letters such as, 101s 583.58

To assign a value to list you have use list = x.get(i); instead of list.equals(x.get(i));
Update:
equals() does not assign values it only checks if two objects are equal.
The value returned by x.get(i) will be a BankAccount so you can't assign it to list (which is a String)
You have to either turn the BankAccount into a String by using toString() or you have to get a String out of it by calling one of the BankAccount methods before assigning it to list, how this works depends on the methods provided by the BankAccount class.

If you are getting a NullPointerException in the above code, either list or x is null. Check where you are setting their value, or include that part of the code in the question.

Regarding your code: you probably have some sort of declaration similar to: String line = null; somewhere before your last piece of code pasted and you get get a NullPointerException at the list.equals(x.get(i)); line. This is because your list object is not initialized. However you don't need to do that. See below.
In order to do what you want you should use the following code:
The class definition for BankAccounts:
class BankAccounts {
public String account;
public Double value;
public BankAccounts(String account, Double value)
{
this.account = account;
this.value = value;
}
}
And rewrite your code like this:
List<BankAccounts> x = new ArrayList<BankAccounts>();
try {
Scanner reader;
reader = new Scanner( new File("F:\\myCreditUnion.txt") );
while ( reader.hasNext() )
{
String inputLine = reader.nextLine();
first = inputLine.substring(0, 3);
second = Double.parseDouble(inputLine.substring(5, inputLine.length()));
x.add(new BankAccounts(first, second));
}
reader.close();
}
It seems to me that your input files contains line of the form ABC 10.324. You are parsing this properly into BankAccounts objects (each one containing a String representing the account name and a Double representing the amount) when you are reading them from file. So there is no need to reparse that again.
The code to iterate and look at the amounts is below;
// x is the list
double howmuch = 0;
for(int i = 0; i < x.size(); i++)
{
BankAccounts accounts = x.get(i);
howmuch = accounts.amount; // there is no need to cast since unboxing will occur here.
// here howmuch will contain the amount for each account
}