> For the complete documentation index, see [llms.txt](https://testingvn.gitbook.io/automationtester/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://testingvn.gitbook.io/automationtester/getting-started/publish-your-docs.md).

# Java Practices

1. **Thay đổi ký tự đặc biệt trong 1 chuỗi cho trước:**

{% hint style="info" %}
thay ký tự `@`  bằng ký tự `_`
{% endhint %}

```java
   public class ChangeSpecialCharacter{
        public static void main (String[] args){
            String str = "Hello @Japneet";
            System.out.print(printDifferentSpeicalCharacter(str));
        }
    
        private static String printDifferentSpeicalCharacter(String str){
            return str.replace('@', '_');
        }
    }
```

1. **Lấy 4 ký tự cuối cùng của một chuỗi cho trước**

{% hint style="info" %}
nhập vào chuỗi `swiss` lấy ra ký tự cuối cùng của chuỗi này là `` `s` ``
{% endhint %}

```java
public class ExtractLast4CharactersOfString{
    public static void main (String[] args){
        String str = "swiss";
        printLast4Chars(str);
    }

    private static void printLast4Chars(String str){
        int size = str.length();
        int counter = size-4;
        for(int i = counter; i<size; i++)
        {
            System.out.print(str.charAt(i));
        }
    }
}
```

3. Tì**m ký tự không lặp lại đầu tiên của một chuối**

```java
import java.util.HashMap;
import java.util.Map;

public class FindFirstNonRepeatedCharacter{
    public static void main (String [] args){
        String str = "swiss";
        findNonRepeatingCharacter(str);
    }

    private static void findNonRepeatingCharacter(String str){
        Map<Character,Integer> map = new HashMap<>();
        int counter =1;

        for(int i=0; i<str.length(); i++){
            if(map.containsKey(str.charAt(i))){
                map.put(str.charAt(i), map.get(str.charAt(i))+1);
            }else{
                map.put(str.charAt(i),counter);
            }
        }

        for(Map.Entry<Character,Integer> entryMap: map.entrySet()){
            if(entryMap.getValue()==1){
                System.out.print(entryMap.getKey());
                break;
            }
        }
    }
}
```

4. **Tìm số lớn nhất và lớn thứ 2 của một mảng**

```java
public class FindLargestSmallestAnd2ndLargest{
    public static void main (String[] args){
        int [] arr = {23,5,1,89,65,0,23,432,1};
        printLargest2ndLargestAndSmallest(arr);
    }

    private static void printLargest2ndLargestAndSmallest(int [] arr){
        int lengthOfArray = arr.length;
        int largest = arr[0];
        int smallest = arr[0];
        int secondLargest = arr[0];

        for(int i=0; i<lengthOfArray; i++){
            if(arr[i]>largest)
{
                secondLargest = largest;
                largest = arr[i];
            }else if (arr[i] < smallest){
                smallest = arr[i];
            }
            //System.out.println(largest+" "+secondLargest+" "+" "+smallest);
        }
        System.out.print(largest+" "+secondLargest+" "+" "+smallest);
    }

}
```

5. Tìm độ lệch lớn nhất giữa 2 phần tử trong một mảng:

```java
public class FindMaximumDifference {
    public static void main (String [] args){
        int [] arr = {10,90,2,40,1,25};
        printMaximumDifference(arr);
    }

    private static void printMaximumDifference(int [] arr){
        //Approach find greatest and smallest number in java and then subtract it.
        int max = arr[0];
        int min = arr[0];

        for(int i=0; i<arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }else if (arr[i] < min){
                min = arr[i];
            }
        }
        System.out.print("Max Difference is: "+ (max-min));
    }
}
```

6. **Tìm vị trí của các số lặp lại trong mảng:**

```
import java.util.HashMap;
import java.util.Map;

public class FindRepeatingElements{
    public static void main (String[] args){
        int [] arr = {4,2,3,5,1,2,4};
        printRepeatingElements(arr);
    }

    private static void printRepeatingElements(int[] arr){
        Map<Integer, Integer> map = new HashMap<>();

        for(int i = 0; i<arr.length; i++){
            Integer mapValue = map.get(arr[i]);

            if(mapValue==null){
                map.put(arr[i], 1);
            }
            else{
                map.put(arr[i], mapValue+1);
            }
        }

        System.out.println(map);
        //Now we need to retrieve only keys which are greater than value = 1
        for(Map.Entry<Integer, Integer> mapEntry : map.entrySet()){
            if(mapEntry.getValue()>1){
                System.out.println("Key: "+mapEntry.getKey()+" Value:"+mapEntry.getValue());
            }
        }
    }
}
```

7. Đưa các số âm trong mảng lên đầu:

```java
import java.util.Arrays;

public class MoveNegativeNumbersToStart{
    public static void main (String [] args){
        int [] arr = {-1,2,3,-4,-7,8};
        moveNegativeNumbersTOStart(arr);
    }

    private static void moveNegativeNumbersTOStart(int [] arr) {
        int[] tempArr = new int[arr.length];
        int counter = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < 0) {
                //System.out.print(arr[i]);
                tempArr[counter] = arr[i];
                counter++;
            }
        }

        for (int i = 0; i < arr.length; i++){
            if(arr[i]>0){
                tempArr[counter] = arr[i];
                counter++;
            }
        }
        System.out.print(Arrays.toString(tempArr));
    }
}
```

8. **Tìm các chuỗi con trong 1 chuổi cho trước:**

```java
public class PrintAllTheSubstrings
{
    public static void main (String [] args){
        String str = "abc";
        printSubstrings(str);
    }

    private static void printSubstrings(String str){
        for(int i=0; i<str.length(); i++){
            for (int j=i+1; j<=str.length(); j++){
                System.out.println(str.substring(i,j));
            }
        }
    }
}
```

9. I**n ra ký tự đầu tiên của mỗi từ trong một câu:**

```java
public class PrintFirstLetterOfString{
    public static void main (String[] args){
        String str = "Hello I am Japneet";
        returnFirstAlphabet(str);
    }

    private static void returnFirstAlphabet(String string){
        String word = "";
        String [] split = string.split(" ");

        for(int i=0; i<split.length; i++){
            word = split[i];
            System.out.print(word.charAt(0));
        }
    }
}
```

10. **In số lượng nguyên âm xuất hiện trong một chuỗi:**

```java
import java.util.HashMap;
import java.util.Map;

public class PrintWordsVowelsFrequencyofeachCaracter{
    public static void main (String [] args){
        String str =    "Learn with Japneet Sachdeva";
        printAllCharacters(str);
    }

    private static void printAllCharacters(String str){
        //TODO: WordCount
        String [] strArray = str.split(" ");
        int wordCount = strArray.length;
        System.out.println(wordCount);

        //TODO: Print Vowels
        int vowelCount = 0;
        for(int i=0; i<str.length(); i++){
            if(str.charAt(i) == 'a' || str.charAt(i) == 'A' || str.charAt(i) == 'e' || str.charAt(i) == 'E' || str.charAt(i) == 'i'
            || str.charAt(i) == 'I' || str.charAt(i) == 'o' || str.charAt(i) == 'O' || str.charAt(i) == 'u' || str.charAt(i) == 'U')
            {
                vowelCount++;
            }
        }

        System.out.println("Vowel count is: "+vowelCount);

        //Todo: Frequency of each character
        Map<Character, Integer> freqMap = new HashMap<>();

        for(int i =0; i<str.length(); i++){
            if(freqMap.containsKey(str.charAt(i))){
                freqMap.put(str.charAt(i), freqMap.get(str.charAt(i))+1);
            }else{
                freqMap.put(str.charAt(i),1);
            }
        }

        for(Map.Entry<Character, Integer> entry: freqMap.entrySet()){
            System.out.print(" Character: "+entry.getKey()+ " Frequency: "+entry.getValue());
        }
    }
}
```

11. **Xóa các ký tự đặc biệt**

```java
public class RemoveAllSpecialCharacters{
    public static void main (String[] args){
        String str = "Hello^^%#$(!)_+ J@apneet";
        System.out.print(removeSpecialCharacters(str));
    }

    private static String removeSpecialCharacters(String str){
        String newStr = str.replaceAll("[%^#$()!_+@]", "");
        return newStr;
    }

}
```

12. **Xóa các từ trùng lặp trong một câu:**

```java
import java.util.HashMap;
import java.util.Map;

public class RemoveDuplicateWordsFromSentence{
    public static void main (String [] args){
        String str = "Hello I am Japneet Japneet am";
        printSentenceWithoutDuplicates(str);
    }

    private static void printSentenceWithoutDuplicates(String str){
        String [] strSplit = str.split("\\s");
        Map<String, Integer> map = new HashMap<>();
        int counter = 1;

        for(int i=0; i<strSplit.length; i++){
            if(map.containsKey(strSplit[i])){
                map.put(strSplit[i], map.get(strSplit[i])+1);
            }else{
                map.put(strSplit[i], counter);
            }
        }

        for(Map.Entry<String,Integer> entryMap: map.entrySet()){
            if(entryMap.getValue()>1){
                System.out.print(entryMap.getKey()+" ");
            }
        }
    }
}
```

13. **Xóa khoảng trắng trong một câu:**

```java
public class RemoveWhiteSpaces{
    public static void main (String[] args){
        String str = "         Hello              Japne     et         ";
        System.out.print(removeWhiteSpace(str));
    }

    private static String removeWhiteSpace(String str){
        String newStr = str.replaceAll("\\s", "");
        return newStr;
    }
}
```

14. **Đảo một chuỗi:**

```java
public class ReverseString{
    public static void main (String[] args){
        String str = "Hello World";
        printReverseofString(str);
    }

    private static void printReverseofString (String str){
        for(int i = str.length()-1; i>=0; i--){
            System.out.print(str.charAt(i));
        }
    }
}
```