有没有一个Java相当于Python的Easy String Splicing？

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

特别：

• 你可以给它一个开始，或者一个开始和结束，但不仅仅是一个结束。（另外，没有步骤，但你不会错过那么多。
• 负指数是一个错误，而不是从末尾开始的计数。

您可以在此处查看文档。

但是，自己写这个并不难：

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并不完全相同，但它可能可以处理您想要的所有情况，并且非常简单。如果你想处理其他边缘情况（包括步骤和传递切片等），你可以添加任何你想要的额外代码;没有一个是特别棘手的。

其他序列基本上是相同的，但是您将需要而不是 .（您也可以在字符串上使用，因为 a 是 .）subSequencesubstringsubSequenceStringCharSequence

数组实际上根本不是一种序列;您需要编写显式创建新数组并复制子数组的代码。但它仍然没有复杂得多。

请注意，您可能希望查找已经为您完成此操作的库。此页面上至少有三个链接的其他答案，这应该使您的搜索变得容易。:)（你可能仍然想自己做一次，只是为了了解这些库是如何工作的 -但是对于生产代码，我宁愿使用其他人已经弄清楚并测试了所有边缘情况的库，而不是重新实现轮子并在它们被单元测试或现场错误捕获时处理它们......）

Java Boon Slice Notation允许所有这些，并且带有字符串，列表，集，映射等。

许多语言都有切片表示法（Ruby，Groovy和Python）。Boon将此添加到Java中。

Boon 有三个 slc 运算符：slc、slc（仅启动）和 slcEnd。

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

切片符号 - 温和的介绍

boon 切片运算符的工作方式类似于 Python/Ruby 切片表示法：

红宝石切片表示法

 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 Slice Notation

     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 Slice Notation：

      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 代表结束切片。复制代表好，错误，嗯复制当然

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

因此：

具有负索引的 Python 切片表示法

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

爪哇负指数

         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类型，列表，数组，蔬菜，基元char数组和基元字节数组。

声明要在 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附带了帮助器方法，可让您轻松创建列表，集，映射，并发映射，排序映射，排序集等。帮助器方法是 safeList、list、set、sortedSet、safeSet、safeSortedSet 等。这个想法是让Java感觉更像是列表和地图是内置于一类的。

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

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（并发）和sortedSafeMap（并发）。这些主要是因为Java没有用于列表，映射等的文字。

Java：使用映射运算符生成排序的映射和映射

 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没有的东西是SortedSets和SortedMaps的切片符号。您可以使用切片表示法在 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切片的讨论中得出了一些措辞。

解释 Python 的切片表示法

这是Boon项目链接：

https://github.com/RichardHightower/boon

现在让我们继续切片！

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

idx(set, "o")

这是我们之前创建的一套水果（设置是一个树集，里面有“苹果”，“猕猴桃”，“橙子”，“梨”，“菠萝”）。

      assertEquals(

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

      );

我们找到了橙子！

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

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

是的！我们找到了梨！

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

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

您也可以要求在另一个项目之后的项目。“pi”之后是什么？after（set， “pi”）

  assertEquals(

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

  );

“菠萝”在项目“pi”之后。顺便说一句，之后和idx是一样的。那么我为什么要添加一个 after 呢？所以我可以有一个之前!!!:)如果你想知道“pi”之前是什么怎么办？

之前（设置，“pi”）

  assertEquals(

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

  );

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

slc（set， “ap”， “o”）

  assertEquals(

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

  );

“o”后面的所有水果怎么样？

slc（set， “o”）

  assertEquals(

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

  );

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

所有水果直到“o”怎么样？（slcEnd阅读它，因为我正在切掉结尾。

slcEnd（set， “o”）

  assertEquals(

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

因此，包括“o”在内的所有水果都是“橙子”，“梨”和“菠萝”。

安全切片列表类似的东西

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

Java Slice 表示法，如下所示使用 Boon：

      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 代表零容忍终端切片。复制代表好，错误，嗯复制当然

男孩和女孩...请记住始终对您不知道的对象执行安全切片。

也适用于基元，因此没有自动装箱

索引基元

 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在数组状，列表状，映射状事物中“索引”的位置给我项目。

首页 MC 字符串切片！

以下是Boon Java String Slicing的一些示例

  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（字母，-1）=='d'的方式是idx（字母，字母.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中滚动，让我的抹布顶部向下，这样我的头发就可以吹了！切片婴儿!!!