Java 中的子字符串

Java 中對String最流行的操作是連接、通過索引獲取字符和獲取子字符串。在本文中，我們將向您介紹 Java 子字符串方法。

什麼是 Java 子串？

Java 子字符串通常是字符串內部連續的字符序列。它可以是字符串的一部分，也可以是整個字符串。 Java 中的子字符串 - 2

Java中的子串是什麼？由於 Java 方法重載，這種語言有一個substring()方法，或者更確切地說是兩個方法。您可以使用它們在 Java 程序中獲取子字符串。第一個 Java substring 方法是String substring(firstIndex)，第二個是String substring (firstIndex, lastIndex)。

如何在 Java 中使用子字符串

答案很簡單：只需使用子串。Java substring()方法返回字符串的一部分。為此，您可以使用兩種方法：

子字符串方法的語法	字符串子串（firstIndex）	字符串子串 (firstIndex, lastIndex)
參數	firstIndex是字符串中的一個數字，它是子字符串的第一個索引。包括的。子字符串的最後一個數字是整個字符串的最後一個數字	firstIndex是字符串中的一個數字，它是子字符串的第一個索引。包括的。 lastIndex是您的字符串的編號，首先是從您的子字符串中排除後的所有編號
Java中如何使用子串的例子	`String s = "CodeGym"; System.out.println(s.substring(4)); //returns Gym`	`String s = "CodeGym"; System.out.println(s.substring(2,5)); //returns deG`

非常受歡迎的任務，可以幫助您理解

如何在 Java 中獲取子字符串
如何查找給定字符串的所有子字符串
如何找到最長公共子串

Java中如何獲取子串（具體）

第一個 Java 子字符串示例非常簡單。您有一個字符串，您需要在其中找到一個子字符串“CodeGym”。您已經知道如何在 Java 中獲取子字符串。所以這是這個特定問題的解決方案：


import java.io.IOException;

public class Main {

   public static void main(String[] args) throws IOException {

       String s1 = "the best Java Core course is CourseCodeGym.  End of story";
       String myTarget = "CodeGym";
       int index1 = s1.indexOf(myTarget);
      
       int index2 = index1 + myTarget.length();
       System.out.println(s1.substring(index1, index2));

   }
}

輸出為： CodeGym Process finished with exit code 0 如何查找給定字符串的所有子字符串這裡我們有最簡單的方法來查找給定字符串的所有子字符串。


import java.io.IOException;
public class Main {
   public static void main(String[] args) throws IOException {
       String myTarget = "CodeGym";
       for (int i = 0; i < myTarget.length(); i++) {
           for (int j = i + 1; j <= myTarget.length(); j++) {
               System.out.println(myTarget.substring(i, j));
           }
       }    
   }
}

輸出為： C Co Cod Code CodeG CodeGy CodeGym o od ode odeG odeGy odeGym d de deG deGy deGym e eG eGy eGym G Gy Gym y ym m 進程結束，退出代碼為 0 如何找到最長公共子串最長公共子 串問題是計算機科學中最受歡迎的任務之一。您很有可能會在初級開發人員面試中遇到它。Anyway，試著去解決它，對於初學程序員來說是一個非常有用的練習。最長公共子串問題是指找到作為兩個或多個字符串的子串（或為子串）的最長字符串（或其中的幾個）。例如你有兩個字符串


String first = "CodeGym" 
String second = "SomeGym"

輸出應為：eGym 因此，您必須輸入字符串“first”和“second”。打印最長公共子串。如果兩個或多個子串的最長公共子串具有相同的值，則打印其中任何一個。我們強烈建議您嘗試自己解決這個問題，然後再查看下面的代碼。


public class SubStringTest {

   //  in this method we are looking for the Longest common substring of
   // first String with length = m  and the second String with length = n
   public static String longestCS(String first, String second, int m, int n) {
       // the maximal length
       int maxLength = 0;
       // the last index of the longest common substring
       int endIndex = m;

       // array stores the length of substring
       int[][] keeper = new int[m + 1][n + 1];

       for (int i = 1; i <= m; i++) {
           for (int j = 1; j <= n; j++) {
               // check if current characters of first and second strings match
               if (first.charAt(i - 1) == second.charAt(j - 1)) {
                   keeper[i][j] = keeper[i - 1][j - 1] + 1;
                  
                   if (keeper[i][j] > maxLength) {
                       maxLength = keeper[i][j];
                       endIndex = i;
                   }
               }
           }
       }
       return first.substring(endIndex - maxLength, endIndex);
   }


   public static void main(String[] args) {
       String first = "CodeGym";
       String second = "SomeGym";
       int m = first.length(), n = second.length();
       System.out.println("The longest common substring = " + longestCS(first, second, m, n));
   }
}

輸出為： 最長公共子串 = eGym

子字符串如何在 Java 中工作

在 JDK 7 和更新版本中，substring()不再像在 JDK 6 之前的版本中那樣計算它創建的字符數組中的字符數，而是簡單地在內存（堆）中創建一個新數組並引用它. 這是一個例子：


String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

因此，在 JDK 7 及更高版本中，由於將substring()方法應用於對象x而創建的對象y和z將引用兩個新創建的數組（在堆上）- {d,e, G, y} for y和{C, o}代表z。在JDK 7+版本的method substring中，這兩個新行（即兩個新的字符數組）會和原來的字符串myLongString({C, o, d, e, G, y, m , i, s, t, h, e, b,e,s,t} 數組形式）。

JDK 6 版本的子串

即使在今天，在一些大型項目中，您也可能會遇到 6 次來自 JDK 的遺留代碼庫。在 JDK 6 中，方法substring()以不同的方式工作。您可能知道，String是一個不可變的類，為了獲取子字符串，Java 在 JDK 6 中更早地使用了這種不可變性。裡面的String類型的對像只是一個字符數組，或者更確切地說，包含一個字符數組。在 JDK 6 的時候，那裡又存儲了兩個變量：字符數組中第一個字符的編號及其數量。於是，在JDK 6中，String有char value[]（字符數組）、int offset（數組第一個字符的索引）、int count三個字段（數組中的字符數）。在 JDK 6 中創建子字符串時，字符數組不會復製到新的String對像中。取而代之的是，兩個對像都存儲了對同一個字符數組的引用。然而，第二個對象存儲了兩個變量，第一個是子字符串的符號，第二個是關於子字符串中有多少個符號。由於內存洩漏問題，JDK 6 方法被替換。這是什麼意思？假設我們有一個 string x，並且我們使用 substring.


String x = "CodeGymIsTheBest";
String y = x.substring (2,6);
String z = x.substring (0,3);

現在我們有一個對象x存儲在一個叫做堆的特殊內存區域，兩個對象y和z引用同一個對象x。只有x指的是從第二到第六的元素，z指的是從零到第三的x個元素。如果原始對象x已經被使用並且沒有任何引用怎麼辦？在程序中，所有其他對象僅與y和z一起使用。在這種情況下，垃圾收集器可能會銷毀對象x，而內存數組仍然存在，並由 y 和 z 使用。發生內存洩漏。因此，較新的 JDK 7 及更高版本的方法在內存使用方面成本相當高。但是它可以讓你防止內存洩漏。此外，新方法運行速度更快，因為它不必計算字符數。為了鞏固您所學的知識，我們建議您觀看我們的 Java 課程中的視頻課程

更多閱讀：
Java String lastIndexOf() 方法 Java 中的 String.split() 方法：將字符串拆分為多個部分