Java recipes

This Java method takes a Class object as an argument and returns a List of String objects that represent the names of all the fields in the class. The method uses the Arrays.stream method to convert the array of fields obtained from the cls.getFields() method into a stream, and then the map method to convert each field into its name. Finally, the stream of field names is collected into a List using the collect method and Collectors.toList method.

Java: get names of public class fields

This code defines a method getAllMethods that takes a Class object as input and returns a list of strings representing the names of all the declared methods in that class. It does this by using the stream method from the Arrays class to create a stream of all the declared methods of the input class, then using the map method to extract the name of each method as a string, and finally using the collect method to collect all the method names into a list, which is then returned.

Java: get names of class methods

This code defines a method called removeDuplicateCharacters that takes in a string and returns a new string with all duplicate characters removed. The input string is first converted into an array of characters, which is then looped over. For each character in the input string, the code checks if it exists in a set of unique characters. If it doesn't, it is added to the set. Finally, the set of unique characters is joined back into a string and returned as the result.

Java: remove duplicate characters from string

This code takes a string and a character as input and returns the maximum number of consecutive occurrences of that character in the string. It does this by looping through each character in the string, checking if the current character is equal to the target character, and incrementing the characterCount if it is. The maxCharacterCount variable is updated with the maximum of the current characterCount and the current maxCharacterCount. The loop resets the characterCount to 0 if the current character is not equal to the target character. After the loop, the code returns the maxCharacterCount.

Java: max count of one character

This code consists of two methods: getCommonLetters and isCommonLetter. The getCommonLetters method takes two strings as input, loops through each character in the first string, and checks if it is a common letter between the two strings using the isCommonLetter method. If a character is a common letter, it is added to a set of common letters. Finally, the set is returned as a string separated by spaces. The isCommonLetter method takes a string and a character as input and returns true if the character is present in the string and is a letter, and false otherwise.

Java: get common letters

This code defines a function compareVersion that takes two strings v1 and v2 as inputs, and returns an integer indicating their comparison as version numbers. The function uses a Function object getVersionComponents to extract the components of a version string (i.e., the sequences of numbers separated by dots or dashes). The components of v1 and v2 are then compared one by one, and the function returns the result of the first comparison that is not equal to 0. If all the version components are equal, the function returns 0.

Java: compare version

This code is a Java implementation of the Levenshtein distance algorithm, which is a measure of the difference between two strings. The algorithm takes as input two strings word1 and word2 and returns an integer representing the minimum number of edit operations (insertions, deletions, or substitutions) needed to convert word1 into word2.

The ans array stores the intermediate results of the algorithm, where ans[i][j] represents the minimum number of edit operations required to convert a prefix of length i of word1 into a prefix of length j of word2. The final result is stored in ans[word1.length()][word2.length()], which represents the minimum number of edit operations required to convert the entire word1 into word2.

Java: find levenshtein distance

This code defines a method named isAnagram that takes two string inputs, s1 and s2. The method returns a boolean indicating whether the two input strings are anagrams of each other.

The method first checks if the lengths of the two input strings are equal. If they are not, it immediately returns false as they cannot be anagrams.

Next, it creates two arrays of size 256 (arr1 and arr2) to store the count of each character in both strings. The code then loops through each character in both strings, incrementing the count of each character in their respective arrays.

Finally, the method returns the result of comparing the two arrays using the Arrays.equals method. If the arrays are equal, the method returns true, indicating that the input strings are anagrams. If the arrays are not equal, the method returns false, indicating that the input strings are not anagrams.

Java: anagram check

This code defines a method called stringToDate that takes two arguments: a String called date and a String called format. The method returns a Date object and throws a ParseException if there's a problem parsing the input date string.

The method uses the SimpleDateFormat class to parse the input date string. The SimpleDateFormat class is part of the Java Standard Library and provides a convenient way to format and parse dates and times. The format argument is used to specify the desired format of the output date, and the date argument is the input date string that needs to be parsed. The parse method of the SimpleDateFormat class is then used to parse the input date string, and the resulting Date object is returned by the stringToDate method.

