They both do the same thing (unless someone's done something unusual), other than that your second one creates an object and adds a property to it. But literal notation takes less space in the source code. It's clearly recognizable as to what is happening, so using new Object(), you are really just typing more and (in theory, if not optimized out by the JavaScript engine) doing an unnecessary function call.

These

person = new Object() /*You should put a semicolon here too.  
It's not required, but it is good practice.*/ 
-or-

person = {
    property1 : "Hello"
};

technically do not do the same thing. The first just creates an object. The second creates one and assigns a property. For the first one to be the same you then need a second step to create and assign the property.

The "something unusual" that someone could do would be to shadow or assign to the default Object global:

// Don't do this
Object = 23;

In that highly-unusual case, new Object will fail but {} will work.

In practice, there's never a reason to use new Object rather than {} (unless you've done that very unusual thing).

It essentially boils down to if you need multiple instances of your object or not; object defined with a constructor lets you have multiple instances of that object. Object literals are basically singletons with variables/methods that are all public.

// define the objects:
var objLit = {
  x: 0,
  y: 0,
  z: 0,
  add: function () {
    return this.x + this.y + this.z;
  }
};

var ObjCon = function(_x, _y, _z) {
  var x = _x; // private
  var y = _y; // private
  this.z = _z; // public
  this.add = function () {
    return x + y + this.z; // note x, y doesn't need this.
  };
};

// use the objects:
objLit.x = 3; 
objLit.y = 2; 
objLit.z = 1; 
console.log(objLit.add());    

var objConIntance = new ObjCon(5,4,3); // instantiate an objCon
console.log(objConIntance.add());
console.log((new ObjCon(7,8,9)).add()); // another instance of objCon
console.log(objConIntance.add()); // same result, not affected by previous line

The difference is the way they're indexed.
Objects have name, value pairs which are not ordered. In some browsers the order you added values will be the order you get when you traverse the object but not in all. The name is usually a string.
Arrays are numerically indexed and the order is totally reliable

An object literal is a way to declare an object.

You would write

var myObject = {}; // with or without members

instead of

var myOject = new Object();

You can also use array literals:

var myArray = [];

instead of

var myArray = new Array(); // with or without members

It's shorter, of course but it also bypasses the constructor so it's supposed to be more efficient.

In JavaScript objects literals are made up of key-value pairs. Keys in JavaScript are always strings while values may be of any data type.

JavaScript provides syntactic sugar for defining keys. For example unlike string literals you don't need to quote keys. Hence the following two examples are equivalent:

{ x: 0 }   // example 1
{ "x": 0 } // example 2

However this syntactic sugar only works for identifiers that don't have any whitespace (i.e. spaces, tabs, newlines, etc.) in between them. For example, the following is invalid in JavaScript:

{ a property: 0 } // whitespace not allowed in identifiers

However you can workaround this limitations by quoting the identifier:

{ "a property": 0 } // valid

You may also use boolean (true or false), number literals and undefined and null as keys. However remember that they are coerced to strings. Hence you can do:

var o = {
    undefined: 1,
    null: 2,
    true: 3,
    false: 4,
    0: 5
};

Then you can access them as:

alert(o.undefined); // 1
alert(o.null);      // 2
alert(o.true);      // 3
alert(o.false);     // 4
alert(o[0]);        // 5

The last statement is important. Number literals by themselves do not classify as valid identifiers. Hence you need to use the array bracket notation ([]) instead of the dot notation (.) to access it.

Since all keys in JavaScript are strings you could even do:

alert(o["undefined"]); // 1
alert(o["null"]);      // 2
alert(o["true"]);      // 3
alert(o["false"]);     // 4
alert(o["0"]);         // 5

However you can't use objects, arrays or functions as keys. For example the following is invalid:

{ {1: 2}: 3 }            // objects can't be used as keys
{ [1]: 2 }               // arrays can't be used as keys
{ function () {}: true } // functions can't be used as keys

That's all you need to know about object literals.