有没有一个Java等价于Python的简单字符串拼接？

Question

好吧，我想知道的是，有一种方法可以用Java来完成Python在下面所能做的。。。

string_sample = "hello world"

string_sample[:-1]
>>> "hello world"

string_sample[-1]
>>> "d"

string_sample[3]
>>> "l"

因为在我看来，Java让你为同样的结果工作（我特别擅长每次使用2个数字，而缺少-1来表示最后一个字符）

String string_sample = "hello world";

string_sample.substring(0,string_sample.length()-1);
>>> "hello world"

string_sample.substringstring_sample.length()];
>>> "d"

string_sample.(3,4);
>>> "l"

我还没有接触到Java中的数组/列表，所以我真的希望Java有比这更简单的东西

编辑：将字符串样本[3]的“i”改为“l”。有斑点的马龙！

Answer 1

抱歉，Java的substring不如Python的切片表示法灵活。

特别是：

• 你可以给它一个开始，或者一个开始和结束，但不只是一个结束。（同样，没有台阶，但你不会错过那么多。）
• 负索引是一个错误，而不是从结尾开始的计数。

你可以看到文档here。

不过，自己写这篇文章一点也不难：

public String slice_start(String s, int startIndex) {
    if (startIndex < 0) startIndex = s.length() + startIndex;
    return s.substring(startIndex);
}

public String slice_end(String s, int endIndex) {
    if (endIndex < 0) endIndex = s.length() + endIndex;
    return s.substring(0, endIndex);
}

public String slice_range(String s, int startIndex, int endIndex) {
    if (startIndex < 0) startIndex = s.length() + startIndex;
    if (endIndex < 0) endIndex = s.length() + endIndex;
    return s.substring(startIndex, endIndex);
}

把它们作为某个实用程序类的静态方法。

显然这与Python并不完全相同，但它可能处理您想要的所有情况，而且非常简单。如果您想处理其他边缘情况（包括step和传递切片等），可以添加任何您想要的附加代码；这些都不是特别复杂的。

---

其他序列基本上是相同的，但是在这里您需要的是subSequence，而不是substring。（也可以对字符串使用subSequence，因为String是CharSequence。）

数组实际上根本不是一种序列类型；您需要编写代码，显式地创建一个新数组并复制子数组。但还是没那么复杂。

---

请注意，您可能希望查找已经为您完成此操作的库。此页上至少有三个链接在其他答案中，这将使您的搜索更容易。：）（您可能还想自己做一次，只是为了了解这些库是如何工作的，但是对于生产代码，我宁愿使用一个库，在这个库中，其他人已经发现并测试了所有的边缘情况，而不是在单元测试或现场错误时重新实现控制盘并处理它们……）

Answer 2

Apache ^{}对此有一些支持in StringUtils：

Gets a substring from the specified String avoiding exceptions.

A negative start position can be used to start n characters from the end of the String

不过，您仍然需要使用显式的开始索引。

Answer 3

Java Boon切片表示法允许所有这一切，并带有字符串、列表、集合、映射等

许多语言都有切片符号（Ruby、Groovy和Python）。Boon将此添加到Java中。

Boon有三个slc操作符：slc，slc（仅限启动）和slcEnd。

使用Boon，您可以对字符串、数组（基元和泛型）、列表、集合、树集合、树映射等进行切片。

切片符号-温和的介绍

boon slice运算符的工作方式与Python/Ruby slice表示法类似：

红宝石切片符号

 arr = [1, 2, 3, 4, 5, 6]
 arr[2]    #=> 3
 arr[-3]   #=> 4
 arr[2, 3] #=> [3, 4, 5]
 arr[1..4] #=> [2, 3, 4, 5]

Python切片表示法

string = "foo bar" 
string [0:3]  #'foo'
string [-3:7] #'bar'

以下内容来自于对Python切片表示法的出色描述：

切片标记的基本原理如下：

Python切片表示法

     a[ index ]       # index of item
     a[ start : end ] # items start through end-1
     a[ start : ]     # items start through the rest of the array
     a[ : end ]       # items from the beginning through end-1
     a[ : ]           # a copy of the whole array

使用Boon的Java切片表示法：

      idx( index )         // index of item
      slc( a, start, end ) // items start through end-1
      slc( a, start )      // items start through the rest of the array
      slcEnd( a, end )     // items from the beginning through end-1
      copy( a )            // a copy of the whole array

slc表示切片 idx表示索引 slcEnd表示结束切片。 copy代表好的，嗯，当然是copy

要记住的关键点是，结束值表示不在选定切片中的第一个值。因此，结束和开始之间的区别在于所选元素的数量。 另一个特性是start或end可以是负数，这意味着它从数组的末尾而不是开头开始计数。

因此：

带负索引的Python切片表示法

         a[ -1 ]    # last item in the array
         a[ -2: ]   # last two items in the array
         a[ :-2 ]   # everything except the last two items

