Java: Selection Sort

The selection sort algorithm sorts an array by repeatedly finding the minimum element
(considering ascending order) from the unsorted part and putting it at the beginning.
The algorithm maintains two subarrays in a given array.

1) The subarray which is already sorted.
2) Remaining subarray which is unsorted.

In every iteration of selection sort, the minimum element (considering ascending order) from the unsorted subarray is picked and moved to the sorted subarray.
Following example explains the above steps:

arr[] = 64 25 12 22 11

Find the minimum element in arr[0...4]and place it at beginning
11 25 12 22 64

Find the minimum element in arr[1...4]and place it at beginning of arr[1...4]
11 12 25 22 64

Find the minimum element in arr[2...4] and place it at beginning of arr[2...4]
11 12 22 25 64
Find the minimum element in arr[3...4] and place it at beginning of arr[3...4]
11 12 22 25 64

public class SelectionSort {

    void sort(int arr[])
    {
        int n = arr.length;

        // One by one move boundary of unsorted subarray         

        for (int i = 0; i < n-1; i++)
        {
            // Find the minimum element in unsorted array 

            int min_idx = i;
            for (int j = i+1; j < n; j++)
                if (arr[j] < arr[min_idx])
                    min_idx = j;

            // Swap the found minimum element with the first element

            int temp = arr[min_idx];
            arr[min_idx] = arr[i];
            arr[i] = temp;
        }
    }
    // Prints the array     

   void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i            System.out.print(arr[i]+" ");
        System.out.println();
    }

    // Driver code to test above 

   public static void main(String args[])
    {
        SelectionSort ob = new SelectionSort();
        int arr[] = {64,25,12,22,11};
        System.out.println("input array");
        ob.printArray(arr);
        ob.sort(arr);
        System.out.println("Sorted array");
        ob.printArray(arr);
    }
}

Java: Bubble Sort

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order.

Example:
First Pass:
( 5 1 4 2 8 ) –> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.
( 1 5 4 2 8 ) –> ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 ) –> ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.

Second Pass:
( 1 4 2 5 8 ) –> ( 1 4 2 5 8 )
( 1 4 2 5 8 ) –> ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.

Third Pass:
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) –> ( 1 2 4 5 8 )

public class BubbleSort {
    void bubbleSort(int arr[])
    {
        int n = arr.length;
        for (int i = 0; i < n-1; i++)
            for (int j = 0; j < n-i-1; j++)
                if (arr[j] > arr[j+1])
                {
                    // swap arr[j+1] and arr[i] 

                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
    }

    /* Prints the array */     

   void printArray(int arr[])
    {
        int n = arr.length;
        for (int i=0; i 

          System.out.print(arr[i] + " ");
          System.out.println();
    }

    // Driver method to test above 

    public static void main(String args[])
    {
        BubbleSort ob = new BubbleSort();
        int arr[] = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Input array");
        ob.printArray(arr);

        ob.bubbleSort(arr);
        System.out.println("Sorted array");
        ob.printArray(arr);
    }

}

Retrieve JWT Authentication Access Token Using HttpsURLConnection

In JWT Authentication, a token is used to access the API interfaces.  In general, it will be a two-step authentication process. First, it will authenticate the user using the user's credentials such as login id, password, client id, and secret keys. Following is a method on how to get the access token uses HTTPS protocol.

    public JwtAuthenticationResponse getHttpsAuthToken(String hostName, int port,     

                                                                    String   userName, String userPassword,

                                                            String grantType, String clientId, String clientSecret,

                                                               String urlPath) 

        HttpsURLConnection httpConn = null;

        final int BUFFER_SIZE = 4096;

        // Create a trust manager that does not validate certificate chains (should be removed in prod env)

        TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {

            public java.security.cert.X509Certificate[] getAcceptedIssuers() {

                return null;

            }

            public void checkClientTrusted(X509Certificate[] certs, String authType) {

            }

            public void checkServerTrusted(X509Certificate[] certs, String authType) {

            }

        }

        };

        try {

            // Install the all-trusting trust manager

            SSLContext sc = SSLContext.getInstance("SSL");

            sc.init(null, trustAllCerts, new java.security.SecureRandom());

            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

            // Create all-trusting host name verifier

            HostnameVerifier allHostsValid = new HostnameVerifier() {

                public boolean verify(String hostname, SSLSession session) {

                    return true;

                }

            };

            HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);

        } catch (NoSuchAlgorithmException e) {

            logger.debug(String.format("Cannot connect to Hybris server:  %s ;", e.toString()));

            throw new RuntimeException(e);

        } catch (KeyManagementException e) {

            logger.debug(String.format("Cannot connect to Hybris server:  %s ;", e.toString()));

            throw new RuntimeException(e);

        }

        String url;

url = "https://"+hostName + ":"+String.valueOf(port)+"/services/oauth2/token";

        logger.debug("get authendication using: " + url);

        InputStream inputStream;

        try {

            StringBuilder data = new StringBuilder ( );

            data.append ("grant_type=" + grantType);

            data.append ("&client_id=" + clientId);

            data.append ("&client_secret=" + clientSecret);

            if (userId != null && !userId.equals ("undefined")) {

                data.append ("&username=" + userId);

            }

            if (userPassword != null && !userPassword.equals ("undefined")) {

                data.append ("&password=" + userPassword);

            }

           String auth = clientId + ":" + clientSecret;

            byte[] encodedS = Base64.encodeBase64 (auth.getBytes ( ));

            String authHeader = "Basic " + new String (encodedS);

            // Create a byte array of the data to be sent

            byte[] encodedAuth = data.toString ( ).getBytes ("UTF-8");

            String authId = userId + ":" + userPassword;

            byte[] encodedId = Base64.encodeBase64 (authId.getBytes ( ));

            String authHeaderId = "Basic " + new String (encodedId);

            // Setup the Request

            URL request = new URL (url);

            httpConn = (HttpsURLConnection) request.openConnection ( );

            httpConn.setRequestMethod ("POST");

            httpConn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            httpConn.setRequestProperty("Content-Length", "" + encodedAuth.length);

            httpConn.setRequestProperty("Content-Length", "" + encodedAuth.length);

            httpConn.setRequestProperty("Authorization", authHeaderId);

            httpConn.setUseCaches (false);

            httpConn.setDoOutput (true);

            // Write data

            OutputStream postStream = httpConn.getOutputStream ( );

            postStream.write (encodedAuth);

            postStream.flush ( );

            postStream.close ( );

            // For POST only - END

            int responseCode = httpConn.getResponseCode ( );

            String response;

            if (responseCode == 200) {

                inputStream = httpConn.getInputStream ( );

                ObjectMapper mapper = new ObjectMapper ( );

                JsonNode jsonMap = mapper.readTree (inputStream);

                String token = jsonMap.get ("access_token").toString ( ).replaceAll ("\"", "");

                String tokenType = jsonMap.get ("token_type").toString ( ).replaceAll ("\"", "");

                String refreshToken = null;

                return new JwtAuthenticationResponse (jsonMap.get ("access_token").toString ( ));

            } else {

                inputStream = httpConn.getErrorStream ( );

                try (Scanner scanner = new Scanner (inputStream)) {

                    scanner.useDelimiter ("\\Z");

                    response = (scanner.next ( ));

             }

            String exceptionMsg = "Response Code " + String.valueOf (responseCode) + ". " +

                                                  response;

                throw new UserDefinedException (exceptionMsg);

            }

        } catch (IOException | UserDefinedException e) {

            logger.debug(String.format("Cannot connect to server:  %s ;", e.toString()));

            throw new RuntimeException(e);

        }

    }