Assuming that you use Java 8, you could do that with the Stream API thanks to the method flatMap(Function<? super T,? extends Stream<? extends R>> mapper) as next: // 1. Convert the Set as a Stream of List<Map<String, List<Object>>> // 2. Extract the elements of the lists to get a Stream of Map<String, List<Object>> // … Read more
I’d say the best way of doing this (if by best you don’t mean “most concise”) without using Guava is using the technique Guava uses internally, which for your example would look something like this: Iterator<String> iter = data.iterator(); StringBuilder sb = new StringBuilder(); if (iter.hasNext()) { sb.append(iter.next()); while (iter.hasNext()) { sb.append(separator).append(iter.next()); } } String … Read more
Keep 2 data structures: A dictionary of words -> count. Just use an ordinary HashMap<String, Long>. An “array” to keep track of order, such that list[count] holds a Set<String> of words with that count. I’m writing this as though it were an array as a notational convenience. In fact, you probably don’t know an upper … Read more
If you’re willing to replace your application’s Thread creations with another wrapper class, said wrapper class can track the active and inactive Threads for you. Here’s a minimal workable shell of such a wrapper: namespace ThreadTracker { using System.Collections.Generic; using System.Collections.ObjectModel; using System.Threading; public class TrackedThread { private static readonly IList<Thread> threadList = new List<Thread>(); … Read more
From the official Sun glossary: deprecation: Refers to a class, interface, constructor, method or field that is no longer recommended, and may cease to exist in a future version. From the how-and-when to deprecate guide: You may have heard the term, “self-deprecating humor,” or humor that minimizes the speaker’s importance. A deprecated class or method … Read more
As you correctly observed in the answer to your own question, removing the “virtual” keyword from the collection properties works around the problem, by preventing the Entity Framework from creating a change tracking proxy. However, this is not a solution for many people, because change tracking proxies can be really convenient and can help prevent … Read more
This works: Random generator = new Random(); Object[] values = myHashMap.values().toArray(); Object randomValue = values[generator.nextInt(values.length)]; If you want the random value to be a type other than an Object simply add a cast to the last line. So if myHashMap was declared as: Map<Integer,String> myHashMap = new HashMap<Integer,String>(); The last line can be: String randomValue … Read more
Replace the brackets and commas with empty space. String formattedString = myArrayList.toString() .replace(“,”, “”) //remove the commas .replace(“[“, “”) //remove the right bracket .replace(“]”, “”) //remove the left bracket .trim(); //remove trailing spaces from partially initialized arrays
Each index will basically be a separate Map. You can (and probably should) abstract this behind a class that manages the searches, indexing, updates and removals for you. It wouldn’t be hard to do this fairly generically. But no, there’s no standard out of the box class for this although it can easily be built … Read more
The .NET 4.0 Framework introduces several thread-safe collections in the System.Collections.Concurrent Namespace: ConcurrentBag<T> Represents a thread-safe, unordered collection of objects. ConcurrentDictionary<TKey, TValue> Represents a thread-safe collection of key-value pairs that can be accessed by multiple threads concurrently. ConcurrentQueue<T> Represents a thread-safe first in-first out (FIFO) collection. ConcurrentStack<T> … Read more