以上就是给各位分享如果我在Java中省略花括号可以吗？，其中也会对java省略this进行解释，同时本文还将给你拓展2023-07-13：如果你熟悉Shell编程，那么一定了解过花括号展开，它可以用来

以上就是给各位分享如果我在Java中省略花括号可以吗？，其中也会对java省略this进行解释，同时本文还将给你拓展2023-07-13：如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。 花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串 定义下面几条语、c – 如果我在清楚的情况下使用指针,编译器可以内联虚函数吗？、java - 在java中使用snakeyaml写入yaml时，我可以只删除大括号吗、JavaScript使用“ new”运算符创建对象时，我们可以省略括号吗？等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

• 如果我在Java中省略花括号可以吗？（java省略this）
• 2023-07-13：如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。 花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串 定义下面几条语
• c – 如果我在清楚的情况下使用指针,编译器可以内联虚函数吗？
• java - 在java中使用snakeyaml写入yaml时，我可以只删除大括号吗
• JavaScript使用“ new”运算符创建对象时，我们可以省略括号吗？

如果我在Java中省略花括号可以吗？（java省略this）

我已经搜索过了，但是找不到答案，无论出于什么原因，我都感到羞耻，无法问教授，因为那种感觉当成千上万的人盯着你看时…

无论如何，我的问题是使用括号的重要性是什么？如果我省略它们可以吗？例：

for (int i = 0; i < size; i++)  {   a += b;}

与

for (int i = 0; i < size; i++)   a += b;

我知道它们都可以使用，但是如果省略括号（由于能见度，我倾向于做很多事情）会改变任何东西吗？正如我说的，我知道它有效，我测试了数十次，但是现在我的一些单项作业越来越大，出于某种原因，我出于非理性的恐惧，从长远来看，这会引起一些问题吗？有理由担心吗？

答案1

除了代码的可维护性之外，它根本不会改变任何东西。我看过这样的代码：

for (int i = 0; i < size; i++)   a += b;   System.out.println("foo");这意味着：for (int i = 0; i < size; i++)   a += b;System.out.println("foo");

…但是应该是这样的：

for (int i = 0; i < size; i++) {   a += b;   System.out.println("foo");}

我个人总是将方括号括起来，以减少在阅读或修改代码时造成混淆的可能性。

我工作过的每家公司的编码约定都要求这样做-并不是说其他​​一些公司没有不同的约定…

以防万一，您认为这永远不会有所作为：我不得不修复一次错误，该错误与上面的代码相当。很难发现……（诚然，这是几年前，在我开始进行单元测试之前，毫无疑问，这使诊断变得更加容易）。

2023-07-13：如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。 花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串 定义下面几条语

2023-07-13：如果你熟悉 Shell 编程，那么一定了解过花括号展开，它可以用来生成任意字符串。

花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串

定义下面几条语法规则：

如果只给出单一的元素 x，那么表达式表示的字符串就只有 "x"。R (x) = {x}

例如，表达式 "a" 表示字符串 "a"。

而表达式 "w" 就表示字符串 "w"。

当两个或多个表达式并列，以逗号分隔，我们取这些表达式中元素的并集

R({e_1,e_2,...}) = R(e_1) ∪ R(e_2) ∪ ...

例如，表达式 "{a,b,c}" 表示字符串 "a","b","c"。

而表达式 "{{a,b},{b,c}}" 也可以表示字符串 "a","b","c"。

要是两个或多个表达式相接，中间没有隔开时，

我们从这些表达式中各取一个元素依次连接形成字符串

R(e_1 + e_2) = {a + b for (a, b) in R(e_1) × R(e_2)}

例如，表达式 "{a,b}{c,d}" 表示字符串 "ac","ad","bc","bd"。

表达式之间允许嵌套，单一元素与表达式的连接也是允许的。

例如，表达式 "a {b,c,d}" 表示字符串 "ab","ac","ad"​​​​​​。

