I have a comparator that compares nested fields of an object. Here the price of a product.
Problem: if the field is null, I'm getting a NullPointerException.
Question: how can I tell the comparator to ignore objects where the comparing field is null, without(!) having to filter the list beforehand? With ignore I mean having them at the end of the list.
public class SorterTest {
private static final Comparator<Product> PRODUCT_COMPARATOR =
Comparator.comparing(p -> p.details.price);
static class Product {
String name;
Details details;
static class Details {
BigDecimal price;
}
}
#Test
public void test() {
List<Product> products = Arrays.asList(
createProduct("A", new BigDecimal(30.00)),
createProduct("B", new BigDecimal(55.00)),
createProduct("C", new BigDecimal(20.00)),
createProduct("D", null),
createProduct("E", null),
createProduct("F", null)
);
Collections.sort(products, PRODUCT_COMPARATOR);
assertEquals("C", products.get(0).name);
assertEquals("A", products.get(1).name);
assertEquals("B", products.get(2).name);
assertEquals("D", products.get(3).name);
assertEquals("E", products.get(4).name);
assertEquals("F", products.get(5).name);
}
private Product createProduct(String name, BigDecimal price) {
Product p = new Product();
p.details = new Product.Details();
p.name = name;
p.details.price = price;
return p;
}
}
Result:
java.lang.NullPointerException
at java.util.Comparator.lambda$comparing$77a9974f$1(Comparator.java:469)
at java.util.TimSort.binarySort(TimSort.java:296)
at java.util.TimSort.sort(TimSort.java:221)
at java.util.Arrays.sort(Arrays.java:1438)
at java.util.Arrays$ArrayList.sort(Arrays.java:3895)
at java.util.Collections.sort(Collections.java:175)
You can use the method nullsLast of the Comparator:
private static final Comparator PRODUCT_COMPARATOR =
Comparator
.nullsLast(Comparator.comparing(p -> p.details.price, Comparator.nullsLast(Comparator.naturalOrder())));
The first nullsLast for Product being null, the second for price being null.
You get the NullPointerException because of the price is null. So use an if statement to check the price value, and if is null then use other value like 0 to replace it. The code may like:
public class SorterTest {
private static final Comparator<Product> PRODUCT_COMPARATOR =
Comparator.comparing(p->
{
if (p.details != null && p.details.price != null) {
return p.details.price;
} else {
return new BigDecimal(0);
}
}
);
static class Product {
String name;
Details details;
static class Details {
BigDecimal price;
}
}
#Test
public void test() {
List<Product> products = Arrays.asList(
createProduct("A", new BigDecimal(30.00)),
createProduct("B", new BigDecimal(55.00)),
createProduct("C", new BigDecimal(20.00)),
createProduct("D", null),
createProduct("E", null),
createProduct("F", null)
);
Collections.sort(products, PRODUCT_COMPARATOR);
assertEquals("D", products.get(0).name);
assertEquals("E", products.get(1).name);
assertEquals("F", products.get(2).name);
assertEquals("C", products.get(3).name);
assertEquals("A", products.get(4).name);
assertEquals("B", products.get(5).name);
}
private Product createProduct(String name, BigDecimal price) {
Product p = new Product();
p.details = new Product.Details();
p.name = name;
p.details.price = price;
return p;
}
}
You can use Optional<> to see if the result from getter is a null or a valid value. For null values, you can put them at the tail or head by always treating their comparator() result is -1 or 1.
private static final Comparator<Product> PRODUCT_COMPARATOR =
Comparator.comparing(p -> {
Optional<BigDecimal> res = Optional.ofNullable(p.getPrice);
if(res.isPresent())
return p.getPrice();
else
return -1;
});
...
static class Product {
String name;
BigDecimal price;
BigDecimal getPrice(){
return this.price;
}
...
}
Related
Trying to get my head round the Java 8 streams syntax with a simple example. Had a look at the other similar questions on this topic, but could not find any solutions that would match my example and would work for me.
I have a class as follow
import java.util.List;
public class Car {
private String model;
private String make;
private String carName;
private List<Specification> specification;
public Car(String model, String make, String carName, List<Specification> specification) {
this.model = model;
this.make = make;
this.carName = carName;
this.specification = specification;
}
public String getModel() {
return model;
}
public String getMake() {
return make;
}
public String getCarName() {
return carName;
}
public List<Specification> getSpecification() {
return specification;
}
}
public class Specification {
private String name;
private String value;
public String getName() {
return name;
}
public String getValue() {
return value;
}
public Specification(String name, String value) {
this.name = name;
this.value = value;
}
}
And I have the main method
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class RegisterCar {
public static void main(String[] args) throws IOException {
List<String> carNames = new ArrayList<>();
carNames.add("Audi");
carNames.add("BMW");
carNames.add("Toyota");
List<String> colour = new ArrayList<>();
colour.add("red");
colour.add("white");
}
}
I want to create a list of car object with each item of carNames. But if the car name is 'Audi' or 'BMW' it should create only one object of the class as follow
List<Car> carList = new ArrayList<>();
Specification musicSystem = new Specification("MusicSysten" , "present");
List<Specification> specList= new ArrayList<>();
specList.add(musicSystem);
carList.add(new Car("Q5", "2020", "Audi", specList));
carList.add(new Car("X2", "2020", "BMW", specList));
But if the item is 'Toyota' then it should create two object each for each color.
List<Specification> specListRed= new ArrayList<>();
specListRed.add(musicSystem);
specListRed.add(redColor);
List<Specification> specListWhite= new ArrayList<>();
specListWhite.add(musicSystem);
specListWhite.add(whiteColor);
carList.add(new Car("Camry", "2020", "Toyota", specListRed));
carList.add(new Car("Camry", "2020", "Toyota", specListWhite));
I am trying to write a common method for creating object and adding to a list. I have tried something like this, but I won't create correct two object for Toyota.
carList = carNames.stream()
.map(carName -> new Car(model, make, carName, specList))
.collect(Collectors.toList());
please suggest how can I achieve this with streams.
If you want the name "Toyota" to be used twice it should be contained in the list of names twice, since the lambda in map() is executed for every name.
But inside your map-Call: Where do you get and model & make?
First thing you need to understand is that map operation always preserves same amount (i.e. cardinality) as your input.
If you will pass 3 items - no matter which function you have, result will always be 3.
Next thing worth looking into: flatMap function. This function can transform any amount of inputs to any amount of results! This looks like what we need.
var carList = carNames.stream()
.flatMap(carName -> {
if (carName.equals("Toyota") {
return Stream.of(new Car(model, make, carName, specList1),
new Car(model, make, carName, specList2));
} else {
return Stream.of(new Car(model, make, carName, specList));
})
.collect(Collectors.toList());
Since it's all about creation and holding of object. Foucus on equals() and and hashcode() methods.
#Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Car)) {
return false;
}
Car car = (Car) o;
if (carName.equals("BMW")) {
return true;
}
if (carName.equals("Toyota")) {
return false;
}
return Objects.equals(carName , car.carName);
}
#Override
public int hashCode() {
return 1;
}
Driver methood
List<String> carNames = new ArrayList<>();
carNames.add("Audi");
carNames.add("BMW");
carNames.add("Toyota");
carNames.add("Toyota");
List<String> colours = new ArrayList<>();
colours.add("red");
colours.add("white");
Set carList = carNames.stream()
.map(carName -> {
Set ss = new HashSet();
if (carName.equals("Toyota")) {
ss.addAll(colours.stream().map(colr -> new Car("model" , "make" , carName , null)).collect(Collectors.toSet()));
} else {
ss.add(new Car("model" , "make" , carName , null));
}
return ss;
})
.collect(HashSet::new, Set::addAll, Set::addAll);
say I have an array List of type Order Details
private static List<OrderDetails> orderDetails = new ArrayList<OrderDetails>();
and the fields in orderDetails are
private String productCode = null;
private int revenue = 0;
my arrayList contains the values`
A012 69
A012 36
I need to change the output of the list so that if something is added to the list of the same productCode the revenues get added together
so the output of the example above would be
A012 105
how will the method work
This should work assuming you have the appropriate getters for the class. It just creates a stream of OrderDetails objects, filters out null productCodes and creates a map of the revenue sums.
Map<String,Integer> results = orderDetails.stream()
.filter(od->od.getProductCode() != null)
.collect(Collectors.groupingBy(OrderDetails::getProductCode,
Collectors.summingInt(OrderDetails::getRevenue)));
If desired, you can then return the values back to a list by creating a new instance of each OrderDetails class.
orderDetails = results.entrySet().stream()
.map(e->new OrderDetails(e.getKey(), e.getValue()))
.collect(Collectors.toList());
Using a map might be more useful since you can get the revenue for any product code.
For example
System.out.println(results.get("A012"));
The small code snippet by using a Map as below may be helpful:
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Test {
private static List<OrderDetails> orderDetails = new ArrayList<OrderDetails>();
public static void main(String[] args) {
final OrderDetails o1 = new OrderDetails("A12", 69);
final OrderDetails o2 = new OrderDetails("A12", 36);
final OrderDetails o3 = new OrderDetails("A13", 136);
addToList(o1);
addToList(o2);
addToList(o3);
orderDetails.stream().map(orderDetail -> orderDetail.getProductCode() + " " + orderDetail.getRevenue()).forEach(System.out::println);
}
private static synchronized void addToList(OrderDetails orderDet) {
final Map<String, OrderDetails> map = orderDetails.stream().collect(Collectors.toMap(OrderDetails::getProductCode, orderDetail -> orderDetail, (a, b) -> b));
final OrderDetails objectFromMap = map.get(orderDet.getProductCode());
if (objectFromMap != null) {
objectFromMap.setRevenue(objectFromMap.getRevenue() + orderDet.getRevenue());
} else {
map.put(orderDet.getProductCode(), orderDet);
}
orderDetails.clear();
orderDetails.addAll(map.values());
}
}
class OrderDetails {
private String productCode = null;
private int revenue = 0;
public OrderDetails(String productCode, int revenue) {
this.productCode = productCode;
this.revenue = revenue;
}
public String getProductCode() {
return productCode;
}
public int getRevenue() {
return revenue;
}
public void setRevenue(int revenue) {
this.revenue = revenue;
}
}
You can use a Map like this:
Map<String, Integer> orderDetails = new new HashMap<>();
and use this method for adding a new order:
void addOrder(Order orderToAdd) {
Order findOrder = orderDetails.get(orderToAdd.productCode);
if (findOrder != null) {
findOrder.revenue += orderToAdd.revenue ;
} else {
orderDetails.put(orderToAdd.productCode, orderToAdd.revenue );
}
}
I need to filter elements and then sort based on certain column. Post that I would need to find the unique entries based on combination of columns. Since it is file processing, pipe(|) is used as delimiter to denote the column value.
String s1= "12|Thor|Asgaurd|1000000|Avenger|Active"
String s2= "234|Iron man|New York|9999999|Avenger|Active"
String s3= "420|Loki|Asgaurd|||Inactive"
String s4= "12|Thor|Asgaurd Bank|1000000|Avenger HQ|Active"
Data first needs to be filtered based on the Active/Inactive status. Then it needs to be sorted based on 4th column. Lastly, the uniqueness needs to be maintained by combining column 1,2,3.
Expected Output =
"234|Iron man|New York|9999999|Avenger|Active"
"12|Thor|Asgaurd|1000000|Avenger|Active"
Creating a model class and parsing the string is the way to go, but if for some reaseon you don't want to do that you can do it this way:
import java.util.Comparator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
List<String> result = Stream.of(s1, s2, s3, s4)
.filter(s -> s.split("\\|")[5].equals("Active"))
.sorted(Comparator.comparing(e -> e.split("\\|")[4]))
.collect(Collectors.toList());
First of all you should create an Object which represents your String data. Something like this:
public class MyObject {
private int id;
private String name;
private String location;
private Integer value;
private String category;
private String state;
public MyObject(String entry) {
String[] parts = entry.split("\\|");
if (parts.length != 6) {
throw new IllegalArgumentException("entry has not 6 parts");
}
id = Integer.parseInt(parts[0]);
name = parts[1];
location = parts[2];
try {
value = Integer.parseInt(parts[3]);
} catch (NumberFormatException ignored) {
}
category = parts[4];
state = parts[5];
}
// getters
#Override
public String toString() {
return String.join("|", String.valueOf(id), name, location, String.valueOf(value), category, state);
}
}
With this you can create a Stream of objects from your Strings and to the filter, sort and distinct operations afterwards:
Collection<MyObject> result = Stream.of(s1, s2, s3, s4)
.map(MyObject::new)
.filter(o -> "Active".equals(o.getState()))
.sorted(Comparator.comparing(MyObject::getValue).reversed())
.collect(Collectors.toMap(o -> Arrays.asList(o.getId(), o.getName()),
Function.identity(), (o1, o2) -> o1, LinkedHashMap::new))
.values();
result.forEach(System.out::println);
After the map operation you filter the values by state and sort them by column 4 (value in my case). At the end you collect all the values in a map for the distinct operation. Add all values you need distinction for to the Arrays.asList(). As values the map takes all the original values (Function.identity()). For duplicates we keep the first value ((o1, o2) -> o1) and we are using a LinkedHashMap to keep the order of the items. At the end wee use only the values of the map.
If you need a List instead of a Collection use new ArrayList(result).
The result will be this:
234|Iron man|New York|9999999|Avenger|Active
12|Thor|Asgaurd|1000000|Avenger|Active
It seems like you're unable to filter while everything is string only.
Try this,
create a new model class which can hold your columns.
Ex:
class MyData{
private String name;
private String city;
private String distance;
private String organization;
private String status;
//And create Getter Setter method for all above fields.
}
Now came to your main class where you can play with your code stuff.
Map<MyData> map = new HashMap<MyData>();
MyData myData = new MyData();
myData.setName("Thor");
myData.setCity("Asgaurd");
myData.setDistance("1000000");
myData.setOrganization("Avenger");
myData.setStatus("Active");
map.put(12, myData);
//Same thing for all other data (note: use the loop for data insertion in map)
Map<String, MyData> sorted = map.entrySet().stream().sorted(comparingByValue()).collect(toMap(e -> e.getKey(), e -> e.getValue().getName(), (e1, e2) -> e2,LinkedHashMap::new));
System.out.println("map after sorting by values: " + sorted);
You can solve your task this way:
Firstly, just create POJO(Plain Old Java Object) and override the toString() method.
class MarvelPerson {
private Integer id;
private String name;
private String origin;
private Integer point = null;
private String faction;
private String status;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getOrigin() {
return origin;
}
public void setOrigin(String origin) {
this.origin = origin;
}
public Integer getPoint() {
return point;
}
public void setPoint(Integer point) {
this.point = point;
}
public String getFaction() {
return faction;
}
public void setFaction(String faction) {
this.faction = faction;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
#Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(id);
builder.append("|");
builder.append(name);
builder.append("|");
builder.append(origin);
builder.append("|");
if(point != null) {
builder.append(point);
}
builder.append("|");
if(faction != null) {
builder.append(faction);
}
builder.append("|");
builder.append(status);
return builder.toString();
}
}
Then, you should write the parser from string to MarvelPerson. Side note: Carefully, my implementation is pretty basic, and I suppose it should be modified because I may not have foreseen some corner cases.
class PersonParser {
static MarvelPerson parse(String data) {
MarvelPerson person = new MarvelPerson();
String[] array = data.split("\\|", -1);
person.setId(Integer.parseInt(array[0]));
person.setName(array[1]);
person.setOrigin(array[2]);
if(!array[3].isEmpty()) {
person.setPoint(Integer.parseInt(array[3]));
}
if(!array[4].isEmpty()) {
person.setFaction(array[4]);
}
person.setStatus(array[5]);
return person;
}
}
And then your solution:
public class Test {
public static void main(String[] args) {
List<MarvelPerson> list = new ArrayList<>();
list.add(PersonParser.parse("12|Thor|Asgaurd|1000000|Avenger|Active"));
list.add(PersonParser.parse("234|Iron man|New York|9999999|Avenger|Active"));
list.add(PersonParser.parse("420|Loki|Asgaurd|||Inactive"));
list.add(PersonParser.parse("12|Thor|Asgaurd Bank|1000000|Avenger HQ|Actie"));
list.stream()
.filter(marvelPerson -> marvelPerson.getStatus().equals("Active"))
.sorted((o1, o2) -> o1.getPoint() <= o2.getPoint() ? 1 : -1)
.forEach(marvelPerson -> {
System.out.println(marvelPerson.toString());
});
}
}
The output to be printed:
234|Iron man|New York|9999999|Avenger|Active
12|Thor|Asgaurd|1000000|Avenger|Active
I have List of stories. Using unique property(id) I want to collect keyword and targeting as list of values. Can I do this with MultiMap? Or is there other library for this?
[{
id = 1,
title = Onboarding,
keyword = new joinee,
targeting = finance
}, {
id = 1,
title = Onboarding,
keyword = training,
targeting = HR
}]
The Desired output must like this :
{
id = 1,
title = Onboarding,
keyword = [new joinee,training], //may be keywords - plural
targeting = [HR,finance]
}
Sample my tried Code as follows:
package prac;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class JavaPrac {
public static void main(String[] args) {
Multimap<Integer, Map> multiMap = ArrayListMultimap.create();
List<Map> stories=new ArrayList();
Map story1=new HashMap();
story1.put("id", 1);
story1.put("title", "Onboarding");
story1.put("keyword","new joinee");
story1.put("targeting","finance");
Map story2=new HashMap();
story2.put("id", 1);
story2.put("title", "Onboarding");
story2.put("keyword","training");
story2.put("targeting","HR");
stories.add(story1);
stories.add(story2);
System.out.println(stories);
stories.forEach((story) -> {
multiMap.put((Integer) story.get("id"), story);
});
}
}
A multimap can only store multiple values per key but what you want is to combine those multiple values so that you get one element that has the same id and title as well as a collection of keywords and targeting information. Thus it would probably be best to either have something like MultiStory or already have Story contain those collections.
I'd suggest using proper objects instead of just maps but with maps and Java 8 lambdas you could use compute() etc. to build maps that contain collections and combine maps that don't.
Here's an example of how you'd do it with maps. Note that this is very bad style and an example using proper pojos will follow:
Disclaimer: example based on the OP's code, not recommended (read text above)
//Problem 1: we don't know the type of the values, i.e. we could put anything for "id" etc.
Map<String, Object> story1=new HashMap<>();
story1.put("id", 1);
story1.put("title", "Onboarding");
story1.put("keyword","new joinee");
story1.put("targeting","finance");
Map<String, Object> story2=new HashMap<>();
story2.put("id", 1);
story2.put("title", "Onboarding");
story2.put("keyword","training");
story2.put("targeting","HR");
List<Map<String, Object>> stories=new ArrayList<>();
stories.add(story1);
stories.add(story2);
Map<Integer, Map<String, Object>> combined = new HashMap<>();
stories.forEach((story) -> {
//Problem 2: because we don't know the type of the values we need a lot of nasty casts
Map<String, Object> combinedStory = combined.computeIfAbsent( (Integer)story.get( "id" ), k -> new HashMap<String, Object>() );
combinedStory.put("id", story.get( "id" ) );
combinedStory.put("title", story.get( "title" ) );
//Problem 3: the combined map would look a lot like your "story" maps but would contain different types
((List<String>)combinedStory.computeIfAbsent( "keyword", v -> new List<String>() )).add( (String)story.get("keyword") );
((List<String>)combinedStory.computeIfAbsent( "targeting", v -> new List<String>() )).add( (String)story.get("targeting") );
});
Using POJOs
Here's a greatly simplified example of how you'd do it with proper Java objects (POJOs). Note that those are meant to resemble your code as much as possible and there are a lot of other issues but addressing those would be way too much here and better designed code would be a lot larger and probably harder to understand - after all it's just meant to show you a difference.
First let's define our classes (for simplicity I made the fields public, you'd normally not do that):
class Story {
public final int id;
public String title;
public String keyword;
public String targeting;
public Story(int storyId) {
id = storyId ;
}
}
class MultiStory {
public final int id;
public String title;
public Set<String> keywords = new HashSet<>();
public Set<String> targetingInfo = new HashSet<>();
public MultiStory( int storyId ) {
id = storyId ;
}
}
Then let's reiterate the code above:
Story story1=new Story( 1 );
story1.title = "Onboarding";
story1.keyword = "new joinee";
story1.targeting = "finance";
Story story2=new Story( 1 );
story2.title = "Onboarding";
story2.keyword = "training";
story2.targeting = "HR";
List<Story> stories=new ArrayList<>();
stories.add(story1);
stories.add(story2);
Map<Integer, MultiStory> combined = new HashMap<>();
stories.forEach((story) -> {
MultiStory multiStory = combined.computeIfAbsent( story.id, v -> new MultiStory( story.id ) );
multiStory.title = story.title;
multiStory.keywords.add( story.keyword );
multiStory.targetingInfo.add( story.targeting );
});
As you can see, there are no casts needed and it's clear what fields are available (though not necessarily filled) which makes it easier to reason about the code and spot errors (the compiler can help a lot here which it couldn't to in the example that uses maps).
Here is a solution using classes to represent the story and tags:
public static void main(String[] args) {
TagsCollector app = new TagsCollector();
app.go();
}
private void go() {
List<Story> stories = createStories();
System.out.println(stories);
Map<Long, Tags> tagsById = collectTags(stories);
tagsById.forEach((aLong, tags) -> System.out.println(tags));
}
private List<Story> createStories() {
return Arrays.asList(
new Story(1, "Onboarding", "new joinee", "finance"),
new Story(1, "Onboarding", "training", "HR")
);
}
private Map<Long, Tags> collectTags(List<Story> stories) {
Map<Long, Tags> tagsById = new HashMap<>();
stories.forEach(s -> {
Tags tags = tagsById.computeIfAbsent(s.id, v -> new Tags(s));
tags.getKeywords().add(s.getKeyword());
tags.getTargetings().add(s.getTargeting());
});
return tagsById;
}
Class used to represent the Story:
public class Story {
private final long id;
private final String title;
private final String keyword;
private final String targeting;
public Story(long id, String title, String keyword, String targeting) {
this.id = id;
this.title = title;
this.keyword = keyword;
this.targeting = targeting;
}
public long getId() {
return id;
}
public String getTitle() {
return title;
}
public String getKeyword() {
return keyword;
}
public String getTargeting() {
return targeting;
}
#Override
public String toString() {
return String.format("Story %s, title=%s, keyword=%s, targeting=%s", id, title, keyword, targeting);
}
}
Class used to represent the Tags:
public class Tags {
private final long id;
private final String title;
private final List<String> keywords = new ArrayList<>();
private final List<String> targetings = new ArrayList<>();
Tags(Story story) {
this.id = story.id;
this.title = story.title;
}
public List<String> getKeywords() {
return keywords;
}
public List<String> getTargetings() {
return targetings;
}
#Override
public String toString() {
return String.format("Tags for id %s, title:%s: keywords=%s, targetings=%s", id, title, keywords, targetings);
}
}
Output
[Story 1, title=Onboarding, keyword=new joinee, targeting=finance, Story 1, title=Onboarding, keyword=training, targeting=HR]
Tags for id 1, title:Onboarding: keywords=[new joinee, training], targetings=[finance, HR]
Yes, you can do that with a Multimap. First I would define a pojo for Story in order to make things clearer:
public class Story {
private int id;
private String title;
private String keyword;
private String targeting;
//getters setters
}
Second you need to define a key with hashcode and equals.
public static class StoryKey {
private final int id;
private final String title;
public StoryKey(int id, String title) {
this.id = id;
this.title = title;
}
//getters
#Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
StoryKey storyKey = (StoryKey) o;
if (id != storyKey.id) return false;
return title != null ? title.equals(storyKey.title) : storyKey.title == null;
}
#Override
public int hashCode() {
int result = id;
result = 31 * result + (title != null ? title.hashCode() : 0);
return result;
}
The code will look like:
ArrayListMultimap<StoryKey, Story> multiMap = ArrayListMultimap.create();
List<Story> stories = new ArrayList();
Story story1 = new Story();
story1.setId(1);
story1.setTitle("Onboarding");
story1.setKeyword("training");
story1.setTargeting("HR");
Story story2 = new Story();
story2.setId(1);
story2.setTitle("Onboarding");
story2.setKeyword("new joinee,");
story2.setTargeting("finance");
stories.add(story1);
stories.add(story2);
System.out.println(stories);
stories.
forEach((story) -> {
multiMap.put(new StoryKey(story.getId(), story.getTitle()), story);
});
multiMap.keys().forEach(key ->
System.out.println(
"id =" + key.getId() +
" title =" + key.getTitle()+
"keyword =" + multiMap.get(key).stream().map(story->story.getKeyword()).collect(Collectors.toList()).toString()+
"targeting ="+ multiMap.get(key).stream().map(story->story.getTargeting()).collect(Collectors.toList()).toString())
);
I looking for solution how to make List (or something) with unique Product. The reason i want to do it is total price of Product. Each sets can contains same Product.
Here's my classes.
public class Product {
public String name; // unique name
public double price;
public double qty;
}
&
public class Sets {
public Product item1;
public Product item2;
...
public Product item7;
public static listsProduct<Product> = new Arraylists<Product>();
}
I'm trying to make a Lists but i don't know how to add a unique product. To add Product i use reflection.
My method:
public void getProducts() throws NoSuchMethodException, Exception {
Sets object = this;
Class clazz = object.getClass();
Field[] fields = clazz.getFields();
Method m1 = Product.class.getMethod("getname", null);
for (Field field : fields) {
if(field.get(object)!=null) {
System.out.println(field.getName()+" = " + m1.invoke(field.get(object),null));
Product e=(Product) field.get(object);
if (listsProduct==null ) listsProduct.add((Produkt) field.get(object));
if (!(listsProduct.contains(field.get(object)))) listsProduct.add(e);
}
}
It's adding a Product correctly but how make UNIQUE lists?
Thanks in advance for any help !
EDIT :
So... What do u want achieve?
eg.
sets :
1) butter, milk, peanut
2) goodie, butter, xxx
3) milk, peanut, xxx
result:
List of unique product
butter
milk
peanut
xxx
goodie
if product exist on lists sum price
You do not need to use the Reflection API for things like this!
One way to get a list of unique products would be to use Map::merge with the Product name as key and the Product::merge method from this example as the remapping function.
Given a class Product...
public class Product {
String name;
double price;
int qty;
public Product(String name, double price, int qty) {
this.name = name; this.price = price; this.qty = qty;
}
public Product merge(Product p) {
price += p.price;
qty += p.qty;
return this;
}
#Override
public String toString() {
return String.format("%s x %d (%.2f)", name, qty, price);
}
}
And a List of Sets of Products:
List<Set<Product>> sets = asList(
new HashSet<>(asList(new Product("cheese", 5, 1), new Product("milk", 3, 3))),
new HashSet<>(asList(new Product("peanut", 1, 1), new Product("bread", 2, 1))),
new HashSet<>(asList(new Product("cheese", 5, 1), new Product("peanut", 1, 1)))
);
A Collection of unique Products can be created like this:
private static Collection<Product> listProducts(List<Set<Product>> sets) {
Map<String, Product> uniques = new HashMap<>();
for(Set<Product> set : sets)
for(Product p : set)
uniques.merge(p.name, p, (a, b) -> a.merge(b));
return uniques.values();
}
Full working example:
import static java.util.Arrays.*;
import java.util.*;
public class UniqProd {
public static class Product {
String name;
double price;
int qty;
public Product(String name, double price, int qty) {
this.name = name;
this.price = price;
this.qty = qty;
}
public Product merge(Product p) {
price += p.price;
qty += p.qty;
return this;
}
#Override
public String toString() {
return String.format("%s x %d (%.2f)", name, qty, price);
}
}
public static void main(String[] args) {
List<Set<Product>> sets = asList(
new HashSet<>(asList(new Product("cheese", 5, 1), new Product("milk", 3, 3))),
new HashSet<>(asList(new Product("peanut", 1, 1), new Product("bread", 2, 1))),
new HashSet<>(asList(new Product("cheese", 5, 1), new Product("peanut", 1, 1)))
);
listProducts(sets).forEach(System.out::println);
}
private static Collection<Product> listProducts(List<Set<Product>> sets) {
Map<String, Product> uniques = new HashMap<>();
for (Set<Product> set : sets)
for (Product p : set)
uniques.merge(p.name, p, (a, b) -> a.merge(b));
return uniques.values();
}
}
If you, for some reason, must/want to use your Sets class instead of a java.util.Set, construct a List of the products in your Sets instance before iterating it:
private static Collection<Product> listProducts(List<Sets> sets) {
Map<String, Product> uniques = new HashMap<>();
for (Sets set : sets)
for (Product p : asList(set.item1, set.item2, set.item3))
uniques.merge(p.name, p, (a, b) -> a.merge(b));
return uniques.values();
}
I still didn't get why you want to use reflection , I am giving below answer to solve your problem of how to store unique products ?
If you want to add unique products . you must define that what makes the product Unique? Lets assume that product name will help you identifying whether they are not-equal/unique.
To define it let's write equals &hashcode method in product class
public class Product {
public String name; // unique name
public double price;
public double qty;
public boolean equals(Object obj){
if (obj ==null || ! obj instanceOf Prpduct) return false;
else return ((Product) obj).name.equals(name);// also write a null check conditions for name field.
}
public interest hashCode(){
return name.hashCode();
}
}
Now change your data structure from List to Set
which will store only distinct Products , like below
`
public class Sets {
public Product item1;
public Product item2;
...
public Product item7;
public static Set<Product> productSet= new HashSet<Product>();
}
`
With this whenever you will add productSet only unique would get stored.