Java: string to date

In summary, this code defines a method called reverseString that takes in a string as input and returns its reverse. The method uses the StringBuilder class to reverse the string, by first converting the input string to a StringBuilder object, then calling the reverse method on the object to reverse the order of its characters, and finally converting the reversed StringBuilder object back to a string using the toString method.

Java: reverse string

This code defines a isPalindrome function which takes in a String and returns a boolean indicating whether the input string is a palindrome. The function first removes all non-letter characters from the input string using a StringBuilder object. Then, it stores the lowercase version of the input string both forwards and backwards, and checks if these two strings are equal. If they are equal, the function returns true, indicating that the input string is a palindrome. If they are not equal, the function returns false.

Java: palindrome check

This Java method takes an address (a string) and a HashMap of arguments (keys and values as strings) as input. It prepares the arguments by encoding the keys and values and concatenating them using the "&" separator, and then sends an HTTP POST request to the specified address with these arguments as the request body. The method returns the HTTP response as a string. The method can throw IOException and InterruptedException.

Java: HTTP - POST

This method sends an HTTP GET request to the specified URI using the Java HttpClient class. The response from the server is returned as a string and is wrapped in an HttpResponse object.

Java: HTTP - GET

This code captures a screenshot of the entire screen and saves it as a PNG image file with the specified filename. The method uses the java.awt.Robot class to capture the screen, which is represented as a java.awt.image.BufferedImage object. The javax.imageio.ImageIO class is then used to write the BufferedImage object as a PNG file to the specified file path.

Java: capture screen

This code provides two methods: toBinary and fromBinary. The toBinary method converts a given positive integer to its binary representation in string format. The fromBinary method converts a given binary string to its decimal representation. Both methods include error checks to ensure that the input is valid (e.g., positive integers for toBinary and binary strings that only contain '0' and '1' for fromBinary).

Java: natural number binary conversion

This code uses a simple algorithm to determine whether a given number is prime or not. The algorithm first checks if the number is less than 3, in which case it returns true as the number is considered prime. If the number is greater than or equal to 3, the code checks if it's divisible by 2. If it is, the code returns false as the number is not prime. Finally, the code checks if the number is divisible by any odd number from 3 to the square root of the number. If the number is divisible by any of these, the code returns false, as the number is not prime. If the number has not been found to be divisible by any number in the loop, the code returns true, indicating that the number is prime.

Java: prime detector

This code implements the Euclidean algorithm for finding the GCD of two integers. The algorithm uses recursion, repeatedly dividing the larger of the two numbers by the smaller until the smaller number is 0. The GCD is then equal to the larger number from the final iteration.

Java: greatest common divisor

Python recipes

To detect the programming language of a code snippet, you would need to implement a language-detection algorithm. There are many ways to do this, but one common approach is to use the frequency of keywords, operators, and syntax elements specific to each language to determine the most likely language.

Here's an example implementation in Python that detects the programming language of a given code snippet.

In this program, the detect_language function takes a code snippet as input and returns the detected programming language. It uses a dictionary of keywords for different programming languages, where each language is associated with a list of keywords specific to that language. The code is first converted to lowercase and then split into words using a regular expression. The function then loops through the words and increments the count of each language's keywords found in the code. The language with the highest count is returned as the detected programming language.

Note that this is a simplified implementation and may not be 100% accurate in detecting the correct language for all code snippets. In practice, you would need to use more sophisticated algorithms and more comprehensive lists of keywords and syntax elements specific to each language to achieve higher accuracy.

Python: basic language detection

