Відео

It's just a string he is giving that string to candidate to write some logic

Correct one would be as below. empMap.entrySet().stream().filter(e -> e.getValue().getSalary() > 20000).map(e -> e.getValue()).collect(Collectors.toList());

Can we use keyset()

@@veerendrakumarmeka3181 using keySet() here will allow to stream and process Keys only...So, we won't get the desired results.

empMap.values().stream().filter(e -> e.getSalary() > 20000).collect(Collectors.toList());

came here to write the same thing u wrote.

little correction "concurrent modification exception"

Yes

Congratulations @JavaTechLead

Yes

package com.demo; import java.util.HashMap; public class Demo { public static void main(String[] args) { HashMap<String, String> hm = new HashMap<>(); hm.put("Raju", "Raju"); hm.put("Kiran", "Kiran"); hm.put("Suman", "Suman"); hm.put("Ramu", "Ramu"); hm.entrySet().stream().map(e->e.getValue()).sorted((e1,e2)->e1.compareTo(e2)).forEach(e->System.out.println(e)); } }

English is not my first language and so is my communication.

package com.demo; import java.util.HashMap; import java.util.List; import java.util.stream.Collectors; public class Demo { public static void main(String[] args) { HashMap<String, Employee> empMap = new HashMap<>(); empMap.put("Raju", new Employee("Raju", "Java", 1000)); empMap.put("Kiran", new Employee("Kiran", "BI", 2000)); empMap.put("Suman", new Employee("Suman", "C#", 5000)); empMap.put("Ramu", new Employee("Ramu", ".Net", 10000)); System.out.println(getEmployees(empMap, 3000)); } public static List<Employee> getEmployees(HashMap<String, Employee> empMap, int salary){ return empMap.entrySet().stream().filter(e->e.getValue().getSalary()>salary).map(e->e.getValue()).collect(Collectors.toList()); } } class Employee{ private String name; private String dept; private int salary; public Employee(String name, String dept, int salary) { super(); this.name = name; this.dept = dept; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDept() { return dept; } public void setDept(String dept) { this.dept = dept; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } @Override public String toString() { return "Employee [name=" + name + ", dept=" + dept + ", salary=" + salary + "]"; } }

Lp L L Llllop ll pls p0l L L

@@JavaTechLead empMap.values().stream().filter(e -> e.getSalary() > salary).collect(Collectors.toList());

@@JavaTechLead great one and I'm having a question so there is no usage of key mention in the question so can't we directly create a stream of values which reduce the use of map function in the stream pipeline.

private static List<Employee> returnEmp(HashMap<String,Employee> map) { List<Employee> list = new ArrayList<>(); for(Map.Entry<String,Employee> newMap : map.entrySet() ){ if(newMap.getValue().salary>9000){ list.add(newMap.getValue()); } } return list; }

3 rounds

It's based on the role.

but volatile can be used only for boolean data types right. If I want one thread to see the updated value by another thread for other data types I need to use AtomicInteger, Atomic Double etc

@@niwasshashi6136 correct; The synchronised, volatile and Atomic are ways to achieve synchronisation. We restrict the shared resource to be accessed by only one three at a time; when two or more thread needs access to the shared resource, there could be of "data/memory inconsistencies" and thread interference as the threads communicate primarily by sharing the access to the resource for faster and efficient execution of programs & and inter-thread communication can be achieved via wait(), notify() and notifyAll() methods (for producer-consumer problem) present inside the Object class; Coming to volatile, The volatile keyword is a non-lock based and to be used "only" with the variable and using it with the method or a class (other than with field) is illegal; It guarantees that the value of the volatile variable is "always" read from the main memory instead of from localThread cache and always "visible" to other threads thus all the other threads can see the updated value for that variable after the write operation thus we can avoid the "data inconsistencies" that can arise in the multi-threaded environments where multiple threads are accessing a particular variable; The volatile also informs the compiler not to perform any kind of optimization and re-ordering since multiple threads are to access this variable; This is faster than "synchronised" which is applicable to only methods or blocks; because in Synchronised methods, the threads will acquire the lock(monitor) on the objects and then relinquishes the lock upon the completion of its purpose (Mutual Exclusion) and the waiting time for the threads to access the resource gets increased; (downside) The volatile and atomic ( java.util.concurrent.Atomic) are both applicable to variable and the read and the write operations are atomic; when to choose volatile and atomic? If the value of the variable does not depend on its previous value, volatile can be used and suitable for boolean variables; If the value of the variable "does" depend on its previous value, Atomic can be used because it provides methods to increment, decrement, compare and swap Operations (getAndSet(), getAndUpdate(), getAndIncrement(), incrementAndUpdate() and updateAndGet(); The classes involved are AtomicInteger, AtomicLong, AtomicDouble and AtomicReference; More Importantly, the Atomic is faster than synchronised and volatile; Both are immune to the concurrency hazards like DeadLock because of the non-(b)locking nature.

@@jeckrazi7691 very good explanation thanks for sharing it with us 😊

Yes Brother. It’s a good company for fresher and experienced.

@@JavaTechLead Have you Joined in That Company?

Got offer but didn’t join.

@@JavaTechLead Ok Good Bro... How Difficult Is Interview For Freshers based on Java Bro

@@PraveenKumar-uj2ih Interview is difficult compared to other MNC’s

I am coming up with another video on interviews attended 👍

correct

And when default size filled with 75% , it will automatically increases size by 2X time. i.e will become 32

Yeah

Selected 👍

@@JavaTechLead That's great.!

@@JavaTechLead when can we expect your next upload

@@sowmyach2628pp