为什么要集合文字？

Question

从有关 Java 7 的各种在线文章中，我了解到 Java 7 将具有如下所示的集合文字¹：

List<String> fruits = [ "Apple", "Mango", "Guava" ];
Set<String> flowers = { "Rose", "Daisy", "Chrysanthemum" };
Map<Integer, String> hindiNums = { 1 : "Ek", 2 : "Do", 3 : "Teen" }; 

我的问题是：

1. 是否可以提供静态方法<所有集合类中的 code>of 可以按如下方式使用：

List; Fruits = ArrayList.of("Apple", "Mango", "Guava");

在我看来，这看起来和字面版本一样好，而且也相当简洁。那么为什么他们必须发明一种新语法（编辑：“新”我的意思是“Java 的新语法”。）？

2. 当我说 List时Fruits = [ "Apple", "Mango", "Guava" ]; 我实际上会得到什么List？它会是 ArrayList 或 LinkedList 还是其他东西？

---

¹ 正如评论中所指出的，集合文字没有符合 Java 7，也没有符合 Java 8。（这是一个 来自 Oracle 开发人员 Brian Goetz 的电子邮件，总结了不包含此功能的理由；以及这是提案本身。）

Answer 1

语言设计是一个品味问题。话虽如此，这种列表/对象初始化已经变得非常流行。例如，C# 也有几乎相同的东西。语法非常灵活，甚至正如您的示例所示，可以让您初始化诸如内联字典之类的东西。我更喜欢设计师在这里选择的语法。

Answer 2

IMO 这只是一个语法糖，稍微简化了代码。为什么你对同类的糖不感到惊讶：

int []arr1 = new int[] {1,2,3};
int []arr2 = {1,2,3};

它只是表达简单想法的一种便捷方式，而不是写这样的东西

int []arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

：这会给我们的生活带来真正新的东西吗？嗯，不。它会让我们的生活变得更轻松吗？我想，是的。

关于问题的第二部分，我不知道实际类型是什么。但坦率地说，您多久关心一次集合实现是什么？特别是考虑到此类集合预计相对较小（所有值均由开发人员键入）。无论如何，在极少数情况下，当您确实关心时，请不要使用这种简化的语法并自己完成这项工作。

Answer 3

它并不是全新的语法，因为此类文字存在于 Python、Javascript (json) 和可能的其他语言中。

坦白说，我还没有看到任何关于 java 7 的信息（最近主要关注 C++ 和 Javascript），但看到这种语言的这样一个补充实际上是很好的。

Answer 4

只是为了澄清一点 - 他们没有“发明新语法”。

我不是 100% 确定最初的想法来自哪里，但使用“[]”表示列表，使用“{}”表示 Perl 中存在的映射（其中这些映射用于构建数组引用和哈希引用）。

严格来说，perl 中没有“集合”，但集合最惯用的实现是映射（将集合成员映射为 1），因此“{}”也适合。

所以 Perl 会说与你列出的完全相同的事情：

$fruits = [ "Apple", "Mango", "Guava" ]; # Creates array reference
$flowers = { "Rose" => 1, "Daisy" => 1, "Chrysanthemum" => 1 };
     # or { map {$_=>1} ("Rose", "Daisy", "Chrysanthemum"))
$hindiNums = { 1 => "Ek", 2 => "Do", 3 => "Teen" }; 

当然，我并不是说上面的内容来自 Perl，但它与至少一种其他语言一致，因此可能具有更广泛的用途。

Answer 5

你是对的，这只是空洞的语法糖。

另外，您的 ArrayList.of(...) 只是 new ArrayList<...>(Arrays.asList(...)) 的简写

Answer 6

我认为原因之一是，如果您尝试用通用对象的实例填充它，of( ... ) 将生成一个未检查警告。

原因是 ... 扩展为 java 数组，而 java 数组不喜欢泛型实例。

以下是规范中处理此特定问题的示例：

List<List<Integer>> pascalsTriangle =
    [[1],
     [1, 1],
     [1, 2, 1],
     [1, 3, 3, 1],
     [1, 4, 6, 4, 1]]

目前无法以这种简洁的方式初始化此变量，并且不会出现未检查警告。

Answer 7

问题 2 的答案：

final List<Integer> piDigits = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9];

为您提供一个不可变列表。

该提案的整体思想是子类型不能被指定。编译器根据右侧的集合选择合适的实现。

请阅读此处的详细信息：提案：集合文字

回答问题1：是的。这是风格问题。

Answer 8

另一件需要注意的事情是，对于列表来说，使用 var args 非常容易，但是稍微考虑一下如何为地图做这件事。除非引入额外的 Map.Entry 对象或类似的东西，否则无法向 var args 方法提供参数对。

因此，使用现有的语法，您最终会

Map<String,String> map = HashMap.of( new Entry( "key1", "value1" ), 
                                     new Entry( "key2", "value2" ) );

很快变得非常疲惫。

