[備忘録 その６] Java Silver ～文字列の取り扱いとデータの比較～

# 文字列の取り扱い
## Stringクラス
'String'クラスは、変化不可(イミュータブル)な文字列を表します。一度作成された'String'オブジェクトの内容は変更できません。文字列操作を行うと、新しい'String'オブジェクトが生成されます。

### 特徴
* イミュータブル(不変)
* スレッドセーフ
* 文字列リテラル'String'オブジェクトとして作成される

```java
public class Main {
    public static void main(String[] args) {
        // 文字列の作成
        String str1 = "Hello";
        String str2 = "World";
        
        // 文字列の連結
        String str3 = str1 + " " + str2;
        System.out.println(str3);  // Hello World
        
        // 文字列の長さ
        int length = str3.length();
        System.out.println("Length: " + length);  // Length: 11
        
        // 部分文字列の取得
        String substr = str3.substring(6, 11);
        System.out.println("Substring: " + substr);  // Substring: World
        
        // 文字列の比較
        boolean isEqual = str1.equals(str2);
        System.out.println("Strings are equal: " + isEqual);  // Strings are equal: false
    }
}
```

### Stringクラスのメソッド

#### charAt(int index)
指定された位置にある文字を返します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        char ch = str.charAt(7);
        System.out.println("Character at index 7: " + ch);  // Character at index 7: W
    }
}
```
#### compareTo(String anotherString)
文字列を辞書順に比較します。文字列が等しければ0、現在の文字列が引数の文字列より小さい場合の負の値、大きい場合は正の値を返します。
```java
public class Main {
    public static void main(String[] args) {
        String str1 = "Apple";
        String str2 = "Banana";
        int result = str1.compareTo(str2);
        System.out.println("Compare result: " + result);  // Compare result: -1
    }
}
```
#### contains(CharSequence s)
指定されたシーケンスがこの文字列に含まれているかどうかを返します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean contains = str.contains("World");
        System.out.println("Contains 'World': " + contains);  // Contains 'World': true
    }
}
```
#### endsWith(String suffix)
この文字列が指定されたサフィックスで終わるかどうかをテストします。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        boolean endsWith = str.endsWith("World!");
        System.out.println("Ends with 'World!': " + endsWith);  // Ends with 'World!': true
    }
}
```
#### equals(Object anObject)
この文字列を指定されたオブジェクトが等しいかどうかを比較します。
```java
public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        boolean isEqual = str1.equals(str2);
        System.out.println("Strings are equal: " + isEqual);  // Strings are equal: true
    }
}
```
#### equalsIgnoreCase(String anotherString)
この文字列と指定された文字列を、大文字小文字を区別せずに比較します。
```java
public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
        System.out.println("Strings are equal ignoring case: " + isEqualIgnoreCase);  // Strings are equal ignoring case: true
    }
}
```
#### indexOf(String str)
指定された文字列が最初に出現する一のインデックスを返します。存在しない場合は-1を返します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int index = str.indexOf("World");
        System.out.println("Index of 'World': " + index);  // Index of 'World': 7
    }
}
```
#### isEmpty()
この文字列がからであるかどうかを判定します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "";
        boolean isEmpty = str.isEmpty();
        System.out.println("String is empty: " + isEmpty);  // String is empty: true
    }
}
```
#### length()
文字列の長さを返します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int length = str.length();
        System.out.println("Length: " + length);  // Length: 13
    }
}
```
#### replace(CharSequence target, CharSequence replacement)
指定されたターゲット文字列のすべての出現部分を置き換えます。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String newStr = str.replace("World", "Java");
        System.out.println("Replaced string: " + newStr);  // Replaced string: Hello, Java!
    }
}
```
#### split(String regex)
この文字列を指定された正規表現に従って分割します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "apple,banana,orange";
        String[] fruits = str.split(",");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
        // Output:
        // apple
        // banana
        // orange
    }
}

```
#### substring(int beginIndex, int endIndex)
この文字列の一部を抽出します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String substr = str.substring(7, 12);
        System.out.println("Substring: " + substr);  // Substring: World
    }
}

```
#### toLowerCase() と toUpperCase()
文字列を小文字または大文字に変換します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String lowerStr = str.toLowerCase();
        String upperStr = str.toUpperCase();
        System.out.println("Lower case: " + lowerStr);  // Lower case: hello, world!
        System.out.println("Upper case: " + upperStr);  // Upper case: HELLO, WORLD!
    }
}

```
#### trim()
文字列の前後の空白を削除します。
```java
public class Main {
    public static void main(String[] args) {
        String str = "   Hello, World!   ";
        String trimmedStr = str.trim();
        System.out.println("Trimmed string: '" + trimmedStr + "'");  // Trimmed string: 'Hello, World!'
    }
}

```
## StringBuilderクラス
'StringBuilder'クラスは、変更可能な(ミュータブル)文字列を表します。文字列の変更操作を行っても新しいオブジェクトを作成するのではなく、同じくオブジェクトを変更します。これは、特に文字列の連結や挿入、削除などの操作が多い場合に有効です。

### 特徴
* ミュータブル(可変)
* スレッドセーフではない
* 高速な文字列操作が可能

```java
public class Main {
    public static void main(String[] args) {
        // StringBuilderの作成
        StringBuilder sb = new StringBuilder("Hello");
        
        // 文字列の追加
        sb.append(" World");
        System.out.println(sb.toString());  // Hello World
        
        // 文字列の挿入
        sb.insert(5, ",");
        System.out.println(sb.toString());  // Hello, World
        
        // 文字列の置換
        sb.replace(5, 6, "!");
        System.out.println(sb.toString());  // Hello! World
        
        // 文字列の削除
        sb.delete(5, 6);
        System.out.println(sb.toString());  // Hello World
        
        // 逆順
        sb.reverse();
        System.out.println(sb.toString());  // dlroW olleH
    }
}
```

### StringBuilderクラスのメソッド
#### appendメソッド
指定された文字列をこのシーケンスの末尾に追加します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(", World!");
        System.out.println(sb.toString());  // Hello, World!
    }
}

```
#### insertメソッド
指定された位置に文字列を挿入します。

```java
```
#### 

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.insert(5, ", World");
        System.out.println(sb.toString());  // Hello, World
    }
}

```replaceメソッド
指定された開始インデックスと終了インデックスの間の文字を、新しい文字列に置き換えます。
#### 

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        sb.replace(7, 12, "Java");
        System.out.println(sb.toString());  // Hello, Java!
    }
}

```
#### deleteメソッド
指定された開始インデックスと終了インデックスの間の文字を削除します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        sb.delete(5, 7);
        System.out.println(sb.toString());  // HelloWorld!
    }
}

```
#### deleteCharAtメソッド
指定された位置の文字を削除します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        sb.deleteCharAt(5);
        System.out.println(sb.toString());  // Hello World!
    }
}

```
#### reverseメソッド
文字列の順序を逆にします。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        sb.reverse();
        System.out.println(sb.toString());  // !dlroW ,olleH
    }
}

```
#### setCharAtメソッド
指定されたインデックスの文字を新しい文字に設定します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        sb.setCharAt(7, 'J');
        System.out.println(sb.toString());  // Hello, Jorld!
    }
}

```
#### substringメソッド
指定された開始インデックスと終了インデックスの間の部分文字列を返します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        String substr = sb.substring(7, 12);
        System.out.println("Substring: " + substr);  // Substring: World
    }
}

```
#### toStringメソッド
StringBuilderの内容をStringに変換して返します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        String str = sb.toString();
        System.out.println(str);  // Hello, World!
    }
}

```
#### lengthメソッド
文字列の長さを返します。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        int length = sb.length();
        System.out.println("Length: " + length);  // Length: 13
    }
}

```
#### capacityメソッド
StringBuilderの現在の容量を返します。容量は、StringBuilderが新しいメモリ割り当てなしに格納できる文字の数です。

```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello, World!");
        int capacity = sb.capacity();
        System.out.println("Capacity: " + capacity);  // Capacity: 29
    }
}

```
#### ensureCapacityメソッド
StringBuilderの容量を少なくとも指定された最小値に増やします。
```java
public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.ensureCapacity(50);
        System.out.println("New Capacity: " + sb.capacity());  // New Capacity: 50
    }
}
```

### 適切なクラスの選択
* 'String'クラス：文字列が変更されない場合や、頻繁に変更する必要がない場合に使用します。例えば、定数文字列や文字列リテラルを扱う場合。
* 'StringBuilder'クラス：文字列の連結や挿入、削除などの操作が多い場合に使用します。例えば、動的に文字列を生成する場合や、ループ内で文字列を構築する場合。

### 'StringBuilder'と'StringBuffer'の違い
* 'StringBuilder'：非スレッドセーフで高速。単一スレッド環境での文字列操作に適しています。
* 'StringBuffer'：スレッドセーフでやや低速。マルチスレッド環境での文字列操作に適しています。

