1. Create a Java program. 2. The class name for the program should be 'EncryptTextMethods'.
3. In the program you should perform the following:
* You will modify the EncryptText program created in a previous assignment (see code below).
* You should move the logic for encrypting text from the main method into a method named encryptString.
* The encryptString method should have a single String argument and return a String value.
1. Create a second method.
2. The name of the method should be decryptString.
3. In the program you should perform the following:
* The method should have a single String argument and return a String value.
* This method should reverse the encryption process by subtracting one from each character in the String argument passed to it.
* The return value should be the result of the decrypting process.
4.The program should read an input String using the Scanner method.
5. The input value should be passed to the encryptString() method and the encrypted string should be passed to the decryptString() method.
6. The program should output the input string, the encrypted string and the decrypted string.
// Existing Code
import java. util. Scanner;
public class EncryptText {
private static String encodeMessage(String message) {
//convert string to character array
char stringChars[] = message. toCharArray();
//for each character
for(int i=0; i< stringChars. length; i++) {
char ch = stringChars[i];
//if character within range of alphabet
if(ch <= 'z' && ch >= 'a') {
//obtain the character value
//add 1 to the integer value
//enter modulus by 26 since z will become a
//once again add the remainder to 'a'
stringChars[i] = (char)('a' + ((int)(ch - 'a') + 1) % 26 );
}
}
//construct the string message
return String. valueOf(stringChars);
}
public static void main(String[] args) {
Scanner keyboard = new Scanner(System. in);
System. out. println("Please enter text to encode: ");
String message = keyboard. nextLine();
message = message. toLowerCase();
System. out. println("Encoded: " + encodeMessage(message));
keyboard. close();
}
}

Explanation:

The following code was written in Java and follows all of the instructions provided. Some instructions were most likely written incorrectly as following them made no sense and would not allow the program to run. Such as placing the main method code into the encryptString method. Since the code inside the main method needed to stay inside the main method for the program to function accordingly. The code that most likely needed to be moved was the EncryptText code to the encryptString method.

package sample;

import java.util.Scanner;

class EncryptTextMethods {

   private static String encryptMessage(String message) {

       //convert string to character array

       char stringChars[] = message.toCharArray();

       //for each character

       for(int i=0; i< stringChars.length; i++) {

           char ch = stringChars[i];

           //if character within range of alphabet

           if(ch <= 'z' && ch >= 'a') {

           //obtain the character value

           //add 1 to the integer value

           //enter modulus by 26 since z will become a

           //once again add the remainder to 'a'

               stringChars[i] = (char)('a' + ((int)(ch - 'a') + 1) % 26 );

           }

       }

       //construct the string message

       return String.valueOf(stringChars);

   }

   public static String decryptString(String message) {

       char stringChars[] = message.toCharArray();

       String decrypted = "";

       for (int x = 0; x < stringChars.length; x++) {

           int charValue = stringChars[x];

           decrypted += String.valueOf( (char) (charValue - 1));

       }

       return decrypted;

   }

   public static void main(String[] args) {

       Scanner keyboard = new Scanner(System.in);

       System.out.println("Please enter text to encode: ");

       String message = keyboard.nextLine();

       message = message.toLowerCase();

       String encrypted = encryptMessage(message);

       String decrypted = decryptString(encrypted);

       System.out.println("Original Message: " + message);

       System.out.println("Encrypted: " + encrypted);

       System.out.println("Decrypted: " + decrypted);

       keyboard.close();

   }

}

answer: internal fragmentation is the difference between the (fixed) size of a memory hole and the data within in that memory. for example, if a 1,024 byte block of memory holds 800 bytes of data, then the 224 bytes difference is considered lost to internal fragmentation.

external fragmentation occurs when the sum of memory fragments is large enough to satisfy a request, but the holes are non-contiguous and the request cannot be satisfied. this can occur when memory is dynamically allocated and freed.

explanation: