[toc]
String
charAt方法
该方法的作用是按照索引值(规定字符串中第一个字符的索引值是0，第二个字符的索引值是1，依次类推)，获得字符串中的指定字符
String s = “abc”;
char c = s.chatAt(1);
compareTo(compareToIgnoreCase忽略大小写)方法
该方法的作用是比较两个字符串的大小，比较的原理是依次比较每个字符的字符编码
String s = “abc”;
String s1 = “abd”;
int value = s.compareTo(s1);
concat方法
使用“+”进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型
该方法的作用是进行字符串的连接，将两个字符串连接以后形成一个新的字符串
String s = “abc”;
String s1 = “def”;
String s2 = s.concat(s1);
endsWith方法
该方法的作用是判断字符串是否以某个字符串结尾，如果以对应的字符串结尾
String s = “student.doc”;
boolean b = s.endsWith(“doc”);
equals方法
该方法的作用是判断两个字符串对象的内容是否相同
String s = “abc”;
String s1 = new String(“abc”);
boolean b = s.equals(s1);
使用“==”比较的是两个对象在内存中存储的地址是否一样
getBytes方法
该方法的作用是将字符串转换为对应的byte数组，从而便于数据的存储和传输
String s = “计算机”;
byte[] b = s.getBytes(); //使用本机默认的字符串转换为byte数组
byte[] b = s.getBytes(“gb2312”); //使用gb2312字符集转换为byte数组
在实际转换时，一定要注意字符集的问题，否则中文在转换时将会出现问题。
indexOf方法
该方法的作用是查找特定字符或字符串在当前字符串中的起始位置，如果不存在则返回-1
String s = “abcded”;
int index = s.indexOf(‘d’);
int index1 = s.indexOf(‘h’);
则返回字符d在字符串s中第一次出现的位置，数值为3。由于字符h在字符串s中不存在，则index1的值是-1。
也可以从特定位置以后查找对应的字符，例如：
int index = s.indexOf(‘d’,4);
length方法
该方法的作用是返回字符串的长度，也就是返回字符串中字符的个数
String s = “abc”;
String s1 = “Java语言”;
int len = s.length();
int len1 = s1.length();
则变量len的值是3，变量len1的值是6。
replace方法replaceAll，replaceFirst
该方法的作用是替换字符串中所有指定的字符，然后生成一个新的字符串
String s = “abc”;
String s1 = “Java语言”;
int len = s.length();
int len1 = s1.length();
则变量len的值是3，变量len1的值是6。
split方法
该方法的作用是以特定的字符串作为间隔，拆分当前字符串的内容，一般拆分以后会获得一个字符串数组
String s = “abc”;
String s1 = “Java语言”;
int len = s.length();
int len1 = s1.length();
则变量len的值是3，变量len1的值是6。
startsWith方法
substring方法
String s = “Test”;
String s1 = s.substring(4);
String s = “TestString”;
String s1 = s.substring(2,5);
toLowerCase方法
trim方法
该方法的作用是去掉字符串开始和结尾的所有空格，然后形成一个新的字符串。该方法不去掉字符串中间的空格
valueOf方法
该方法的作用是将其它类型的数据转换为字符串类型
由于该方法是static方法，所以不用创建String类型的对象即可
StringBuffer
public class UsingStringBuffer {
/**
* 查找匹配字符串
*/
public static void testFindStr() {
StringBuffer sb = new StringBuffer();
sb.append("This is a StringBuffer");
// 返回子字符串在字符串中最先出现的位置，如果不存在，返回负数
System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is"));
// 给indexOf方法设置参数，指定匹配的起始位置
System.out.println("sb.indexOf(\"is\")=" + sb.indexOf("is", 3));
// 返回子字符串在字符串中最后出现的位置，如果不存在，返回负数
System.out.println("sb.lastIndexOf(\"is\") = " + sb.lastIndexOf("is"));
// 给lastIndexOf方法设置参数，指定匹配的结束位置
System.out.println("sb.lastIndexOf(\"is\", 1) = "
+ sb.lastIndexOf("is", 1));
}
/**
* 截取字符串
*/
public static void testSubStr() {
StringBuffer sb = new StringBuffer();
sb.append("This is a StringBuffer");
// 默认的终止位置为字符串的末尾
System.out.print("sb.substring(4)=" + sb.substring(4));
// substring方法截取字符串，可以指定截取的起始位置和终止位置
System.out.print("sb.substring(4,9)=" + sb.substring(4, 9));
}
/**
* 获取字符串中某个位置的字符
*/
public static void testCharAtStr() {
StringBuffer sb = new StringBuffer("This is a StringBuffer");
System.out.println(sb.charAt(sb.length() - 1));
}
/**
* 添加各种类型的数据到字符串的尾部
*/
public static void testAppend() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
sb.append(1.23f);
System.out.println(sb.toString());
}
/**
* 删除字符串中的数据
*/
public static void testDelete() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
sb.delete(0, 5);
sb.deleteCharAt(sb.length() - 1);
System.out.println(sb.toString());
}
/**
* 向字符串中插入各种类型的数据
*/
public static void testInsert() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
// 能够在指定位置插入字符、字符数组、字符串以及各种数字和布尔值
sb.insert(2, 'W');
sb.insert(3, new char[] { 'A', 'B', 'C' });
sb.insert(8, "abc");
sb.insert(2, 3);
sb.insert(3, 2.3f);
sb.insert(6, 3.75d);
sb.insert(5, 9843L);
sb.insert(2, true);
System.out.println("testInsert: " + sb.toString());
}
/**
* 替换字符串中的某些字符
*/
public static void testReplace() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
// 将字符串中某段字符替换成另一个字符串
sb.replace(10, sb.length(), "Integer");
System.out.println("testReplace: " + sb.toString());
}
/**
* 将字符串倒序
*/
public static void reverseStr() {
StringBuffer sb = new StringBuffer("This is a StringBuffer!");
System.out.println(sb.reverse()); // reverse方法将字符串倒序
}
}
System
20151213115320592.png
Math
Java中比较常用的几个数学公式的总结：
//取整，返回小于目标函数的最大整数,如下将会返回-2
Math.floor(-1.8)；
//取整，返回发育目标数的最小整数
Math.ceil()
//四舍五入取整
Math.round()
//计算平方根
Math.sqrt()
//计算立方根
Math.cbrt()
//返回欧拉数e的n次幂
Math.exp(3);
//计算乘方,下面是计算3的2次方
Math.pow(3,2);
//计算自然对数
Math.log();
//计算绝对值
Math.abs();
//计算最大值
Math.max(2.3,4.5);
//计算最小值
Math.min(,);
//返回一个伪随机数，该数大于等于0.0并且小于1.0
Math.random
Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（以当前时间作为种子），另一个构造器需要程序员显示的传入一个long型整数的种子。
Random比Math的random（）方法提供了更多的方式来生成各种伪随机数。
e.g
import java.util.Arrays;
import java.util.Random;
public class RandomTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Random rand = new Random();
System.out.println("随机布尔数" + rand.nextBoolean());
byte[] buffer = new byte[16];
rand.nextBytes(buffer);
//生产一个含有16个数组元素的随机数数组
System.out.println(Arrays.toString(buffer));
System.out.println("rand.nextDouble()" + rand.nextDouble());
System.out.println("Float浮点数" + rand.nextFloat());
System.out.println("rand.nextGaussian" + rand.nextGaussian());
System.out.println("" + rand.nextInt());
//生产一个0～32之间的随机整数
System.out.println("rand.nextInt(32)" + rand.nextInt(32));
System.out.println("rand.nextLong" + rand.nextLong());
}
}
为了避免两个Random对象产生相同的数字序列，通常推荐使用当前时间作为Random对象的种子，代码如下：
Random rand = new Random(System.currentTimeMillis());
在 java7 中引入了ThreadLocalRandom
在多线程的情况下使用ThreadLocalRandom的方式与使用Random基本类似，如下程序·片段示范了ThreadLocalRandom的用法：
首先使用current()产生随机序列之后使用nextCXxx()来产生想要的伪随机序列 :
ThreadLocalRandom trand= ThreadLocalRandom.current();
int val = rand.nextInt(4,64);
产生4～64之间的伪随机数
Arrays
[Java](http://lib.csdn.net/base/java).util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
² 给数组赋值：通过fill方法。
² 对数组排序：通过sort方法,按升序。
² 比较数组：通过equals方法比较数组中元素值是否相等。
² 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class TestArrays {
public static void output(int[] array) {
if (array!=null) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
System.out.println();
}
public static void main(String[] args) {
int[] array = new int[5];
//填充数组
Arrays.fill(array, 5);
System.out.println("填充数组：Arrays.fill(array, 5)：");
TestArrays.output(array);
//将数组的第2和第3个元素赋值为8
Arrays.fill(array, 2, 4, 8);
System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
TestArrays.output(array);
int[] array1 = {7,8,3,2,12,6,3,5,4};
//对数组的第2个到第6个进行排序进行排序
Arrays.sort(array1,2,7);
System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
TestArrays.output(array1);
//对整个数组进行排序
Arrays.sort(array1);
System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
TestArrays.output(array1);
//比较数组元素是否相等
System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));
int[] array2 = array1.clone();
System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"\n"+Arrays.equals(array1, array2));
//使用二分搜索[算法](http://lib.csdn.net/base/datastructure)查找指定元素所在的下标（必须是排序好的，否则结果不正确）
Arrays.sort(array1);
System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"\n"+Arrays.binarySearch(array1, 3));
//如果不存在就返回负数
System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："+"\n"+Arrays.binarySearch(array1, 9));
}
}
**输出结果：**
填充数组：Arrays.fill(array, 5)：5 5 5 5 5将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：5 5 8 8 5对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：7 8 2 3 3 6 12 5 4对整个数组进行排序：Arrays.sort(array1)：2 3 3 4 5 6 7 8 12比较数组元素是否相等:Arrays.equals(array, array1):false克隆后数组元素是否相等:Arrays.equals(array1, array2):true元素3在array1中的位置：Arrays.binarySearch(array1, 3)：1元素9在array1中的位置：Arrays.binarySearch(array1, 9)：-9
[](http://blog.csdn.net/object_allen/article/details/41695425#)[](http://blog.csdn.net/object_allen/article/details/41695425#)[](http://blog.csdn.net/object_allen/article/details/41695425#)[](http://blog.csdn.net/object_allen/article/details/41695425#)[](http://blog.csdn.net/object_allen/article/details/41695425#)[](http://blog.csdn.net/object_allen/article/details/41695425#)