例如，表达式 "a {b,c}{d,e} f {g,h}"

可以表示字符串 :

"abdfg", "abdfh", "abefg", "abefh",

"acdfg", "acdfh", "acefg", "acefh"。

给出表示基于给定语法规则的表达式 expression。

返回它所表示的所有字符串组成的有序列表。

输入：expression = "{a,b}{c,{d,e}}"。

输出：["ac","ad","ae","bc","bd","be"]。

答案 2023-07-13：

大体步骤如下：

1. 定义了一个结构体 Info，其中包含一个 treeset.Set 类型的指针 ans 和一个整数 end。

2. 定义了一个 NewInfo 函数，用于初始化 Info 对象。

3. 定义了 braceExpansionII 函数，接收一个表示表达式的字符串，并返回展开后的字符串列表。

4.process 函数是实际处理展开过程的核心函数，它接收一个表示表达式的字符数组 exp 和一个起始索引 start，返回一个 Info 对象。

5. 在 process 函数中，创建了一个空的 treeset.Set 对象 ans 和一个空的 []*treeset.Set 切片 parts。

6. 使用 strings.Builder 创建了一个字符串构建器 builder。

7. 在循环中，依次遍历 exp 中的字符，直到遇到 } 或到达字符串末尾为止。

8. 如果当前字符为 {，则调用 addStringToParts 函数将构建器中的字符串添加到 parts 中，并递归调用 process 函数处理 {} 内部的表达式，将返回的 ans 添加到 parts 中，并更新起始索引 start。

9. 如果当前字符为 ,，则调用 addStringToParts 函数将构建器中的字符串添加到 parts 中，并将 parts 中的所有集合添加到 ans 中，然后清空 parts，并更新起始索引 start。

10. 如果当前字符为小写英文字母，则将其添加到构建器中。

11. 循环结束后，调用 addStringToParts 函数将构建器中的最后一个字符串添加到 parts 中。

12. 调用 addPartsToSet 函数将 parts 中的所有集合添加到 ans 中。

13. 返回包含 ans 和起始索引 start 的 Info 对象。

14.addStringToParts 函数将构建器中的字符串添加到 parts 中，如果构建器不为空，则创建一个新的 treeset.Set 对象，并将字符串添加到集合中，再将集合添加到 parts 中。

15.addPartsToSet 函数将 parts 中的所有集合进行组合并添加到 ans 中。

16.processParts 函数是递归处理 parts 切片的核心函数。如果索引 i 等于 parts 的长度，则表示已经处理完所有集合，将连接后的字符串添加到 ans 中。否则，取出当前集合，遍历集合中的每个元素，与 path 进行连接，并递归调用 processParts 处理下一个集合。

17.toSlice 函数将 ans 中的元素转换为有序字符串切片，并返回该切片。

18. 在 main 函数中，定义了一个表达式字符串 expression，并调用 braceExpansionII 函数对表达式进行展开，并将结果打印输出。

该代码的时间复杂度为 $O (N^M)$，其中 N 为表达式中的字符数，M 为展开括号的深度。具体来说，代码中的核心函数 process 通过遍历表达式字符并进行递归处理，每次递归都会将问题规模缩小，直到达到展开括号的最深层级。因此，时间复杂度取决于表达式中字符的数量以及展开括号的深度。

空间复杂度是 $O (N^M)$，其中 N 为表达式中的字符数，M 为展开括号的深度。在代码执行过程中，会创建一些辅助数据结构，如字符串构建器和集合。对于集合这种动态数据结构，其占用的内存空间与展开括号的深度呈指数关系。而字符串构建器的空间复杂度与表达式中字符的数量成线性关系。因此，最终的空间复杂度取决于展开括号的深度和表达式中字符的数量，即 $O (N^M)$。

go 完整代码如下：

package main

import (
	"fmt"
	"strings"

	"github.com/emirpasic/gods/sets/treeset"
)

type Info struct {
	ans *treeset.Set
	end int
}

func NewInfo(a *treeset.Set, e int) *Info {
	ans := &Info{}
	ans.ans = a
	ans.end = e
	return ans
}

func braceExpansionII(expression string) []string {
	ans := process([]rune(expression), 0).ans
	return toSlice(ans)
}

func process(exp []rune, start int) *Info {
	ans := treeset.NewWith(func(a, b interface{}) int {
		aa := a.(string)
		bb := b.(string)
		if aa < bb {
			return -1
		} else if aa == bb {
			return 0
		} else {
			return 1
		}
	})
	parts := make([]*treeset.Set, 0)
	builder := strings.Builder{}

	for start < len(exp) && exp[start] != ''}'' {
		if exp[start] == ''{'' {
			addStringToParts(&builder, &parts)
			next := process(exp, start+1)
			parts = append(parts, next.ans)
			start = next.end + 1
		} else if exp[start] == '','' {
			addStringToParts(&builder, &parts)
			addPartsToSet(ans, &parts)
			start++
			parts = make([]*treeset.Set, 0)
		} else {
			builder.WriteRune(exp[start])
			start++
		}
	}

	addStringToParts(&builder, &parts)
	addPartsToSet(ans, &parts)
	return &Info{ans, start}
}

func addStringToParts(builder *strings.Builder, parts *[]*treeset.Set) {
	if builder.Len() != 0 {
		s := treeset.NewWithStringComparator()
		s.Add(builder.String())
		*parts = append(*parts, s)
		builder.Reset()
	}
}

func addPartsToSet(ans *treeset.Set, parts *[]*treeset.Set) {
	processParts(parts, 0, "", ans)
}

func processParts(parts *[]*treeset.Set, i int, path string, ans *treeset.Set) {
	if i == len(*parts) {
		if path != "" {
			ans.Add(path)
		}
	} else {
		part := (*parts)[i]
		it := part.Iterator()
		for it.Next() {
			cur := it.Value().(string)
			processParts(parts, i+1, path+cur, ans)
		}
	}
}

func toSlice(set *treeset.Set) []string {
	slice := make([]string, 0)
	it := set.Iterator()
	for it.Next() {
		slice = append(slice, it.Value().(string))
	}
	return slice
}

func main() {
	expression := "{a,b}{c,{d,e}}"
	result := braceExpansionII(expression)
	fmt.Println(result)
}

c – 如果我在清楚的情况下使用指针,编译器可以内联虚函数吗？

B* b = new B;

b->doSth();

// main1.cpp
struct A {
  virtual void f();
};

struct B : A { 
  virtual void f();
};

void g() {
  A *a = new A;
  a->f();

  a = new B;
  a->f();
}

// clang -O2 -S -emit-llvm -o - main1.cpp | c++filt
// ...
define void @g()() {
  %1 = tail call noalias i8* @operator new(unsigned int)(i32 4)
  %2 = bitcast i8* %1 to %struct.A*
  %3 = bitcast i8* %1 to i32 (...)***
  store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @vtable for A,i32 0,i32 2) to i32 (...)**),i32 (...)*** %3,align 4
  tail call void @A::f()(%struct.A* %2)
  %4 = tail call noalias i8* @operator new(unsigned int)(i32 4)
  %5 = bitcast i8* %4 to i32 (...)***
  store i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*]* @vtable for B,i32 (...)*** %5,align 4
  %tmp = bitcast i8* %4 to %struct.B*
  tail call void @B::f()(%struct.B* %tmp)
  ret void
}
// ...

java - 在java中使用snakeyaml写入yaml时，我可以只删除大括号吗

root:
  nested_object1:
    mapping:
    - [element1,element2]
    - [element1,element2]
    test: {
       obj1: true,obj2: true,obj3: false
    }

root:
 nested_object1:
    mapping:
    - [element1,element2]
    test:
       obj1: true
       obj2: true
       obj3: false
    

const obj = new Foo;

const obj = new Foo();