look at set (Hashset, enumset) and hash (HashMap,linkedhash...,idnetityhash..) based implementations. they have O(1) for contains()

[This cheatsheet][1] is of great help.


  [1]: http://infotechgems.blogspot.com/2011/11/java-collections-performance-time.html

For your particular case of numbers with a relatively high density I&#39;d use a BitSet, it will be faster and much smaller than a hash set.

The only data structure faster than HashSet is likely to be TIntHashSet from Trove4J.  This uses primitives avoiding the need to use Integer Objects.

If the number of integers is small, you can create a boolean[] where each value present is turned into a &quot;true&quot;.  This will be O(1).  Note: HashSet is not guarenteed to be O(1) and is more likely to be O(log(log(N))).

You will only get O(1) for an ideal hash distribution.  However, it is more likely you will get collisions of hashed buckets and some lookups will need to check more than one value.

hashing(hash set) is the best one with O(1)

I would like my User model to sanitize some input before before save. For now some simple whitespace stripping will do. 
So to avoid people registering with &quot;Harry &quot; and pretend to be &quot;Harry&quot;, for example.


I assume it is a good idea to do this stripping before validation, so that the validates_uniqueness_of can avoid accidental duplicates.



    class User &lt; ActiveRecord::Base
      has_many :open_ids
      
      validates_presence_of :name
      validates_presence_of :email
      validates_uniqueness_of :name
      validates_uniqueness_of :email
      validates_format_of :email, :with =&gt; /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
      
      before_validation :strip_whitespace, :only =&gt; [:name, :email, :nick]
     
      private
      def strip_whitespace(value)
        value.responds_to?(&#39;strip&#39;) ? value.strip : value
      end
    end

However, this code comes with an error ArgumentError: wrong number of arguments (0 for 1). I assumed the callback would be passed the values.

Also: is this stripping actually a good idea? Or should I rather validate on space and tell the user that &quot;Harry  &quot; contains invalid spacess (I want to allow &quot;Harry Potter&quot; but not &quot;Harry\s\sPotter&quot;).

Edit: As pointed out in a comment, my code is wrong (which is why I was asking the question a.o.). Please make sure you read the accepted answer in addition to my question for the correct code and to avoid the same mistakes I made.

Rails before_validation strip whitespace best practices

I have a string array like this.

`string[] queries` with data more than one string.

I want to skip the last string from the element and take the remaining. I have come up with

    var remStrings = queries.Reverse().Skip(1).Take(queries.Length - 1);

Is there a better alternative to this?

how to take all array elements except last element in C#

What&#39;s the data structure in Java that has the fastest operation for contains() ?

e.g. i have a set of numbers { 1, 7, 12, 14, 20... }

Given another arbitrary number x, what&#39;s the fastest way (on average) to generate the boolean value of whether x is contained in the set or not? The probability for !contains() is about 5x higher.

Do all the map structures provide o(1) operation? Is HashSet the fastest way to go?

Fastest data structure for contains() in Java?

What's the data structure in Java that has the fastest operation for contains() ?
e.g. i have a set of numbers { 1, 7, 12, 14, 20... }
Given another arbitrary number x, what's the fastest way (on average) to generate the boolean value of whether x is contained in the set or not? The probability for !contains() is about 5x higher.
Do all the map structures provide o(1) operation? Is HashSet the fastest way to go?

What is the simplest way to to wait for all tasks of `ExecutorService` to finish? My task is primarily computational, so I just want to run a large number of jobs - one on each core.  Right now my setup looks like this: 

    ExecutorService es = Executors.newFixedThreadPool(2);
    for (DataTable singleTable : uniquePhrases) {	
        es.execute(new ComputeDTask(singleTable));
    }
    try{
        es.wait();
    } 
    catch (InterruptedException e){
        e.printStackTrace();
    }

`ComputeDTask` implements runnable.  This appears to execute the tasks correctly, but the code crashes on `wait()` with `IllegalMonitorStateException`.  This is odd, because I played around with some toy examples and it appeared to work.  

`uniquePhrases` contains several tens of thousands of elements.  Should I be using another method?  I am looking for something as simple as possible

ExecutorService, how to wait for all tasks to finish

How do I get Jackson to serialize my Joda DateTime object according to a simple pattern (like &quot;dd-MM-yyyy&quot;)?

I&#39;ve tried:

    @JsonSerialize(using=DateTimeSerializer.class)
    private final DateTime date;

I&#39;ve also tried:

    ObjectMapper mapper = new ObjectMapper()
        .getSerializationConfig()
        .setDateFormat(df);

Thanks!

How to serialize Joda DateTime with Jackson JSON processor?

The Prepared Statement is a slightly more powerful version of a Statement, and should always be at least as quick and easy to handle as a Statement.  
The Prepared Statement may be parametrized 
 
Most relational databases handles a JDBC / SQL query in four steps:  

1. Parse the incoming SQL query  
2. Compile the SQL query  
3. Plan/optimize the data acquisition path  
4. Execute the optimized query / acquire and return data  
 
A Statement will always proceed through the four steps above for each SQL query sent to the database. A Prepared Statement pre-executes steps (1) - (3) in the execution process above. Thus, when creating a Prepared Statement some pre-optimization is performed immediately. The effect is to lessen the load on the database engine at execution time.  

Now my question is this:

&quot;Is there any other advantage of using Prepared Statement?&quot;


Difference between Statement and PreparedStatement

I&#39;m developing a Java enterprise application, currently doing Java EE security stuff to restrict access for particular functions to specific users. I configured the application server and everything, and now I&#39;m using the RolesAllowed-annotation to secure the methods:

    @Documented
    @Retention (RUNTIME)
    @Target({TYPE, METHOD})
    public @interface RolesAllowed {
        String[] value();
    }

When I use the annotation like this, it works fine:

    @RolesAllowed(&quot;STUDENT&quot;)
    public void update(User p) { ... }

But this is not what I want, as I have to use a String here, refactoring becomes hard, and typos can happen. So instead of using a String, I would like to use an Enum value as a parameter for this annotation. The Enum looks like this:

    public enum RoleType {
        STUDENT(&quot;STUDENT&quot;),
        TEACHER(&quot;TEACHER&quot;),
        DEANERY(&quot;DEANERY&quot;);

        private final String label;

        private RoleType(String label) {
            this.label = label;
        }

        public String toString() {
            return this.label;
        }
    }

So I tried to use the Enum as a parameter like this:

    @RolesAllowed(RoleType.DEANERY.name())
    public void update(User p) { ... }

But then I get the following compiler error, although Enum.name just returns a String (which is always constant, isn&#39;t it?).

&gt; The value for annotation attribute RolesAllowed.value must be a constant expression`

The next thing I tried was to add an additional final String to my Enum:

    public enum RoleType {
        ...
        public static final String STUDENT_ROLE = STUDENT.toString();
        ...
    }

But this also doesn&#39;t work as a parameter, resulting in the same compiler error:

    // The value for annotation attribute RolesAllowed.value must be a constant expression
    @RolesAllowed(RoleType.STUDENT_ROLE)

How can I achieve the behavior I want? I even implemented my own interceptor to use my own annotations, which is beautiful, but far too much lines of codes for a little problem like this.

**DISCLAIMER**

This question was originally a [Scala][1] question. I found out that Scala is not the source of the problem, so I first try to do this in Java.

  [1]: http://en.wikipedia.org/wiki/Scala_%28programming_language%29


Use Enum type as a value parameter for @RolesAllowed-Annotation

How to import a jar in Eclipse?

I want to remove all elements in a list which contains (or does not contain) a set of specific characters, however I&#39;m running in to problems iterating over the list and removing elements as I go along. Two pretty much equal examples of this is given below. As you can see, if two elements which should be removed are directly following each other, the second one does not get removed.

Im sure there are a very easy way to do this in python, so if anyone know it, please help me out - I am currently making a copy of the entire list and iterating over one, and removing elements in the other...Not a good solution I assume

    &gt;&gt;&gt; l
    [&#39;1&#39;, &#39;32&#39;, &#39;523&#39;, &#39;336&#39;]
    &gt;&gt;&gt; for t in l:
    ... 	for c in t:
    ... 		if c == &#39;2&#39;:
    ... 			l.remove(t)
    ... 			break
    ... 			
    &gt;&gt;&gt; l
    [&#39;1&#39;, &#39;523&#39;, &#39;336&#39;]
    &gt;&gt;&gt; l = [&#39;1&#39;,&#39;32&#39;,&#39;523&#39;,&#39;336&#39;,&#39;13525&#39;]
    &gt;&gt;&gt; for w in l:
    ... 	if &#39;2&#39; in w: l.remove(w)
    ... 	
    &gt;&gt;&gt; l
    [&#39;1&#39;, &#39;523&#39;, &#39;336&#39;]

Figured it out:

    &gt;&gt;&gt; l = [&#39;1&#39;,&#39;32&#39;,&#39;523&#39;,&#39;336&#39;,&#39;13525&#39;]
    &gt;&gt;&gt; [x for x in l if not &#39;2&#39; in x]
    [&#39;1&#39;, &#39;336&#39;]

Would still like to know if there is any way to set the iteration back one set when using for x in l though. 


Removing elements from a list containing specific characters

I need a data structure to store string-int value pairs in an 1:1 relationship, and being able too look up from either way their counterpart.

I wrote a class with a Hashtable and a String array and stored the data 2 times and used the built in functions for lookup.

My question is that is there a nicer way to accomplish this? And by nicer I mean being efficient and not storing the data 2 times, and preferably without writing a ton of code either :P.



How to create a 2 way map in java

When should I use a dictionary, list or set?

Are there scenarios that are more suited for each data type?

In Python, when to use a Dictionary, List or Set?

Is there any standard Java library class to represent a tree in Java?

Specifically I need to represent the following:

 - The sub-tree at any node can have an arbitrary number of children
 - Each node (after the root) and it&#39;s children will have string value 
 - I need to get all the children (some sort of list or array of Strings) of a given node and it&#39;s string value(i.e. a method that will take a node as input and return all the string values of the children node as output)

Is there any available structure for this or do I need to create my own (if so implementation suggestions would be great).

How to implement a tree data-structure in Java?

Why exactly do we need a &quot;Circular Linked List&quot; (singly or doubly) data structure?

What problem does it solve that is evident with simple Linked Lists (singly or doubly)? 

Why exactly do we need a &quot;Circular Linked List&quot; (singly or doubly) data structure?

I am trying to optimize a piece of code which compares elements of list.

Eg.

    public void compare(Set&lt;Record&gt; firstSet, Set&lt;Record&gt; secondSet){
        for(Record firstRecord : firstSet){
            for(Record secondRecord : secondSet){
                // comparing logic
            }
        }
    }

Please take into account that the number of records in sets will be high.

Thanks

Shekhar




What is the fastest way to compare two sets in Java?

How can I make as &quot;perfect&quot; a subclass of *dict* as possible? The end goal is to have a simple *dict* in which the keys are lowercase.

It would seem that there should be some tiny set of primitives I can override to make this work, but according to all my research and attempts it seem like this isn&#39;t the case:

*   If I [override `__getitem__`/`__setitem__`][1], then `get`/`set` don&#39;t work.    How can I make them work?  Surely I don&#39;t need to implement them individually?

*   Am I preventing pickling from working, and do I need to implement `__setstate__` etc?

*   Do I [need `repr`, `update` and `__init__`][2]?

*   Should I just [use mutablemapping][3] (it seems one shouldn&#39;t use `UserDict`
    or `DictMixin`)?  If so, how? The docs aren&#39;t exactly enlightening.

  [1]: https://stackoverflow.com/a/2390889
  [2]: https://stackoverflow.com/a/2390997
  [3]: https://stackoverflow.com/a/1622872

Here is my first go at it, `get()` doesn&#39;t work and no doubt there are many other minor problems:

    class arbitrary_dict(dict):
        &quot;&quot;&quot;A dictionary that applies an arbitrary key-altering function
           before accessing the keys.&quot;&quot;&quot;

        def __keytransform__(self, key):
            return key

        # Overridden methods. List from 
        # https://stackoverflow.com/questions/2390827/how-to-properly-subclass-dict

        def __init__(self, *args, **kwargs):
            self.update(*args, **kwargs)

        # Note: I&#39;m using dict directly, since super(dict, self) doesn&#39;t work.
        # I&#39;m not sure why, perhaps dict is not a new-style class.

        def __getitem__(self, key):
            return dict.__getitem__(self, self.__keytransform__(key))

        def __setitem__(self, key, value):
            return dict.__setitem__(self, self.__keytransform__(key), value)

        def __delitem__(self, key):
            return dict.__delitem__(self, self.__keytransform__(key))

        def __contains__(self, key):
            return dict.__contains__(self, self.__keytransform__(key))
    

    class lcdict(arbitrary_dict):
        def __keytransform__(self, key):
            return str(key).lower()

How to &quot;perfectly&quot; override a dict?

I have a set like this:

    keep = set(generic_drugs_mapping[drug] for drug in drug_input)

How do I add values `[0,1,2,3,4,5,6,7,8,9,10]` into this set?

Append values to a set in Python

I have two lists in Python:

    temp1 = [&#39;One&#39;, &#39;Two&#39;, &#39;Three&#39;, &#39;Four&#39;]
    temp2 = [&#39;One&#39;, &#39;Two&#39;]

I want to create a third list with items from the first list which aren&#39;t  in the second list:

    temp3 = [&#39;Three&#39;, &#39;Four&#39;]

Are there any fast ways without cycles and checking?

Content Type	Original Author	Original Content on Stackoverflow
Question	codechobo	View Question on Stackoverflow
Solution 1 - Java	Aravind Yarram	View Answer on Stackoverflow
Solution 2 - Java	starblue	View Answer on Stackoverflow
Solution 3 - Java	Peter Lawrey	View Answer on Stackoverflow
Solution 4 - Java	Satish	View Answer on Stackoverflow

Fastest data structure for contains() in Java?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Solution 4 - Java

how to take all array elements except last element in C#

Rails before_validation strip whitespace best practices

Attributions