StringManipulator

Object
- StringManipulator

```
public class StringManipulator
extends Object
```
StringManipulator contains a series of methods to manipulate a String by either running a Caesar Cipher on it, runlength encodes it, or uses a lossy compression algorithm that removes vowels. As every method is self contained, every method in this class is static. It is mean simply to provide helper functionality to other classes.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`OPTIONS` An contains the String "Cipher,Encode,Compress" for use in other classes
`static String`	`VOWELS` Contains the String "aeiouAEIOU" for use in stringCompress

Constructor Summary

Constructors
Constructor and Description

StringManipulator()

Constructors
Constructor and Description
`StringManipulator()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static String`	`encrypt(String msg, int shift)` Performs a simple Caesar Cipher on msg and returns the result.
`static void`	`main(String[] args)` By itself, this main simply tests the various methods in StringManipulator.java.
`static String`	`manipulate(String msg, String type)` Called to determines which type of String manipulation to perform, and then returns the manipulated String.
`static String`	`runLengthEncoding(String msg)` This method takes sequences of the same character in a String and represents that sequence as the number of same characters in a row followed by that character.
`static String`	`stringCompress(String msg)` Remove all `VOWELS` from another String, unless the vowel starts a word.

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - OPTIONS
```
public static final String OPTIONS
```
    An contains the String "Cipher,Encode,Compress" for use in other classes
    
    See Also:
    
    Constant Field Values
  - VOWELS
```
public static final String VOWELS
```
    Contains the String "aeiouAEIOU" for use in stringCompress
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - StringManipulator
```
public StringManipulator()
```
- Method Detail
  - encrypt
```
public static String encrypt(String msg,
                             int shift)
```
    Performs a simple Caesar Cipher on msg and returns the result. A simple Caesar Cipher simpy takes the characters of a string, and shifts them by the number in shift. It does not loop, or worry if the character is a valid character. For example:
```
     encrypt("A", 2) return "C"
     encrypt("Ada", 3) returns "Dgd"
 
```
    --- Implementation Hints
    - Remember, you can add ints to characters (in your knowledge checks)
    - You need to 'cast' back to a char after adding. For example, (char)(myChar+shift) (notice parens - they matter)
    - first, just make sure you can loop through the entire string without the shift essentially copying it, then figure out the shift.
    Parameters:
    
    msg - the string to manipulate
    
    shift - the amount of Caesar shift to do (can be in either direction)
    
    Returns:
    
    a string that has been hidden in the cipher.
  - main
```
public static void main(String[] args)
```
    By itself, this main simply tests the various methods in StringManipulator.java. It is possible to have multiple main methods in programs as different entry points, and they can often be used to test functionality of a class - to confirm correctness before moving onto other classes to implement.
    Students! You must implement this main with some test methods, as this is a good practice to develop, that will greatly help later projects. In this case, we are going to be specific on the minimum things you should implement, but it will not hurt your grade doing additional tests (which you should!)
    The output (System.out.println) for your test methods should contain at a minimum the following lines. We will test each group separately, so please add your own tests freely.
```
 Testing encrypt
     TEST: encrypt("A", 2) returns C - true
     TEST: encrypt("Ada", 3) returns Dgd - true
 Testing stringCompress
     TEST: stringCompress("You can be a good programmer, if you can read this.") returns Y cn b a gd prgrmmr, if y cn rd ths. - true
     TEST: stringCompress("HA AH HA AH") returns H AH H AH  - true
 Testing runLengthEncoding
     TEST: runLengthEncoding("AAA") returns 3A - true
     TEST: runLengthEncoding("AAA BBB") returns 3A1 3B - true
 
```
    How to write a test method, here are a couple samples we wrote
```
     
        System.out.println("\tTEST: encrypt(\"A\", 2) returns C - " + encrypt("A", 2).equals("C"));
        System.out.println("\tTEST: runLengthEncoding(\"AAA\") returns 3A - " + runLengthEncoding("AAA").equals("3A"));
     
 
```
    Suggestion: write one method, completely test it before moving onto the next
    Parameters:
    
    args - not used, but needed for correctness.
  - manipulate
