Skip to main content

Go For Java Developers


Data Types:

  1. String  --> string (defaults to "")
  2. Integer --> int    (defaults to 0)
  3. Double --> float (defaults to 0.0)
  4. Boolean --> bool (defaults to false)
    final equivalent
     const x string = "text" 

    Define 

    String x   -->    var x string
  

   Initialize

    x = "text" --> x = "text"
  
  Define & Initialize
    String x = "text" --> x := "text"

   Collection

     List list = new ArrayList<>();   --> var list []string
                                                                      --> list := []string{"text"}
                                                                      --> list = append(list, "another text")

    Map map = new HashMap<>():

       var x map[string]int  where string is key and int is value.
       x["key1"] = 10
      
   Control Statements
     if/for/switch
     
    if (condition) {} --> if (condition) {}
    e.g.
     if (10 >= 10) {} --> if (10 >= 10) {}

    for(initialization;condition;incr/decr) {} --> for (initialization;condition;incr/decr) {}
    for (int x = 0; x < 10; x++) {} --> for (x := 0; x < 10; x++) {}

    switch(condition) {
      case A: 
         //
         break;
      case B:
        //
        break;
      default:
    }

   Go equivalent
    switch condition {
      case A: 
         //
      case B:
        //
      default:
    }
   
   Functions
     public static Integer add(int x, int y) {
        return x + y;
     }

     Go equivalent
     func Add(x int, y int) int {   // capital function name means public/package-visible
        return x + y;
     }
     
      Functions can also return multiple values
      func AddSub(x, y int) (int, int) {
        return x+y, x-y
      }
      
      Go supports closures as well.
      Kind of an anonymous function and can be assigned to a variable, e.g.
      func main() {
        add := function (x, y int) int { return x+y }
        add(1,1)
      }

     Structs & Methods
      Go doesn't support classes, nor inheritance. Use structs and methods to encapsulate data and operations e.g.

      type user struct { name string, age int } 
      structs can also contain embedded types e.g.
      type account struct {employee user, id int }

     Initialize Struct
          x := new(user)
          x := &user{}
          x := &user{}

      Composition
         type Account struct { 
            *User // this structs will act like primary member.
             id int
        }
      
     Go supports method that which are visible on on struct types e.g.
     func (a account) printName() {  
         // prints name
     }
         // not (u user) means this method is part of the struct
        // and can be called on the struct type e.g.
       func main() {
         p := account{
                   employe = {name := "xyz", age = 20},
                   id = 100000
       }
       p.printName() // note sends copy of p not a reference to p. To send a reference you'll to change printName function's signature to func (a *account) printName() {}

   
      packages
       Go packages are always a single value. e.g.
          package db
          package app
       But imports needs to full path e.g.
         package app/db


     Interfaces

       type Logger interface { 
          Log(message string)
       }
       
      Implementing an interface in Go requires just creating method with same signature e.g.
      type ConsoleLogger struct {}
      func (l *ConsoleLogger) Log(message string) {}


     Go doesn't have any exception handling, but built-in type can be used.
      type error interface { Error() string } // built-in error interface

      import ( "errors" ) 
      func process(count int) error {
           if count < 1 { 
              return errors.New("Invalid count") 
      }

     Finally equivalent in go is defer e.g.
      defer file.close()






     
                                                             
   

Comments

Popular posts from this blog

JPA 2 new feature @ElementCollection explained

@ElementCollection is new annotation introduced in JPA 2.0, This will help us get rid of One-Many and Many-One shitty syntax.

Example 1: Stores list of Strings in an Entity

@Entity
public class Users implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
@ElementCollection
    private List<String> certifications = new ArrayList<String>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public List<String> getCertifications() {
        return certifications;
    }

    public void setCertifications(List<String> certifications) {
        this.certifications = certifications;
    }
..
}

        Users u = new Users();
        u.getCertifications().add("Sun Certified Java Programmer");
        em.persist(u);

Generated Tables

   Users
Column --> ID
    Row             1

Users_CERTIFICATIONS

Validating CSV Files

What is CsvValidator ?
  A Java framework which validates any CSV files something similar to XML validation using XSD.

Why should I use this ?
  You don't have to use this and in fact its easy to write something your own and also checkout its source code for reference.

Why did I write this ?
  Some of our projects integrate with third party application which exchanges information in CSV files so I thought of writing a generic validator which can be hooked in multiple projects or can be used by QA for integration testing.

What is the license clause ?
GNU GPL v2

Are there any JUnit test cases for me checkout ?
 Yes, source

How to integrate in my existing project ?

Just add the Jar which can be downloaded from here CsvValidator.jar and you are good.

Instantiate CsvValidator constructor which takes these 3 arguements

         // filename is the the file to be validated and here is a sample         // list - defines all the fields in the above csv file ( a field has index, type, isOptional, rege…

ArrayList vs LinkedList vs HashSet Performance Comparision

ConclusionsInserting & Reading sequentially from Collection prefer LinkedList/ArrayListInserting & Reading/Deleting by Search/equals from Collection prefer HashSetInserting, ArrayList & LinkedList performs best while HashSet takes double the timeReading, HashSet performs best while ArrayList & LinkedList are marginally lessDeleting, HashSet performs 10 times better than ArrayList & ArrayList performs 4 times better than LinkedList. LinkedList is slow because of sequencial search Bottom line : unless you are not going to iterate using for(Integer i : list ) then prefer HashSet
Inserting/Reading/Deleting integer's from zero till countJDK7Collectionactioncounttime msArrayListInsert1000/1LinkedListInsert1000/1HashSetInsert1000/1ArrayListInsert100005LinkedListInsert100004HashSetInsert100007ArrayListInsert10000011LinkedListInsert10000011HashSetInsert10000021ArrayListGet/Read1000LinkedListGet/Read1000HashSetGet/Read1000ArrayListGet/Read100004LinkedListGet/Read100003Has…