Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8046176

JEP 186: Collection Literals

    XMLWordPrintable

    Details

    • Type: JEP
    • Status: Draft
    • Priority: P4
    • Resolution: Unresolved
    • Fix Version/s: None
    • Component/s: specification
    • Labels:
      None
    • Author:
      Brian Goetz
    • JEP Type:
      Feature
    • Exposure:
      Open
    • Subcomponent:
    • Scope:
      JDK
    • Discussion:
      lambda dash dev at openjdk dot java dot net
    • Effort:
      S
    • Duration:
      S
    • JEP Number:
      186

      Description

      Summary

      A collection literal is a syntactic expression form that evaluates to an aggregate type, such as an array, List, or Map. Many languages support collection literals. A List literal in Java might look like:

      List<Integer> list = #[ 1, 2, 3 ];

      Collection literals were proposed for Project Coin and naturally complement the library additions in Java SE 8. Collection literals can reduce boilerplate code, improve performance, and increase safety.

      Goals

      This is a research JEP. The sole goal of this JEP is to explore the design space sufficiently to be able to propose a feature JEP (or recommend that the feature not be pursued.)

      Non-Goals

      It is not a goal of this research JEP to produce a production-ready implementation or specification.

      Success Metrics

      This research JEP will be judged successful if it produces a design that we wish to move forward to a feature JEP, or else certainty that we do not wish to proceed with this feature.

      Motivation

      Collection literals can increase programmer productivity, code readability, and code safety.

      Description

      Being able to initialize arrays, lists, sets, and maps with a compact expression offers many benefits, including:

      • Clarity (smaller, simpler code);
      • Dynamic footprint (the size is known, so a space-efficient implementation can be chosen); and
      • Safety (the resulting object can be made immutable).

      While a minimal solution that works for arrays, Lists, and Maps would be "trivial", we would like to explore beyond such a simple-minded solution, leveraging target typing and which might enable an extensible set of types to exploit this feature.

        Attachments

          Issue Links

            Activity

              People

              Assignee:
              briangoetz Brian Goetz
              Reporter:
              briangoetz Brian Goetz
              Owner:
              Brian Goetz Brian Goetz
              Votes:
              0 Vote for this issue
              Watchers:
              4 Start watching this issue

                Dates

                Created:
                Updated: