diff --git a/packages/flutter_tools/lib/src/devfs.dart b/packages/flutter_tools/lib/src/devfs.dart
index 78b35eb..e4656a7 100644
--- a/packages/flutter_tools/lib/src/devfs.dart
+++ b/packages/flutter_tools/lib/src/devfs.dart
@@ -330,7 +330,7 @@
   final Set<String> assetPathsToEvict = new Set<String>();
 
   final List<Future<Map<String, dynamic>>> _pendingOperations =
-      new List<Future<Map<String, dynamic>>>();
+      <Future<Map<String, dynamic>>>[];
 
   Uri _baseUri;
   Uri get baseUri => _baseUri;
@@ -376,7 +376,7 @@
     // Handle deletions.
     printTrace('Scanning for deleted files');
     final String assetBuildDirPrefix = _asUriPath(getAssetBuildDirectory());
-    final List<Uri> toRemove = new List<Uri>();
+    final List<Uri> toRemove = <Uri>[];
     _entries.forEach((Uri deviceUri, DevFSContent content) {
       if (!content._exists) {
         final Future<Map<String, dynamic>> operation =
diff --git a/packages/flutter_tools/lib/src/ios/devices.dart b/packages/flutter_tools/lib/src/ios/devices.dart
index 9075daf..eb30f79 100644
--- a/packages/flutter_tools/lib/src/ios/devices.dart
+++ b/packages/flutter_tools/lib/src/ios/devices.dart
@@ -434,7 +434,7 @@
 }
 
 class _IOSDevicePortForwarder extends DevicePortForwarder {
-  _IOSDevicePortForwarder(this.device) : _forwardedPorts = new List<ForwardedPort>();
+  _IOSDevicePortForwarder(this.device) : _forwardedPorts = <ForwardedPort>[];
 
   final IOSDevice device;
 
diff --git a/packages/flutter_tools/lib/src/run_hot.dart b/packages/flutter_tools/lib/src/run_hot.dart
index c56a785..7473c6f 100644
--- a/packages/flutter_tools/lib/src/run_hot.dart
+++ b/packages/flutter_tools/lib/src/run_hot.dart
@@ -61,7 +61,7 @@
   Uri _observatoryUri;
 
   final bool benchmarkMode;
-  final Map<String, int> benchmarkData = new Map<String, int>();
+  final Map<String, int> benchmarkData = <String, int>{};
   // The initial launch is from a snapshot.
   bool _runningFromSnapshot = true;
   String kernelFilePath;
@@ -141,7 +141,7 @@
       return 1;
     }
 
-    final Map<String, dynamic> platformArgs = new Map<String, dynamic>();
+    final Map<String, dynamic> platformArgs = <String, dynamic>{};
 
     await startEchoingDeviceLog(package);
 
diff --git a/packages/flutter_tools/lib/src/template.dart b/packages/flutter_tools/lib/src/template.dart
index a1c3197..abf7731 100644
--- a/packages/flutter_tools/lib/src/template.dart
+++ b/packages/flutter_tools/lib/src/template.dart
@@ -24,7 +24,7 @@
 /// extensions.
 class Template {
   Template(Directory templateSource, Directory baseDir) {
-    _templateFilePaths = new Map<String, String>();
+    _templateFilePaths = <String, String>{};
 
     if (!templateSource.existsSync()) {
       return;
diff --git a/packages/flutter_tools/lib/src/vmservice.dart b/packages/flutter_tools/lib/src/vmservice.dart
index 574fe76..8d547ec 100644
--- a/packages/flutter_tools/lib/src/vmservice.dart
+++ b/packages/flutter_tools/lib/src/vmservice.dart
@@ -505,14 +505,14 @@
     _removeDeadIsolates(map['isolates']);
   }
 
-  final Map<String, ServiceObject> _cache = new Map<String,ServiceObject>();
-  final Map<String,Isolate> _isolateCache = new Map<String,Isolate>();
+  final Map<String, ServiceObject> _cache = <String,ServiceObject>{};
+  final Map<String,Isolate> _isolateCache = <String,Isolate>{};
 
   /// The list of live isolates, ordered by isolate start time.
-  final List<Isolate> isolates = new List<Isolate>();
+  final List<Isolate> isolates = <Isolate>[];
 
   /// The set of live views.
-  final Map<String, FlutterView> _viewCache = new Map<String, FlutterView>();
+  final Map<String, FlutterView> _viewCache = <String, FlutterView>{};
 
   int _compareIsolates(Isolate a, Isolate b) {
     final DateTime aStart = a.startTime;
@@ -767,7 +767,7 @@
   DateTime startTime;
   ServiceEvent pauseEvent;
 
-  final Map<String, ServiceObject> _cache = new Map<String, ServiceObject>();
+  final Map<String, ServiceObject> _cache = <String, ServiceObject>{};
 
   @override
   ServiceObject getFromMap(Map<String, dynamic> map) {
@@ -967,7 +967,7 @@
 class ServiceMap extends ServiceObject implements Map<String, dynamic> {
   ServiceMap._empty(ServiceObjectOwner owner) : super._empty(owner);
 
-  final Map<String, dynamic> _map = new Map<String, dynamic>();
+  final Map<String, dynamic> _map = <String, dynamic>{};
 
   @override
   void _update(Map<String, dynamic> map, bool mapIsRef) {