This code defines a function highlight_syntax that takes a string of code as an argument and returns a new string where certain keywords (if, elif, else, def) are highlighted in green. The highlighting is achieved by surrounding the keyword with ANSI escape codes \033[32m (green) and \033[0m (reset color). The code splits the input string into lines, splits each line into words, checks if each word is a keyword, and adds the highlighted or normal version of each word to a list. The lists of words are then joined together into lines, and the lines are joined together into the final highlighted string.

Python: basic syntax highlighting

This Java code implements the Luhn algorithm, a checksum calculation commonly used in credit card numbers and other identification numbers. The function calculateLuhnChecksum takes as input a long integer num and returns the Luhn checksum digit.

The input number is first checked to make sure it's non-negative. The input number is then converted to a string representation, which is looped through from right to left. If the current digit is in an odd position, it is doubled. The tens and ones place digits of the doubled digit are then added to the running sum. The odd/even position flag is flipped after each iteration.

Finally, the checksum digit is calculated as (10 - (sum % 10)) % 10. This ensures that the checksum digit is between 0 and 9 and handles the edge case where the input number is 0. The checksum digit is then returned as the result of the function.

Java: luhn algorithm

This code is a Java function that generates a list of lottery numbers by adding the numbers 1 to numNumbers to an ArrayList, shuffling the numbers, and returning the first numbersToPick numbers as an Integer array. The Collections.shuffle method is used to randomly shuffle the elements in the ArrayList.

Java: lottery

This code calculates the Haversine distance between two points on the surface of the Earth. It defines a constant SPHERE_RADIUS_IN_KM which represents the radius of the Earth in kilometers. The main method findHaversineDistance calculates the Haversine distance between two points given by their latitude and longitude values. Before calculation, it checks if the latitude and longitude values are within the valid range of -90 to 90 for latitude and -180 to 180 for longitude. If any of the values are not within the valid range, it throws an IllegalArgumentException. The code then calculates the differences between the latitude and longitude values, converts them to radians, and calculates the distance using the Haversine formula.

Java: haversine formula

This is a Java method that calculates the factorial of a number using recursion. It takes an integer number as input, and returns the factorial of that number.

If the input number is equal to initial (which is set to 0), the function returns 1. If the input number is not equal to initial, the function returns number multiplied by the result of a recursive call to the same function with an argument of number - 1.

This recursive call continues until the input number is equal to initial, at which point the function returns 1, and each previous call returns the factorial of the input number.

Java: factorial (recursive)

This code defines a Java function named factorial that takes a single argument number and returns the factorial of that number. The factorial of a positive integer n is the product of all positive integers less than or equal to n.

The function uses a for loop to iterate over the integers from 2 to number, and at each iteration, multiplies the current value of result by the current value of factor. After the loop, the final value of result is returned as the result of the function.

Java: factorial (iterative)

In this code, the iterativeFibonacci method takes an integer number as input, which represents the index of the Fibonacci number that we want to calculate. The method uses an iterative approach to calculate the Fibonacci numbers by storing intermediate values in a list. The loop starts at the 2nd Fibonacci number (index 2) and continues until the number-th Fibonacci number has been calculated. On each iteration, the current Fibonacci number is added to the list by summing the two previous ones. Finally, the method returns the number-th Fibonacci number.

Java: fibonacci sequence (iterative)

This code defines a fibonacci method that takes an integer n as an argument and returns the nth value in the Fibonacci sequence. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding numbers, starting with 0 and 1. In this implementation, if n is less than or equal to 1, the method returns n, since the first two numbers in the Fibonacci sequence are 0 and 1. If n is greater than 1, the method returns the sum of the fibonacci values of n-1 and n-2, since each number in the Fibonacci sequence is the sum of the two preceding numbers.

Java: fibonacci sequence (recursive)

This code provides two Java methods for zipping a directory and its contents: zipDirectory and zipFile.

The zipDirectory method takes two arguments: the name of the source directory (srcDirectoryName) and the name of the resulting zip file (zipFileName). The method uses a try-with-resources statement to create a FileOutputStream and a ZipOutputStream. It then calls the zipFile method with the source directory and its name as the first two arguments and the ZipOutputStream as the third argument.

The zipFile method takes three arguments: a file to be zipped (fileToZip), the file name to be used in the zip archive (fileName), and a ZipOutputStream (zipOut). The method first checks if the file to be zipped is hidden and returns immediately if it is. If the file is a directory, the method puts a new ZipEntry into the ZipOutputStream with the directory name and a "/" mark added to the end of the name to preserve the structure when unzipping. If the file is not a directory, the method uses a try-with-resources statement to create a FileInputStream and reads the contents of the file into a byte array. It then writes the contents of the byte array into the ZipOutputStream with a new ZipEntry for the file name.

This code provides a basic implementation for zipping a directory and its contents. The code can be improved to handle exceptions and different types of files, but this is the basic functionality.

Java: zip directory

This Java code provides a method zipFiles that takes an array of source filenames and a target zip file name as input. It then creates a ZipOutputStream that is used to write the contents of the source files into a zip archive. For each source file, the method opens a FileInputStream to read its contents and writes them to the ZipOutputStream as a new ZipEntry. The entire process is done in a try-with-resources block, which automatically closes the streams when they are no longer needed.

Java: zip multiple files

This code is a Java method that compresses a file into a ZIP archive. It takes two arguments: the name of the source file to be compressed and the name of the ZIP archive to create.

The method uses a try-with-resources block to automatically close the resources it opens (the FileOutputStream, ZipOutputStream, and FileInputStream).

It starts by creating a File object for the source file and a FileOutputStream for the ZIP archive. Then, it creates a ZipOutputStream, wrapping the FileOutputStream. Finally, it creates a FileInputStream for the source file.

The method then creates a ZipEntry for the source file and puts it into the ZipOutputStream using the putNextEntry method.

It uses a buffer bytes of size 1024 to read data from the source file, and a length variable to store the length of the data read. In a while loop, it reads data from the source file using the read method of the FileInputStream and writes it to the ZipOutputStream using the write method. The loop continues until there's no more data to read from the source file.

Java: zip file

This Java code is a simple method that takes a filename as input and returns a list of strings, where each string represents a line in the file. It uses the readAllLines method from the java.nio.file.Files class to read the lines of the file. The readAllLines method takes a java.nio.file.Path object as an argument, so the code creates a Path object from a File object, which is constructed from the input filename. The method throws an IOException if an I/O error occurs while reading the file, or if a malformed or unmappable byte sequence is read.

Java: read lines from file to string list

This code is a Java function that takes a file path as an argument and returns a list of all the files within that path, including those in any subdirectories. The function first creates a list all to store the files it finds, and then creates a File object for the given path and gets an array of all its files and directories using the listFiles() method. The code then checks if the list of files is not null, which can occur in case of an access error. If the list is not null, the code iterates through the list and adds each file to the all list. If a file is a directory, the code recursively calls the listAllFiles method with the absolute path of the directory to find all its files. The final list of all files is returned at the end.

Java: list files in directory recursively

This code defines a static method called listFilesInDirectory, which takes a single File object folder as its argument. The method returns an array of File objects that correspond to the files in the given folder. The listFiles method of the File class is used to retrieve an array of all the files and directories in the folder, but we're using a method reference to only return the files in the folder by passing the isFile method as a filter. The returned array contains only the File objects that represent files (not directories).

Java: list files in directory

This code defines a method listDirectories that takes a string argument path, which is the path to a directory. The method returns an array of File objects representing the subdirectories within the directory specified by path. To do this, it creates a File object based on the path argument and then uses the listFiles method to get a list of all the files and directories in the directory represented by the File object. It then filters this list by passing a reference to the isDirectory method of the File class as an argument to listFiles, so that only the directories are included in the returned list.

Java: list directories

This code defines a Java method named decodeBase64 that takes a Base64 encoded String as input and returns the decoded String. The decoded data is obtained using the Base64.getDecoder().decode method, which takes the input string encoded in Base64 and returns the decoded data as a byte[]. The resulting byte[] is then converted into a String and returned as the result of the decodeBase64 method.

Java: base64 decode string

The encodeBase64 method takes a string input and returns its base64 encoded representation. It uses the getEncoder method of the Base64 class to get a Base64.Encoder object, and then calls the encodeToString method of the encoder to encode the input string. The getBytes method is used to convert the input string into a sequence of bytes, which is the input required by the encodeToString method.

Java: base64 encode string

This Java code defines a findMax function that takes an integer array as an argument. The function first converts the input array into a stream using Arrays.stream. Then, it uses the reduce method to find the maximum value in the stream. The reduce method takes two arguments: an initial value (in this case, Integer.MIN_VALUE) and a binary operator (in this case, Integer::max). The binary operator is applied to each element in the stream and the initial value, and the reduce method returns the final result.

In this case, the function returns the maximum value in the input array.

Java: find max value of array

This code defines a method called arraySum that takes an array of integers as an argument and returns the sum of its elements. It does this by creating a stream of integers from the input array using the stream method from the Arrays class and then using the sum method from the stream class to compute and return the sum.

Java: find sum of array

This code calculates the median of an array of integers by first sorting the array and then finding the middle element(s). If the number of elements in the array is odd, the median is simply the middle element. If the number of elements is even, the median is the average of the two middle elements.

Java: find median of array

This method takes in an array of generic type T, converts the array into a stream, and then uses the distinct and count methods to determine if all elements in the array are the same. The method returns a boolean indicating whether all elements in the array are equal.

Java: find mean of array

The code defines a generic method allEqual that takes an array arr of type T as an argument. It then uses the stream method of the Arrays class to convert the array into a stream, eliminates duplicates using the distinct method, and counts the number of elements using the count method. The method returns true if all elements in the array are equal, and false otherwise.

Java: check if all elements of array are equal

The code defines a Java method called nArrayConcat that takes as input two or more arrays of type T and returns a single array that is the result of concatenating all input arrays. The method first calculates the total length of all arrays by adding up the lengths of each array. It then creates a new array with this calculated length and copies all elements from the first array into this new array. Finally, it copies all elements from the rest of the arrays into the new array and returns the new array as the result.

Java: N array concatenation

The code provided is a Java method that concatenates two arrays of generic type T and returns the resulting array. It uses the Arrays.copyOf method to create a new array with the length of the sum of the lengths of the two input arrays, and the System.arraycopy method to copy the elements of the second array into the new array starting from the end of the first array. The final result is then returned.

Java: two array concatenation

In this code, the linearSearch function takes in an integer array arr and an integer item. It performs a linear search on the array, looking for the item. If the item is found, the function returns its index in the array. If the item is not found, the function returns -1.

Java: linear search

This code implements a counting sort algorithm in Java, which is a sorting algorithm that operates by counting the number of objects having distinct key values (kind of values present in an array). The algorithm works by counting the number of occurrences of each number in the input array and then using this information to place the numbers in their correct order in the output array. The algorithm has a time complexity of O(n + k), where n is the number of elements in the input array and k is the range of the numbers.

Java: counting sort

This code is an implementation of the Insertion Sort algorithm in Java. The Insertion Sort algorithm sorts an array of integers in ascending order by iterating through the array and inserting each element into its correct position relative to the sorted portion of the array.

The code begins by looping through the array starting from the second element (index 1). For each iteration, the current element is stored in a temporary variable. The code then compares the current element with the elements before it, and keeps moving these elements to the right until it finds an element that is smaller than the current one or until it reaches the start of the array. Finally, the current element is inserted into its correct position.

The algorithm continues this process until all elements in the array are sorted in ascending order.

Java: insertion sort

The selectionSort function takes an array of integers as an argument, sorts it in ascending order using the Selection Sort algorithm, and returns nothing.

The algorithm iterates over the array twice, once to select the minimum element, and again to swap it with the first unsorted element. This process is repeated until all elements in the array are sorted.

Java: selection sort

This code implements a simple bubble sort algorithm in Java. The bubble sort algorithm sorts an array of integers by repeatedly swapping adjacent elements that are out of order, until the entire array is sorted in ascending order.

Java: bubble sort

The QuickSort algorithm is a divide-and-conquer algorithm that sorts an array by selecting a pivot element and partitioning the other elements into two sub-arrays, according to whether they are less than or greater than the pivot. The sub-arrays are then sorted recursively. The quickSort method implements this algorithm in Java.

Java: quick sort

The mergeSort function uses a recursive approach to sort the elements in the input array. It first checks if the low index is greater than or equal to the high index, which is the base case. If so, it returns. If not, it calculates the middle index, sorts the first and second halves of the array by calling mergeSort recursively, and then merges the two sorted arrays by calling the merge function.

The merge function takes in the input array, the low and high indices, and the middle index as parameters. It creates a temporary array to store the sorted elements, and uses two indices to keep track of the elements in the two subarrays to be merged. It then iterates through the subarrays and adds the smaller elements to the temp array. Finally, it copies the elements from the temp array back to the original array.

Java: merge sort

 postgres

The sudo -i command allows the user to become the superuser. The -u postgres command sets the user's username to be "postgres". The psql postgres command executes the PostgreSQL command prompt.

Name	Language	Author	Uses
Java: get names of public class fields	Java	TD Tara Dwyer	0
Java: get names of class methods	Java	TD Tara Dwyer	1
Java: remove duplicate characters from string	Java	TD Tara Dwyer	0
Java: max count of one character	Java	TD Tara Dwyer	0
Java: get common letters	Java	TD Tara Dwyer	0
Java: compare version	Java	TD Tara Dwyer	0
Java: find levenshtein distance	Java	TD Tara Dwyer	0
Java: anagram check	Java	TD Tara Dwyer	0
Java: string to date	Java	TD Tara Dwyer	0
Java: reverse string	Java	TD Tara Dwyer	0
Java: palindrome check	Java	TD Tara Dwyer	1
Java: HTTP - POST	Java	TD Tara Dwyer	0
Java: HTTP - GET	Java	TD Tara Dwyer	1
Java: capture screen	Java	TD Tara Dwyer	0
Java: natural number binary conversion	Java	TD Tara Dwyer	0
Java: prime detector	Java	TD Tara Dwyer	0
Java: greatest common divisor	Java	TD Tara Dwyer	0
Python: basic language detection	Python	TD Tara Dwyer	0
Python: basic syntax highlighting	Python	TD Tara Dwyer	0
Java: luhn algorithm	Java	TD Tara Dwyer	0
Java: lottery	Java	TD Tara Dwyer	0
Java: haversine formula	Java	TD Tara Dwyer	0
Java: factorial (recursive)	Java	TD Tara Dwyer	0
Java: factorial (iterative)	Java	TD Tara Dwyer	0
Java: fibonacci sequence (iterative)	Java	TD Tara Dwyer	0
Java: fibonacci sequence (recursive)	Java	TD Tara Dwyer	1
Java: zip directory	Java	TD Tara Dwyer	0
Java: zip multiple files	Java	TD Tara Dwyer	0
Java: zip file	Java	TD Tara Dwyer	3
Java: read lines from file to string list	Java	TD Tara Dwyer	1
Java: list files in directory recursively	Java	TD Tara Dwyer	0
Java: list files in directory	Java	TD Tara Dwyer	0
Java: list directories	Java	TD Tara Dwyer	0
Java: base64 decode string	Java	TD Tara Dwyer	0
Java: base64 encode string	Java	TD Tara Dwyer	0
Java: find max value of array	Java	TD Tara Dwyer	1
Java: find sum of array	Java	TD Tara Dwyer	0
Java: find median of array	Java	TD Tara Dwyer	0
Java: find mean of array	Java	TD Tara Dwyer	0
Java: check if all elements of array are equal	Java	TD Tara Dwyer	0
Java: N array concatenation	Java	TD Tara Dwyer	0
Java: two array concatenation	Java	TD Tara Dwyer	0
Java: linear search	Java	TD Tara Dwyer	1
Java: counting sort	Java	TD Tara Dwyer	1
Java: insertion sort	Java	TD Tara Dwyer	0
Java: selection sort	Java	TD Tara Dwyer	1
Java: bubble sort	Java	TD Tara Dwyer	7
Java: quick sort	Java	TD Tara Dwyer	0
Java: merge sort	Java	TD Tara Dwyer	0
Opening a Postgres Prompt	JavaScript	A Allmacht	0

Codiga Snippets, page 6