Develop Reference

Why does .contains method on ArrayList of custom instances work?

I've been developing a small application for work, and I've come across something I can't figure out.
In the following code, I have an ArrayList of a Custom Class called 'Product' that contains data of type 'String'. I use the .contains method on this ArrayList to ensure it doesn't contain a certain String.
My IDE gives me the warning of 'Suspicious call to java.util.Collections.contains: Given object cannot contain instances of String (expected Product)'.
I completely understand the above message, because I'm comparing two different Types, so how can it ever evaluate correctly? I'm thinking it must be because the 'Product' class contains the data I want to compare, it is defaulting to using the toString method on the Product class (I override this in the Class) and comparing it with the String I want to compare it against.
It seems like JVM black magic to me.
private void createOrderListing(List<String[]> orderList)
{
//For each line of the order list file
for(String[] s : orderList)
{
if(s.length >= 28) //OrderLine should be of this length
{
if (!s[0].equalsIgnoreCase("ProductCode") && !s[0].isEmpty()) //Makes sure we're not including headers
{
//How does this bit work?
if(!productListing.contains(s[0]))
{
OrderLine order = new OrderLine();
//References product code of Product against Order Line, if match, then pack sizes and other basic fields ammended as appropriate
boolean productFound = false;
for (Product p : productListing)
{
if (s[0].contentEquals(p.getProductCode()))
{
order.initialAmendOrderLine(p.getProductCode(), p.getProductName(), p.getPackSize(), p.getProductType());
productFound = true;
}
}
if(productFound)
{
order.setOrderValues(s);
orderListing.add(order);
}
}
//System.out.println("\nOrder Product is: " + order.getProductName()+ "\nOrder Pack Size is: " + order.getInternalPackSize());
}
}
}
}
UPDATE
The reason this works as pointed out in the comments is that the block is always true (the .contains method is always false, the ! inverses this, hence true). Sorry for the confusion and pointing out my carelessness.

Here is an implementation of contains method in ArrayList that I have in OpenJDK:
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
Basically, there is nothing complex in it. It iterates through the all elements of your ArrayList and checks whether your given object is equal to the current one. If the condition is true then element exists in the list.
So let's imagine that you are passing String "SomeValue" to this method. Elements of ArrayList are iterated and following action is executed: "SomeValue".equals(elementData[i]) where elementData[i] is a product.
Since equals method of String class cannot compare String with a Product it returns false and as a result, you get false from contains method.
To fix this situation you can iterate over ArrayList manually and compare some Product's field with your string. E.g. you can implement following contains method:
public boolean contains(List<Product> products, String yourStringValue) {
for (Product p : products) {
if(p.getProductCode().equals(yourStringValue)){
return true;
}
}
return false;
}

productListing is a list of Product objects. Yet you are asking the list if it contains a specific String object -- which shouldn't ever happen.
What you should do is check if your Product#getProductCode is equal to your specific String. This can be acheived by using streams:
if(!productListing.contains(s[0])) // replace this
// with this
if (!productListing.stream().filter(o -> o.getProductCode().equals(s[0])).findFirst().isPresent())
What does this code do? It checks all your Product elements to find one whose myStringData attribute is equal to the String you're comparing.

since contains relays on equals implementation, when you do
if(!productListing.contains(s[0]))
you are asking the list OF ARRAYS OF STRINGS if its contains a String.
that will return always false because the type are different, so is not that is working at all, is that your condition will always return false

Suspicious call to Collection.contains method in ArrayList

I am getting a warning that watchStore.contains(s) is a suspicious call to java.util.Collection#contains. How can I fix it? I want to use contains() to find a particular object with the matching serial number.
public Watch findWatchBySerialNumber(long srch) {
long s = srch;
Watch watch = null;
for(int i = 0; i < watchStore.size(); i++) {
watch = watchStore.get(i);
if(watchStore.contains(s)) {
System.out.print("item found");
return watch;
}
}
System.out.print("item not found");
return null; // watch is not found.
}

Presuming that Watch is the class, watchStore is a List<Watch>, and that a field serialNo exists on Watch...
public Optional<Watch> findWatchBySerialNumber(long serial) {
return watchStore.stream()
.filter(w -> w.getSerialNo() == serial)
.findFirst();
}
If you're not using Java 8, the code is close, but a bit more dangerous since you have the chance to return null. If you can use Guava's Optional, that'd be a better choice here.
public Watch findWatchBySerialNumber(long serial) {
for(Watch w : watchStore) {
if(w.getSerialNo() == serial) {
return w;
}
}
return null;
}
Your contains isn't going to work since your list doesn't contain Longs, it contains Watchs. This is also why the compiler sees it as dubious; contains accepts an Object but it will return false if what you're looking for doesn't have a comparable equals for what's in your list.
You have to iterate over the entirety of your collection to find it in this scenario, especially since you're looking for a specific property on those objects as opposed to a specific, easy-to-provide value.

please how can I fix that. I want to use the contain() to find a
particular object with the matching serial number.
In that case override Watch's equals() to use serialNumber field for comparison.
Then add constructor that accepts serialNumber.
public class Watch {
private final long serialNumber;
public Watch(long serialNumber) {
this.serialNumber = serialNumber;
}
#Override
public boolean equals(Object obj) {
return obj == this ||
(obj instanceof Watch && ((Watch)obj).serialNumber == serialNumber);
}
#Override
public int hashCode() {
return (int)serialNumber;
}
}
Replace if(watchStore.contains(s)){ with if(watchStore.contains(watchToFind)){ where Watch watchToFind = new Watch(s);

you can use contains method from org.apache.commons.lang.ArrayUtils package.
Checks if the value is in the given array.
The method returns false if a null array is passed in.
Parameters:
array the array to search through
valueToFind the value to find
Returns:
true if the array contains the object
long [] imageHashes= {12l,13l,14l,15l};
System.out.println(ArrayUtils.contains(imageHashes, 13l));

Comparators and HashMaps for Markov Chain

I am trying to make a markov chain in Java/Processing, that will read a book then be able to cut it up in probabilistic ways. Programming is a hobby…
I had the idea that the way to do it was to use a HashMap, and store a Word Object within it. I could easily do this with a String, but within each unique Word it needs to have another HashMap that will store more yet more Word Objects for the Words that follow it, and so on until we have made a model with a sufficient level of complexity.
The problems are that I can’t seem to be able to check whether or not a Word Object is already within the Map by its String name.
Through looking around on SO I can see that it is likely that I will need a Comparator — but all the examples that I have seen use compare or compareTo, when I think that I need something that is more like equals? I don’t need anything at all to do with Sorting, the order will be worked out in the second part of the program.
The code below is pretty horrible — I have been hacking away at this problem for ages but I can’t find an explanation that is sufficiently dumbed down enough for me to understand it.
In Pseudo:
read book
If the Word is not in the Map, put it in there
If the Word is in the Map, iterate the key
Check the Words that follow this Word, and check in the same way if they are within the first Word’s Map, adding as necessary… repeat…
When this is complete
Using the Integer values as probabilities, pick a word
from that Word’s Map, find a Word that is probable to follow it
repeat until desired length is achieved
Code so far:
///markovs
import java.util.HashSet;
import java.util.Comparator;
HashMap<Word, Integer> book;
void setup()
{
book = new HashMap<Word, Integer>();
String[] rows = loadStrings("crash.txt");
for (int i = 0; i < rows.length; i++)
{
if (trim(rows[i]).length() == 0)
{
continue;
}
String[] pieces = split(rows[i], " ");
for (int j = 0; j<pieces.length; j++)
{
Word temp = new Word(pieces[j]);
//c++;
if (book.compare(temp)) {
println("this worked for once");
//iterate here
} else {
book.put(temp, 1);
println("didn’t work");
//book.add(temp);
book.put(temp, 1);
}
}
}
println(book.size());
//println(c);
//println(book);
}
class WordComparator implements Comparator<Word> {
#Override
public int compare(Word w1, Word w2) {
String w1name = w1.name;
String w2name = w2.name;
if (w1name.equals(w2name)) {
return 1;
} else {
return 0;
}
}
}
class Word
{
String name;
int value=1;
int depth;
HashMap<String, Integer> list;
Word(String name_)
{
this.name = name_;
}
int compareTo(Word w) {
if (w.name.equals(this.name)) {
return 0;
} else {
return -1;
}
}
Word(Word w)
{
this.depth = w.depth+1;
}
void nextWord(String word)
{
}
void count() {
value++;
}
void makeHash()
{
list = new HashMap<String, Integer>();
}
}

To use an Object as a key in a HashMap, you need to override two methods: equals() and hashCode(). I'm not exactly sure what you're going for, but a simple example that just uses the name variable would look like this:
public boolean equals(Object other){
if(other instanceof Word){
return this.name.equals(((Word)other).name);
}
return false;
}
public int hashCode(){
return name.hashCode();
}
However, if you're just using the name variable anyway, you might be looking for a multimap, which is just a Map that contains a Map that contains...
HashMap<String, HashMap<String, Integer>> bookMap;
Furthermore, while HashMap does not use the compareTo function, the way you've implemented it seems off. First of all, you need to implement Comparable on your class:
class Word implements Comparable<Word>{
And secondly, the compareTo function should return one of 3 values: negative, zero, or positive. Right now you're only returning zero or negative, which doesn't make any sense.
I think you might be better off taking a step back and describing what you're actually trying to do, as your code contains a lot of confusing logic right now.

As for comparing, you can override Object's inherited equals method, something like:
# Override
boolean equals(Object o) {
return o instanceof Word
? o.name.equals(name) : false;
}

Be aware of using your own types as keys for the HashMap, in this case Word. That only works out well if you provide a sensible implementation of .hashCode() and .equals() on Word.
Here it looks like you could just use String instead. String already has the required method implementations. If you really do want to use Word, you could use those methods from String. e.g.
class Word {
String letters;
public int hashCode() {
return letters.hashCode();
}
public boolean equals(Object o) {
if (o == null || o.getClass() != getClass()) return false;
return letters.equals(((Word) o).letters);
}
}
You don't need a compare or compareTo, just these two.

Remove Duplicates in an Array List based on element of object

Ok, So I know this topic has been asked lots of times. All usually referring to using a set of some kind.
Now here is the problem.
I have a RateSheet (ArrayList) which has many rates (object) in it. In this rate object we have the variables:
desName
prefix
cost
Now to summarise, I want to take this RateSheet and remove all the duplicate rates based on desName.
I have used a set and collection todo this. Which works, but then I can't go in and access individual objects and then their variables etc as I get cast errors. So I am trying todo this without using sets.

I assume you are creating a set from the rate sheet and inject in that set the desName of each rate sheet.
Unfortunately, the Set api is based upon the equals method and the hashCode methods, so once you imnplemented the equals and hashCode based upon the desName attribute, your sets will contain unique rate sheet objects regarding the desName, if you want them to be unique regarding the prefix, you have to change the equals method and hashCode method.
I've done something like this in the past by plugging in an adapter inside the rate sheet that either links to the desName or to the prefix, hence the hashCode redirects to the "hashCode" provided by the current adapter.

Set<String> s = new HashSet();
for(int i=0;i<RateSheet.size;i++){
Rate rate = (Rate)RateSheet.get(i);
s.add(rate.desName);
}
Set<Rate> rs = new HashSet();
for(int i=0;i<RateSheet.size;i++){
Rate rate = (Rate) RateSheet.get(i);
Iterator it = s.iterator();
while(it.hasNext()){
if(rate.desName.equals(it.next()){
rs.add(rate);
}
}
}

List<RateSheets> dedupSheets(List<RateSheet> sheets) {
Map<String,RateSheet> map = new HashMap<>();
for(Rate r: sheets) map.put(r.getName(), r);
return new ArrayList<>(rateSheets.values());
}

Here's an example code on how to do it with a Set. You need to override hashCode() and equals() because they are used under the hood to find out what's a duplicate and what's not:
import java.util.HashSet;
public class RateSheet
{
private String desName;
public RateSheet(String name)
{
desName = name;
}
#Override
public boolean equals(Object other)
{
if (other == null) return false;
if (other == this) return true;
if (!(other instanceof RateSheet))return false;
RateSheet otherAsRateSheet = (RateSheet)other;
return desName.equals(otherAsRateSheet.desName);
}
#Override
public int hashCode()
{
return desName.hashCode();
}
public static void main(String[] args)
{
HashSet<RateSheet> sheets= new HashSet<RateSheet>();
RateSheet a = new RateSheet("a");
RateSheet b = new RateSheet("a");
RateSheet c = new RateSheet("b");
System.out.println(sheets.add(a));
System.out.println(sheets.add(b));
System.out.println(sheets.add(c));
}
}
This is based on this other answer found here:
Java Set collection - override equals method
and also this one:
Why is equals() not called while adding to HashSet and hashCode matches?
and what #GerritCap posted. (sorry, I am a little slow)

Searching an array by a variable contained in an instance of an object rather than the array number?

I am creating an array of customer accounts for a company called "customers". I have a method called getGasAccount which will count the number of accounts in the array.
I declared variables in the program class as:
final int MAXACCOUNTS = 10;
int intNUmber, intSelectAccount;
I set up the accounts using:
if (GasAccount.getGasAccount() < MAXACCOUNTS) {
intSelectAccount = GasAccount.getBankAccount()++;
customers[intSelectAccount] = new GasAccount();
}
I want to be able to search for a customer by their account number which is manually input when the constructor is called. I don't want to search by the intSelectAcocunt/array reference.
If I have a method called displayAccountDetails, is there another way of finding the account rather than using:
customers[intSelectAccount].displayAccountDetails();

Implement equals method in GasAccount like this
public boolean equals(Object objToCompare){
if (objToCompare != null){
return objToCompare instanceof GasAccount && ((GasAccount)objToCompare).getAccountNumber() == getAccountNumber();
}else{
return false;
}
}
Now to find the location of GasAccount object in the array and to display the account details:
java.util.List<GasAccount> gasAccountsList = (java.util.List<GasAccount>)java.util.Arrays.asList(customers);
int objectIndex = gasAccountsList.indexOf([Gas Account Object]);
if (objectIndex != -1){
gasAccountsList.get(objectIndex).displayAccountDetails();
}
Another simple approach suggested by jahroy to search by account number is :
public void getAccountDetails(int accountNumber){
java.util.List<GasAccount> gasAccountsList = (java.util.List<GasAccount>)java.util.Arrays.asList(customers);
for(GasAccount gasAccountObj : gasAccountsList){
if(gasAccountObj.getAccountNumber() == accountNumber){
gasAccountObj.displayAccountDetails();
break;
}
}
}
OR
public void getAccountDetails(int accountNumber){
for(GasAccount gasAccountObj : customers){
if(gasAccountObj.getAccountNumber() == accountNumber){
gasAccountObj.displayAccountDetails();
break;
}
}
}

The data structure that you want is a HashMap. You can do something like this.
public class AccountClass{
//You can fill in the details. I sounds like you know about constructors
//getters, setters, etc.
private HashMap<String, String> accountHash = new HashMap<String, String>();
public HashMap<String, String> getHashMap()
{
return this.accountHash;
}
}
when you want to look up an account by account number, you will be able to do something like this.
AccountClass acct = new AccountClass();
acct.getHashMap().get("1234");
assuming that you have actually put an entry with account number "1234" in your map it will return the value associated with that key.
Here is the Wikipedia article if you want to do more reading.
Edit: I have a few more things to add based on some comments.
It might be better if you made the HashMap static like this
private static HashMap<String, String> accountHash = new HashMap<String, String>();
When you declare the variable static this makes it so that you don't have to instantiate an object to access the HashMap. You can just do something like this.
AccountClass.accountHash.get();
or
AccountClass.accountHash.put();
If you want to add things to your HashMap, you need to use the put method. Here is an example.
accountHash.put("1234","My test account").
Now when you use this,
accountHash.get("1234");//you will get My test account
you will get the value associated with the "1234" key.
Keep in mind this example is just to give you an idea about how to use it. You can have a map of , , or whatever else you want.