```
public static String manipulate(String msg,
                                String type)
```
    Called to determines which type of String manipulation to perform, and then returns the manipulated String. Takes in both a the string to manipulate (msg) and the type of manipulation to perform. It assumes the type has already been forced to lower case, causing the options to be
    - cipher:N - where N is a number
    - encode
    - compress
    It does not assume consistency or validity of the string. As such, calling methods should check for potential errors before submitting the string to be manipulated. If the type of manipulation is unknown, it defaults to compress.
    cipher:N
    Runs the encrypt(String, int) method, using msg, and a shift defined by any value after the colon (:). For example: "cipher:2" would call encrypt(msg, 2).
    
    encode
    Runs the runLengthEncoding(String) method using msg.
    
    Compress
    Runs the lossy compression method stringCompress(String) method using msg.
    
    --
    Implementation suggestions include:
    - indexOf(":") - will be useful, but careful for an OB1 error!
    - parseInt(String) - will be useful
    - this is mainly an if check with some string manipulation. All the real work is done in other methods.
    Parameters:
    
    msg - the string to manipulate
    
    type - the type of manipulation to perform
    
    Returns:
    
    the manipulated String
  - runLengthEncoding
```
public static String runLengthEncoding(String msg)
```
    This method takes sequences of the same character in a String and represents that sequence as the number of same characters in a row followed by that character. For example:
```
 "BBBWWWWWB", becomes "3B5W1B".
 "AAAAA BBB", becomes "5A1 3B".  (notice the space)
 
```
    This is a simple implementation, and does not encode any number characters. (read: you can ignore those cases, we won't test strings with numbers in them.
    
    --- Implementation Suggestions:
    - this requires an if statement inside of the loop
    - if you the character you are looking at matches the character before it, increment a counter
    - else store the counter plus the character you are tracking (often the character before) into the output string, reset counter
    - It helps if you set the counter to 0 before you start the loop
    - you will have a final action after the loop, that takes the counter plus the last character of the string
    - Try writing this in sections. Can you simply count the characters?
    - You are more interested when the characters are different, than when they are the same!
    - Make sure to work this out on paper first! This is logically hard, but not very many lines to implement
    This is a CHALLENGE goal. We will not grade the correctness of this method, just that you attempted it (so make sure it compiles).
    Parameters:
    
    msg - A String representing the String to encode.
    
    Returns:
    
    A String representing the encoded version of the original String.
  - stringCompress
```
public static String stringCompress(String msg)
```
    Remove all VOWELS from another String, unless the vowel starts a word. Systematically removes all VOWELs from a line, and returns a new string. This method does not ignore case and does not remove a character if it is the 'start' of a word after a space.
    Example:
```
   You can be a good programmer, if you can read this.
  
```
    Gets converted to
```
   Y cn b a gd prgrmmr, if y cn rd ths.
 
```
    Implementation hints:
    - You are looping through the entire string, looking at each character individually. Check to make sure you can print the whole String out character by character.
    - Make sure to track the 'previous' character to check that it isn't a space before removing the character you are on.
    - Take it in parts. Write a few lines of code, run it, write a few run it. You won't have it right, but you can make sure you are getting what you want.
    - A few methods that will help.
      
      String.valueOf(char) can be useful to convert a character to a string for contains
      
      VOWELS.contains(String) Remember, contains requires Strings not characters to work.
      
      Character.isWhitespace(char) Able to check any spacing.
    Parameters:
    
    msg - A String representing the String to check for matching characters.
    
    Returns:
    
    A String with characters removed.

Class StringManipulator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

OPTIONS

VOWELS

Constructor Detail

StringManipulator

Method Detail

encrypt

main

manipulate

runLengthEncoding

stringCompress