# データの比較
データの比較は、プログラミングにおいて、非常に重要な操作です。Javaでデータを比較する方法はいくつかあります。

## 基本データ型の比較
基本データ型(プリミティブ型)の比較は、'=='演算子を使用します。
### 整数型の比較
```java
public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        
        if (a == b) {
            System.out.println("a is equal to b");
        } else {
            System.out.println("a is not equal to b");  // a is not equal to b
        }
        
        if (a < b) {
            System.out.println("a is less than b");  // a is less than b
        }
        
        if (a > b) {
            System.out.println("a is greater than b");
        }
    }
}
```
### 浮動小数点型の比較
浮動小数点の比較には注意が必要です。'=='演算子は使用しないほうがいい場合が多いです。代わりに、許容範囲を考慮して比較します。
```java
public class Main {
    public static void main(String[] args) {
        double a = 0.1 + 0.2;
        double b = 0.3;
        
        if (Math.abs(a - b) < 0.00001) {
            System.out.println("a is approximately equal to b");  // a is approximately equal to b
        } else {
            System.out.println("a is not equal to b");
        }
    }
}

```
## 参照型の比較
### 文字列の比較
'String'オブジェクトの比較には'=='演算子を使用せず、'equals'メソッドを使用します。'=='演算子は参照の比較を行うため。文字列の内容が同じかどうかを確認するためには'equals'メソッドを使用します。
```java
public class Main {
    public static void main(String[] args) {
        String str1 = new String("Hello");
        String str2 = new String("Hello");
        
        if (str1 == str2) {
            System.out.println("str1 == str2");
        } else {
            System.out.println("str1 != str2");  // str1 != str2
        }
        
        if (str1.equals(str2)) {
            System.out.println("str1 equals str2");  // str1 equals str2
        }
    }
}

```

### オブジェクトの比較
独自のオブジェクトを比較する場合は、'equals'メソッドをオーバーライドする必要があります。また、ハッシュコードの比較を行う場合は'hashCode'メソッドもオーバーライドする必要があります。
```java
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("John", 25);
        Person p2 = new Person("John", 25);
        
        if (p1.equals(p2)) {
            System.out.println("p1 equals p2");  // p1 equals p2
        } else {
            System.out.println("p1 does not equal p2");
        }
    }
}

```

### コレクションの比較
Javaのコレクション(リスト、セット、マップ)を比較する場合、それぞれのコレクションが提供する'equals'メソッドを使用します。
#### リストの比較
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<>(Arrays.asList("A", "B", "C"));
        
        if (list1.equals(list2)) {
            System.out.println("list1 equals list2");  // list1 equals list2
        } else {
            System.out.println("list1 does not equal list2");
        }
    }
}

```
#### セットの比較
```java
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>(Arrays.asList("A", "B", "C"));
        Set<String> set2 = new HashSet<>(Arrays.asList("A", "B", "C"));
        
        if (set1.equals(set2)) {
            System.out.println("set1 equals set2");  // set1 equals set2
        } else {
            System.out.println("set1 does not equal set2");
        }
    }
}

```

#### nullの比較
==演算子を使用する
nullの比較には、==演算子を使用します。==演算子は、オブジェクト参照が同じかどうかを確認するため、nullの比較にも適しています。

```java
public class Main {
    public static void main(String[] args) {
        String str1 = null;
        String str2 = null;
        String str3 = "Hello";
        
        if (str1 == str2) {
            System.out.println("str1 and str2 are both null");  // str1 and str2 are both null
        }
        
        if (str1 == null) {
            System.out.println("str1 is null");  // str1 is null
        }
        
        if (str3 != null) {
            System.out.println("str3 is not null");  // str3 is not null
        }
    }
}

```
最初のページ
[[備忘録 その１] Java Silver ～Javaプログラミング基礎～](https://qiita.com/MagicShowTime/items/9fcf3a2cb4a7162aafcf "[備忘録 その１] Java Silver ～Javaプログラミング基礎～")

前のページ
[[備忘録 その５] Java Silver ～演算子～](https://qiita.com/MagicShowTime/items/801fbb1a542cb9e1a317 "[備忘録 その５] Java Silver ～演算子～")

次のページ
[[備忘録 その７] Java Silver ～基本データ型の型変換～](https://qiita.com/MagicShowTime/items/f6ec6a1ae77954263c0a "[備忘録 その７] Java Silver ～基本データ型の型変換～")