算法

二分法查找：

package suanfa;

public class test1
{

    public static void main(String[] args)
    {
        int p[] = { 1, 2, 3, 4, 5 };
        System.out.println(Search(p, 0, 4, 4));

    }

    /*
     * public static int BinarySerach(int[] arry,int num) { int low=0; int
     * hight=arry.length;
     * 
     * while(low <= hight) { int mid= (low+hight)/2;
     * 
     * if(num > arry[mid]) { low = mid+1; }else if(num < arry[mid]) { hight =
     * mid -1; }else { return mid; } } return -1; } *
     */

    public static int Search(int p[], int low, int height, int key)
    {
        int middle = (low + height) / 2;
        if (low <= height)
        {

            if (p[middle] == key)
            {

                return middle;
            }
            else if (p[middle] > key)
            {
                return Search(p, low, middle - 1, key);
            }
            else if (p[middle] < key)
            {
                return Search(p, middle + 1, height, key);
            }

        }

        return -1;

    }

}

 string类的常用方法：

char[] my =s.toCharArray()；//将字符串对象中的字符转换成一个字符数组

Arrays.sort(arr)  //数组进行升序排序

Arrays.toString(a) //数组转为字符串，输出【a,b,c】
//输出a,b,c
//直接构造String时转换
char[] data={'a','b','c'};
String str = new String(data);
//调用String类的方法转换
String.valueOf(char[] ch)

//字符串转化为数组
String s = "abc";
String [] arr = s.split(",");
//输出a,b,c

String s ="abc";
char [] arr=s.toCharArray();
//返回char数组
byte[] arr=s.getBytes();
//返回byte数组

char t = String.charAt(i);
//返回String下标为i的char

s.substring(int b,int e)//返回一个新的字符串，从下标b开始到下标e结束
s.substring(int b )//返回一个新的字符串，从下标b开始直到结束


//找不见返回-1
int indexOf(String str) //返回第一次出现的指定子字符串在此字符串中的索引。 
int indexOf(String str, int startIndex)//从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。 
int lastIndexOf(String str) //返回在此字符串中最右边出现的指定子字符串的索引。 
int lastIndexOf(String str, int startIndex) //从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。

concat()   连接两个字符串
trim() 去掉起始和结尾的空格

String replace(char original,char replacement)   第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换
String replace(CharSequence original,CharSequence replacement)    用一个字符序列替换另一个字符序列

String.valueOf()   转换为字符串
toLowerCase() 转换为小写
toUpperCase() 转换为大写
length() 取得字符串的长度
charAt() 截取一个字符
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

sourceStart 指定了子串开始字符的下标
sourceEnd 指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。
target 指定接收字符的数组
targetStart target中开始复制子串的下标值

getBytes()    替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()
startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束
compareTo()和compareToIgnoreCase() 比较字符串

Integer.parseInt() 把String   型转换为Int型，
Integer.valueOf()  把String   型转换为Integer型，
Integer.valueOf()   把String类型转换成Integer型，
Integer.valueOf().intValue()  把String类型转换成int类型

由 基本数据型态转换成 String

String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
String.valueOf(char c) : 将 char 变量 c 转换成字符串
String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
String.valueOf(char[] data, int offset, int count) :
将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串
String.valueOf(double d) : 将 double 变量 d 转换成字符串
String.valueOf(float f) : 将 float 变量 f 转换成字符串
String.valueOf(int i) : 将 int 变量 i 转换成字符串
String.valueOf(long l) : 将 long 变量 l 转换成字符串
String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString() 

由 String 转换成 数字的基本数据型态

比如说 String 转换成 byte
可以使用 Byte.parseByte(String s)
这一类的方法如果无法将 s 分析 则会丢出 NumberFormatException
byte :
Byte.parseByte(String s) : 将 s 转换成 byte
Byte.parseByte(String s, int radix) : 以 radix 为基底 将 s 转换为 byte
比如说 Byte.parseByte("11", 16) 会得到 17
double :
Double.parseDouble(String s) : 将 s 转换成 double
float :
Double.parseFloat(String s) : 将 s 转换成 float
int :
Integer.parseInt(String s) : 将 s 转换成 int
long :
Long.parseLong(String 

Math.abs()
//java取绝对值的函数

Random random = new Random();
random.nextInt(int n)；
//给定一个参数n，nextInt(n)将返回一个大于等于0小于n的随机数，即：0 <= nextInt(n) < n。 

//ArrayList : 
add()
remove();//返回被删除的数字
get();

快速排序

该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

void quicksort(int* a, int p,int q)
{
    int i = p;
    int j = q;
    int temp = a[p];
    
    while(i < j)
    {
        // 越过不小于基准值的数据 
        while( a[j] >= temp && j > i ) j--;
        
        if( j > i )
        {
            a[i] = a[j];
            i++;
            
            // 越过小于基准值的数据 
            while(a[i] <= temp && i < j )  i++;
            if( i < j )
            {
                a[j] = a[i];
                j--;
            }
        }        
    }
    a[i] = temp; 
    
    for(int k = p; k <= q;k++)
    {
        if( k == i ) 
        {
            printf("(%d) ",a[k]);
            continue;
        }
        printf("%d ",a[k]);
    } 
    printf("
");
    
    if( p < (i-1)) quicksort(a,p,i-1);
    if((j+1) < q ) quicksort(a,j+1,q);    
}

//编码的转换
String a=new String("中".getBytes("gb2312"),"iso-8859-1");

String a=new String("中".getBytes("iso-8859-1"));

//冒泡排序
for(int i = 0 ; i <　ａ.length；i++)
{
    for(int j = 0 ; j < a.length-1-i;j++)
     {
           if(a[j] > a[j+1])
            {
                   int temp = al[i];
                   al[i] = al[j];
                   al[j] = temp;      

            }          

      }          
}

int indexOf(String str) //返回第一次出现的指定子字符串在此字符串中的索引。 
int indexOf(String str, int startIndex)//从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。 
int lastIndexOf(String str) //返回在此字符串中最右边出现的指定子字符串的索引。 
int lastIndexOf(String str, int startIndex) //从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。
//若没找见返回-1