即使您走上使用构建器模式的道路（就像我们所做的那样），它也是相当难看的

Map<String,String> map = CollectionUtil.<String,String>map()
                                        .put( "key1", "value1" )
                                        .put( "key2", "value2" )
                                        .map();

Answer 9

上面没有提到的是集合的集合的简单性。假设您想要一个常量来存储不同国家的货币名称和价值。

// Currency devisions by country, and their various names
Map<String,Map<Float,List<String>>> CURRENCIES =
    { "US" : { 1 : ["dollar","buck"],
               0.25 : ["quarter"],
               0.10 : ["dime"],
               0.05 : ["nickel"],
               0.01 : ["penny"] },
      "UK" : { 1 : ["pound"],
               1.05 ["guinea"],
               0.125 : ["half crown"],
               0.05 : ["shilling","bob"],
               0.025 : ["sixpence"] } 
    };

我将大量数据打包在十二行极其清晰的行中。如果我使用 ArrayList.of（十次）和一些类似的映射构造函数（四次，使用十个 Map.EntryPair！），函数调用会使代码变得臃肿并使其难以阅读。

虽然它绝对属于语法糖领域，但这是我在 Java 7 中期待的 #1 功能（如果它出现的话）。

Answer 10

A1 是的，这是可能的，但需要您输入越来越多的内容。

虽然这本质上并不是错误的，但它是开发人员抱怨最多的事情之一。他们（有时我自己也这么认为）觉得 Java 太冗长了。

随着硬件变得越来越快，一开始执行计算成本太高的新编程语言变得可行，现在它们被越来越多地使用并且非常流行。当开发人员必须再次输入 Java 时，他们会感觉，哦不：，public static void main 再次！之类的。

Java（以及一般的静态类型语言）必须提高执行速度的事情之一是在运行之前（即编译阶段）执行尽可能多的验证

这些新的编程语言（值得注意的是，Python 和 Ruby）使编程变得很有趣，因为您只需输入更少的内容即可实现相同的效果。

Java 对此的反应是使语言变得更大并将一些“语法糖”合并到语言中，这就是原因。

即使像 C# 这样的编程语言也具有这些扩展功能（我想到的是属性），可以减少开发人员的代码量。

最后，我认为这些添加对语言有利，但必须非常小心地添加它们，以避免破坏兼容性和/或创建一种太大的语言，以至于没有人可以使用它。

我认为另一种选择是让方法的名称更具表现力，但这对于 Java 来说非常复杂。也许用一种新的语言:)。

Map put 方法签名可能是这样的：

 /**
  * Analog to put( Object k, Object v );
  */
 public [( Object = k )]=( Object  v ) {
 } 

允许方法名称为： [(key)]=(value) 并最终省略括号（就像在 Ruby 中或最初在 Smalltalk 中一样），所以这样方法将是：

 Map map = ....
 map.["name"]="Oscar";

由于这是不可能的（因为 []= 不是有效的方法标识符）并且写作：

 map.put("name","Oscar");

是... mmhh 太冗长了，他们决定添加此解决方案。

另一个增强功能是数字文字，因此您将能够键入：

 int million = 1_000_000;

A2 ：您将得到其他内容。

A3（扩展我对kloffy答案的评论）。

从今天开始，您可以用 Java 编写相同的代码。

如果 Stage、Scente、Group、Text、ImageView、Image 是现有的 Java 类，您可以输入：

 new Stage() {{
     title  =  "Group-Nodes-Transformation";
     scene  =  new Scene() {{
         width =  600;
         height = 600;
         content = new Group() {{
             content = new Object[] =  {
                 new Circle() {{
                     centerX = 300;
                     centerY = 300;
                     radius = 250;
                     fill = Color.WHITE;
                     stroke = Color.BLACK;
                 }},
                 new Text() {{
                     x = 300;
                     y = 300;
                     content = "Mr. Duke";
                 }},
                 new ImageView() {{
                     image = new  Image() {{
                         url = "D:\\TEST\\Documents\\duke.png"
                         width = 50;
                         height = 50;
                     }};
                 }};
             };
         }};
     }};
 }};

Answer 11

他们可能受到 JavaFX 声明式编程风格的启发。然而，如果是这样的话，我很失望他们没有全力支持对象文字。下面是 JavaFX 中对象文字的示例：

Stage {
    title: "Group-Nodes-Transformation"
    scene: Scene {
        width: 600
        height: 600
        content: Group {
            content: [
                Circle {
                    centerX: 300
                    centerY: 300
                    radius: 250
                    fill: Color.WHITE
                    stroke: Color.BLACK
                },
                Text {
                    x: 300
                    y: 300
                    content: "Mr. Duke"
                },
                ImageView {
                    image: Image {
                        url: "D:\\TEST\\Documents\\duke.png"
                        width:50
                        height:50
                    }
                }
            ]
        }
    }
}

我认为这种编程风格肯定适合某些应用程序领域。归根结底，这始终是一个品味问题......