JavaSE阶段2_String,StringBuffer,System,Math,Arrays_ios中arrays.equals(array1, array2)-CSDN博客

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

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#)