Pattern Analysis

This is a basic Pattern Analysis program I wrote. It's just version 0.03 so it's capabilities are very limited. Sorry for the formatting :(

Usage: Just type in one number at a time, pressing enter after each number. Type ? to calculate the next item in the list. The program clear it's memory and start over with a new sequence.

Capabilities: I can find patterns such as:
1,1,1,1,1,? (1)
1,2,3,? (4)
1,4,9,16,25,36,49,64,81,? (100) Square of each number found using spacing pattern.
7,19,37,61,91(127)
1,8,27,64,125,216(343) Cube of each number

Right now, It's fairly bad at exponents and it cant figure out the Fibonacci sequence either :(


import java.util.Scanner;
import java.util.*;
import java.io.*;


public class PatternRecognition{

public static void main(String args[])
{
System.out.println("AI Pattern Analysis Module. V 0.03");
while(true){
ArrayList intSequence = new ArrayList();
String str = getInput();
while(!str.equals("?")){
int temp = (Integer) Integer.valueOf(str);
intSequence.add(temp);
str = getInput();
}
System.out.println("Next number will be "+nextInt(intSequence));
}
}
public static String getInput()
{
Scanner input = new Scanner(System.in);
System.out.print("# :");
String inputString = input.nextLine();
return inputString;
}

public static ArrayList nextInt(ArrayList list){
ArrayList nextInt = new ArrayList();
ArrayList spaces = getSpaces(list);
if(linear(spaces)){
nextInt.add(getNextLinear(list));
System.out.println("Linear pattern found");
}

if(true){
boolean done = false;
int counter = 0;
int lastAdd = 0;
while(!done){
counter++;
if(linear(spaces)){
done = true;
//return getNextLinear(list,spaces);
lastAdd+=(Integer) spaces.get(spaces.size()-1);
int lastInList = (Integer) list.get(list.size()-1);
nextInt.add(lastInList+=lastAdd);
System.out.println("Spacing pattern found");
}
else{
lastAdd+=(Integer) spaces.get(spaces.size()-1);
ArrayList sp2 = copyArray(spaces);
spaces = getSpaces(sp2);
}
}

}

int sequenceWidth = repeatingCheck(list);
if(sequenceWidth > 0){
// System.out.println("Sequence repeats every "+sequenceWidth+" digits.");
nextInt.add(getNextRepeating(list,sequenceWidth));
System.out.println("Sequential pattern found");
}

return nextInt;
}

public static ArrayList copyArray(ArrayList list){
ArrayList rtrn = new ArrayList();
for(int k = 0; k < list.size(); k++){
rtrn.add(list.get(k));
}
return rtrn;
}

public static ArrayList getSpaces(ArrayList list){
ArrayList spaces = new ArrayList();
int previous = 0;
for(int k = 0; k < list.size(); k++){
int i = (Integer) list.get(k);
if(k == 0){ previous = i;} // Initialize previous
else{
spaces.add(i-previous);
previous = i;
}
}
return spaces;
}

// Checks if it's a set of evenly spaced numbers
public static boolean linear(ArrayList list){
if(list.size() >= 1){
int reference = (Integer) list.get(0); // Initialize a default value for space
for(int k = 1; k < list.size(); k++){ // starts at 1 because 0 is init value
int i = (Integer) list.get(k);
if(i != reference){ return false;}
}
}
return true;
}

public static int getNextLinear(ArrayList list){
if(list.size() >= 2){
int i1 = (Integer) list.get(0);
int i2 = (Integer) list.get(1);
int difference = i2-i1;
int rtrn = (Integer) list.get(list.size()-1);
rtrn += difference;
return rtrn ;
}
else if(list.size() >= 1){return (Integer)list.get(0);}
else{return 0; }
}

public static int repeatingCheck(ArrayList list){
ArrayList sequence = new ArrayList();
boolean repeating = false;
boolean oneRepeat = true;

sequence.add(list.get(0));
for(int k = 1; k < list.size()-1; k++){
if(repeating(list,sequence)){
return k;
}
else{
sequence.add(list.get(k));
}
}
return 0;
}

public static boolean repeating(ArrayList list, ArrayList sequence){
int k2 = 0;
for(int k = 0; k < list.size(); k++){
int l = (Integer) list.get(k);
int s = (Integer) sequence.get(k2);

k2++;
if(k2 > sequence.size() -1){ k2=0; }

if(l != s){ return false; }
}
return true;
}

public static int getNextRepeating(ArrayList list, int sequenceWidth){

if(list.size() > sequenceWidth){
ArrayList sequence = new ArrayList();
for(int k = 0; k < sequenceWidth; k++){
sequence.add(list.get(k));
}

int k2 = 0;
for(int k = 0; k < list.size(); k++){
int l = (Integer) list.get(k);
int s = (Integer) sequence.get(k2);

k2++;
if(k2 > sequence.size() -1){ k2=0; }

}
return (Integer)sequence.get(k2);
}
return 0;
}
}



How can I improve this???