Java负索引

         idx   ( a, -1)     // last item in the array
         slc   ( -2 )       // last two items in the array
         slcEnd( -2 )       // everything except the last two items

Python和Boon对程序员很好，如果项目比您要求的要少：Python不允许您越界，如果您这么做，它会返回一个空列表。Boon遵循这一传统，但提供了一个选项来获取越界的异常（稍后介绍）。在Python和Boon中，如果你走远了，就得到长度，如果你试图在0以下，就得到0（计算后在0以下）。相反，Ruby给你一个空指针（Nil）。Boon复制Python样式，因为Boon的目标之一是避免返回null（您会得到一个异常，Option）。（Boon有第二个名为zlc的运算符，它抛出了一个越界索引异常，但大多数人应该使用slc。）

例如，如果您要求slcEnd（a，-2）（a[：-2]），而a只包含一个元素，则会得到一个空列表而不是一个错误。有时候你更喜欢这个错误，有了Boon你就有了这个选择。

更多切片

下面是一些基本的Java类型、列表、数组、蔬菜、原始字符数组和原始字节数组。

在Boon中声明要使用的变量

//Boon works with lists, arrays, sets, maps, sorted maps, etc.
List<String> fruitList;
String [] fruitArray;
Set<String> veggiesSet;
char [] letters;
byte [] bytes;
NavigableMap <Integer, String> favoritesMap;
Map<String, Integer> map;

//In Java a TreeMap is a SortedMap and a NavigableMap by the way.

Boon附带了helper方法，允许您轻松创建列表、集合、映射、并发映射、排序的映射、排序的集合等。helper方法有safeList、list、set、sortedSet、safeSet、safeSortedSet等。其思想是让Java感觉更像list和maps是内置类型的。

初始化集合、列表、字符串数组、字符数组和字节数组

veggiesSet  =  set( "salad", "broccoli", "spinach");
fruitList   =  list( "apple", "oranges", "pineapple");
fruitArray  =  array( "apple", "oranges", "pineapple");
letters     =  array( 'a', 'b', 'c');
bytes       =  array( new byte[]{0x1, 0x2, 0x3, 0x4});

甚至还有创建映射和排序映射的方法，称为map、sortedMap、safeMap（concurrent）和sortedSafeMap（concurrent）。创建它们的主要原因是Java没有用于列表、映射等的文本

Java：使用map操作符生成SortedMap和map

 favoritesMap = sortedMap(
      2, "pineapple",
      1, "oranges",
      3, "apple"
 );


 map =    map (
    "pineapple",  2,
    "oranges",    1,
    "apple",      3
 );

您可以使用idx运算符索引映射、列表、数组等。

Java：使用Boon Java idx运算符获取索引处的值

 //Using idx to access a value.

 assert idx( veggiesSet, "b").equals("broccoli");

 assert idx( fruitList, 1 ).equals("oranges");

 assert idx( fruitArray, 1 ).equals("oranges");

 assert idx( letters, 1 ) == 'b';

 assert idx( bytes, 1 )      == 0x2;

 assert idx( favoritesMap, 2 ).equals("pineapple");

 assert idx( map, "pineapple" )  == 2;

idx操作符也可以处理负索引。

Java:使用带负值的idx运算符

         //Negative indexes

          assert idx( fruitList, -2 ).equals("oranges");

          assert idx( fruitArray, -2 ).equals("oranges");

          assert idx( letters, -2 ) == 'b';

          assert idx( bytes, -3 )   == 0x2;

Ruby、Groovy和Python都有这个特性。现在你也可以在Java中使用它了！Java版本（Boon）与基元数组一起工作，因此您不会自动装箱。

Ruby和Python做的事情没有用于sortedset和sortedmap的is切片表示法。 可以使用切片表示法在Java中搜索排序的映射和排序的集

切片标记适用于已排序的地图和已排序的集。

下面是一个将几个概念组合在一起的示例。

          set = sortedSet("apple", "kiwi", "oranges", "pears", "pineapple")

          slcEnd( set, "o" )      //returns ("oranges", "pears", "pineapple")
          slc( set, "ap", "o" )   //returns ("apple", "kiwi"),
          slc( set, "o" )         //returns ("apple", "kiwi")

您实际上是在对已排序的映射进行切片，而已排序的集是排序之间的查询。 “pi”后面是什么？

          after(set, "pi") //pineapple

在菠萝之前呢？

          before(set, "pi")

好吧，让我们一步一步来。。。。

  NavigableSet<String> set =
          sortedSet("apple", "kiwi", "oranges", "pears", "pineapple");

  assertEquals(

          "oranges", idx(set, "ora")

  );

记住：TreeSet实现NavigableSet和SortedSet。

这是从我的博客。。。。

http://rick-hightower.blogspot.com/2013/10/java-slice-notation-to-split-up-strings.html

还有更多的例子。

