Java 是否有与Python'；什么是简单的字符串拼接？

好的，我想知道的是，Java有没有一种方法可以实现Python在下面所能做的事情

string_sample = "hello world"

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

string_sample[-1]
>>> "d"

string_sample[3]
>>> "l"

因为在我看来，Java让你得到了同样的结果（我特别习惯于每次都要使用2个数字，并且缺少一个-1来表示最后一个字符）

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

---

编辑：将字符串_示例[3]的“i”改为“l”。好样的马龙

我认为没有这样的Java字符串库提供与python完全相同的东西。也许你能做的最好的事情就是构建一个新的类来提供你需要的函数。因为java中的类是最后一个类，您不能让一个类从中扩展，所以您需要使用组合。例如：

public class PythonString {
  protected String value;
  public PythonString(String str) {
    value = new String(str);
  }

  public char charAt(int index) {
    if (index < 0) {
      return value.charAt(value.length() + index);
    }
    return value.charAt(index);
  }

  ....

}

公共类PythonString{
保护字符串值；
公共Python字符串（字符串str）{
值=新字符串（str）；
}
公共字符（整型索引）{
如果（指数<0）{
返回值.charAt（value.length（）+索引）；
}
返回值.charAt（索引）；
}
....
}

---

另一种选择是创建静态字符串库。

对不起，Java的

子字符串

不如Python的切片表示法灵活

特别是：

• 你可以给它一个开始，或者一个开始和结束，但不仅仅是一个结束。（此外，没有步骤，但您不会错过太多。）
• 负索引是一个错误，不是从末尾开始的计数

你可以看到文件

然而，自己写这篇文章并不难：

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);
}

public String slice\u start（String s，int startIndex）{
如果（startIndex<0）startIndex=s.length（）+startIndex；
返回s.substring（startIndex）；
}
公共字符串切片\u结束（字符串s，int-endIndex）{
如果（endIndex<0）endIndex=s.length（）+endIndex；
返回s.substring（0，endIndex）；
}
公共字符串切片_范围（字符串s、int-startIndex、int-endIndex）{
如果（startIndex<0）startIndex=s.length（）+startIndex；
如果（endIndex<0）endIndex=s.length（）+endIndex；
返回s.substring（startIndex，endIndex）；
}

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

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

---

其他序列基本上是相同的，但是这里您需要的是

子序列

，而不是

子序列

。（也可以对字符串使用

子序列

，因为

字符串

是

字符序列

）

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

---

---

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

简单回答，不，没有。字符串在两种语言中都是不可变的。字符串在内部存储为字符数组，因此在Python中使用子字符串和使用括号基本上是做同样的事情的。Java不支持运算符重载，因此无法将该功能赋予该语言。使用子字符串并不是那么糟糕。你不应该经常这样做。如果您经常编写帮助函数以简化使用，则可以编写帮助函数。

您可以轻松编写这样的方法，请记住，从字符串长度中减去负索引以获得正确的索引

public String slice(String s, int start) {
   if (start < 0) start = s.length() + start; 

   return s.substring(start);
}

公共字符串片段（字符串s，int start）{
如果（开始<0）开始=s.长度（）+开始；
返回s.substring（开始）；
}

使用

子字符串

：

class Main
{
  public static void main (String[] args) throws java.lang.Exception
  {
     String s = new String("hello world");
     System.out.println(s.substring(0, s.length()));
     System.out.println(s.substring(s.length() - 1, s.length()));
     System.out.println(s.substring(3, 4));
  }
}

或

charAt

：

System.out.println(s.charAt(s.length() - 1));
System.out.println(s.charAt(3));

Java不是python，所以应该避免负索引以保持恒定性。但是，您可以制作一个简单的转换函数。

对此有一些支持：

从指定的字符串中获取子字符串以避免异常

负起始位置可用于从字符串末尾开始n个字符

---

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

我为此创建了一个简单的库，名为，它提供了一种统一的方式，以类似于Python的方式访问Java中的字符串、列表或数组片段

因此，您的示例将简单地写为：

    String sample = "hello world";

    System.out.println(slice(sample, 0, -1)); // "hello worl"
    System.out.println(slice(sample, -1)); // 'd'
    System.out.println(slice(sample, 3)); // 'l'

---

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

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

Boon有三个slc操作符：slc、slc（仅开始）和slcEnd

通过Boon，您可以对字符串、数组（基本和通用）、列表、集合、树集合、树映射等进行切片

切片符号-温和的介绍

boon slice操作符的工作原理类似于Python/Ruby切片表示法：

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]

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

     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

Python切片表示法

 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]

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

     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

以下内容来源于一篇关于Python切片表示法的优秀文章：

切片符号的基础如下所示：

Python切片表示法

 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]

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

     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

      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

slc代表切片 idx代表指数 slcEnd表示结束切片。 复制sta

         //Negative indexes

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

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

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

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

          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")

          after(set, "pi") //pineapple

          before(set, "pi")

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

  assertEquals(

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

  );

idx(set, "o")

      assertEquals(

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

      );

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

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

  assertEquals(

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

  );

  assertEquals(

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

  );

  assertEquals(

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

  );

  assertEquals(

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

  );

  assertEquals(

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

      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

 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)
 );

  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");

  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!");