我从这个关于Python切片的讨论中得到了一些措辞。

Explain Python's slice notation

以下是Boon项目链接：

https://github.com/RichardHightower/boon

现在让我们继续切！

我们可以使用以下命令查找以“o”开头的集合中的第一个水果：

idx(set, "o")

这是我们之前制作的一套水果（一套是有“苹果”、“猕猴桃”的树）， “橘子”，“梨”，“菠萝”在里面）。

      assertEquals(

          "oranges", idx(set, "o")

      );

我们找到橘子了！

这又是一次，但这一次我们正在寻找以“p”开头的水果，即idx（set，“p”）。

      assertEquals(
          "pears",
          idx(set, "p")
      );

是啊！我们找到梨了！

以“圆周率”开头的水果怎么样，比如“菠萝”-idx（set，“圆周率”）

  assertEquals(
          "pineapple",
          idx(set, "pi")
  );

你也可以要求在另一个项目之后的项目。“pi”后面是什么？ 之后（设置为“pi”）

  assertEquals(

          "pineapple",
          after(set, "pi")

  );

“菠萝”在“π”之后。顺便说一下，after和idx是一样的。那我为什么要加一个after呢？所以我可以有一个以前！！！:) 如果你想知道“π”之前是什么呢？

之前（设置“pi”）

  assertEquals(

          "pears",
          before(set, "pi")

  );

所有介于“ap”和“o”之间的水果怎么样？正如我所承诺的，有切片符号！

slc（设置，“ap”，“o”）

  assertEquals(

          sortedSet("apple", "kiwi"),
          slc(set, "ap", "o")

  );

“o”之后的水果怎么样？

slc（设置“o”）

  assertEquals(

          sortedSet("apple", "kiwi"),
          slc(set, "o")

  );

所以“o”后面的水果都是“苹果”和“猕猴桃”。

到“o”为止的水果怎么样？（当我切下末端时，斯莱森德读到了。）

slcEnd（设置“o”）

  assertEquals(

          sortedSet("oranges", "pears", "pineapple"),
          slcEnd(set, "o")
  );

所以所有的水果包括“o”都是“橘子”、“梨”和“菠萝”。

为类似列表的东西进行安全切片

如果索引超出界限，这些运算符将引发异常：

使用Boon的Java切片表示法如下：

      ix( index )         // index of item
      zlc( a, start, end ) // items start through end-1
      zlc( a, start )      // items start through the rest of the array
      zlcEnd( a, end )     // items from the beginning through end-1

zlc表示零公差片 ix表示零公差指数 zlcEnd表示零公差端片。 copy代表好的，嗯，当然是copy

男孩和女孩。。。记住要对你不知道的东西进行安全切片。

也适用于原语，因此没有自动装箱

索引基元

 byte[] letters =
      array((byte)'a', (byte)'b', (byte)'c', (byte)'d');

 assertEquals(
      'a',
      idx(letters, 0)
 );


 assertEquals(
      'd',
      idx(letters, -1)
 );


 assertEquals(
      'd',
      idx(letters, letters.length - 1)
 );

 idx(letters, 1, (byte)'z');

 assertEquals(
      (byte)'z',
      idx(letters, 1)
 );

len和idx方法是通用运算符，它们处理列表、数组、集合、映射等

len给我数组、列表、映射的长度。 idx在数组like、list like、map like中的“index”位置给我项。

主控字符串切片！

下面是Boon Java字符串切片的一些示例

  String letters = "abcd";

  boolean worked = true;

  worked &=

          idx(letters, 0)  == 'a'
                  || die("0 index is equal to a");



  worked &=

          idx(letters, -1)  == 'd'
                  || die("-1 index is equal to a");

另一种表示idx（letters，-1）=“d”的方法是idx（letters，letters.length（）-1）=“d”！ 我喜欢较短的路！

  worked &=

          idx(letters, letters.length() - 1) == 'd'
                   || die("another way to express what the -1 means");


  //We can modify too
  letters = idx(letters, 1, 'z');

  worked &=

          idx(letters, 1) == 'z'
                  || die("Set the 1 index of letters to 'z'");


  worked &= (
          in('a', letters) &&
          in('z', letters)
  ) || die("'z' is in letters and 'a' is in letters");

切片切片宝贝！

  letters = "abcd";

  worked &=
          slc(letters, 0, 2).equals("ab")
              || die("index 0 through index 2 is equal to 'ab'");



  worked &=
          slc(letters, 1, -1).equals("bc")
                  || die("index 1 through index (length -1) is equal to 'bc'");


  worked &=
          slcEnd(letters, -2).equals("ab")
                  || die("Slice of the end of the string!");


  worked &=
          slcEnd(letters, 2).equals("ab")
                  || die("Vanilla Slice Slice baby!");

穿上我的5.0，把我的抹布上衣拿下来，这样我的头发就可以吹了！切片宝贝！！！