相关类以及常用方法

1、system：(系统相关类）

常用方法：

a)       : system.arraycopy(制定数组，开始复制的位置，目标数组，开始粘贴的位置，需要复制的长度) 。

将指定源数组中的数组从指定位置复制到目标数组的指定位置。

a)       :System.currentTimeMIllis返回当前时间（以毫秒为单位）。

该方法返回值类型为long 所以调用结果用long类型变量接收。

b)       ：System.exit（int status）终止当前最正在运行的Java虚拟机，参数作状态码，按照惯例非0表示异常终止。

2、(数学相关类）

一 . Math类

a)       Math：Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

随机数生成: double random();返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。需要生成随机数的范围0-X,便在随机数后面*X然后进行强制转换.

b)       BigDecimal：float/double都不能表示精确的小数，此时使用BigDecimal，用于处理经前和精度要求较高的数据。

c)       BigInteger：表示大整数，如果两个long类型的足大指运算，结果long储存不下，此时使用BigInteger，一般不用。（因为long的数据范围已经够大了）

加减乘除方法和bigdecimal相同。

二 . Random类

 

随机数生成: nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

3、字符串相关类

字符串的分类：

不可变的字符串：（String）当对象创建完毕之后，该对象的内容是不可改变的。一旦内容改变就是一个新的对象。

可变的字符串：（StringBuilder/StringBuffer），当对象创建完毕之后，该对象的内容发生改变的时候，对象保持不变。

一、：String类：不可变的字符串。内容改变后相对应的内存地址也改变了。所以就相当于一个新的对象。

常量池：抓们储存常量的地方，都指的方法区中。

编译常量池：把字节码加载进JVM的时候，储存的是字节码的相关信息。

运行常量池：储存常量数据（研究）。

-------------------------------------------------------------------------------

面试题：

1、下列代码中分别创建了几个String对象

String  str   =  “asdf”;     

最多创建一个String对象,最少不创建String对象

如果在常量池中已经存在“asdf”，那么str直接引用，此时不创建String对象。

否则，现在常量池创建“asdf”内存空间，在引用。

String  str1  =  new  String(“asdf”);

最多创建两个String对象，至少创建一个string对象。

New关键字：绝对会在堆空间创建内存区域，所以至少创建一个对象。

2、:判断下列代码创建了几个String对象,彼此直接是否相等.

   String str1 = "ABCD";

   String str2 = "A" +"B"+"C"+"D";  编译器优化之后,该代码等价于 str1.

   String str3 = "AB"+"CD";

   String c = "CD";

   String str4 = "AB" + c;

   String str5 = "AB" + getXX();  (备注:getXX方法返回"CD");

   String str6 = new String(“ABCD”)

用==判断：   str1 == str2 ? // true

str1 == str3 ?   //true

str1 == str4 ?   //false

str1 == str5 ?   //false

str1 == str6 ?   //false

-----------------------------

 

String对象比较:

1）：单独使用""引号创建的字符串都是直接量,编译期就已经确定存储到常量池中；

2）：使用new String("")创建的对象会存储到堆内存中,是运行期才创建；

3）：使用只包含直接量的字符串连接符如"aa" + "bb"创建的也是直接量编译期就能确定,已经确定存储到常量池中；

4）：使用包含String直接量(无final修饰符)的字符串表达式(如"aa" + s1)创建的对象是运行期才创建的,存储在堆中；

通过变量/调用方法去连接字符串，都只能在运行时期才能确定环境变量的值和方法的返回值，不存在编译优化操作。

-----------------------------

比较字符串:  ==:只能比较内存地址,若要比较内容:equals.

String类中的常用方法：

public class StringDome {
public static void main(String[] args) {
String str1 = "ABCD";
String str2 = "A" +"B"+"C"+"D"; //编译器优化之后,该代码等价于 str1.
String str3 = "AB"+"CD";
String c = "CD";
String str4 = "AB" + c;
String str5 = "AB" + getXX(); //(备注:getXX方法返回"CD");
String str6 = new String("ABCD");
//用==判断：
System.out.println(str1 == str2); // true
System.out.println(str1 == str3); //true
System.out.println(str1 == str4 ); //false
System.out.println(str1 == str5); //false
System.out.println(str1 == str6); //false
System.out.println(str1.equals(str2)); // true
System.out.println(str1.equals(str3)); // true
System.out.println(str1.equals(str4)); // true
System.out.println(str1.equals(str5)); // true
System.out.println(str1.equals(str6)); // true
String name ="";
System.out.println(StringUtil.judgeString(name));

}

private static String getXX() {

return "CD";
}
}

---------------------------------------------------------------------------------------------------------------------------------

public class StringDome2 {

public static void main(String[] args) {
testString();
gainStringPrice();
capitalized();

}
private static void capitalized() {
/**
* toLowerCase() 将所有在此字符 String使用默认语言环境的规则，以小写。
* toUpperCase() 将所有在此字符 String使用默认语言环境的规则大写。
*/
System.out.println("ASSxsdfhsDSF".toLowerCase());
System.out.println("ASSxsdfhsDSF".toUpperCase());

}
private static void gainStringPrice() {
/**
* 获取字符串信息:
* int length();获取字符串长度
* char charAt(int index);返回index索引处的值。
* int index (String str);返回指定子字符串第一次出现的字符串内的索引。
* int lastIndexOf(int ch)返回指定字符的最后一次出现的字符串中的索引。
*/
String read = "ASDFGHJKDL";
System.out.println(read.length());
System.out.println(read.charAt(2));
System.out.println(read.indexOf("DF"));
System.out.println(read.lastIndexOf("KD"));

}
/**
* 把String字符串转换成byte数组 Byte [] a = getBytes(x);
* 把String字符串转换成char数组 Byte [] a = x.toCharArray();
* 把byte数组转换成String字符串 String x = new String(byte数组名);
* 把char数组转换成String字符串 String x = new String(char数组名);
*/

private static void testString() {
//byte数组与String之间的相互转换。
byte [] a = {'3','b','d','f','9'};
String x = new String(a);
System.out.println(x);
byte [] b = x.getBytes();
System.out.println(Arrays.toString(b));
//char数组与String之间的相互转换
char [] c = {'a','s','d','f'};
x = new String(c);
System.out.println(x);
char []ds = x.toCharArray();
System.out.println(Arrays.toString(ds));

}

}

判断字符串是否包含指定字符串

        boolean contains(CharSequence s)//CharSequence此处代表字符串

        int indexOf(String str);返回字符串出现的第一次的索引,字符串里没有指定的字符串则返回-1.

 

分别用String、StringBuider、StringBuffer拼接50000次字符串，对比各自损耗的时间。

经过测试：

String做字符拼接的时候性能极低，原因是string是不可变的，内次内容改变都会在内存中创建新的对象。

String 耗时1315ms

StringBuider 耗时 1ms

StringBuffer 耗时 3ms

结论：以后拼接字符，统统使用StringBuider / StringBuffer，不要使用string.

StringBuider 和 StringBuffer都表示可变的字符串，功能方法都是相同的。

唯一区别：

StringBuffer ：StringBuffer中的方法名都使用了synchronized修饰符，表示同步的，在多线程并发的时候可以保证线程安全。（保证线程安全，性能也就降低了）

StringBuider（建议使用）：StringBuider中的方法没有使用synchronized修饰。不安全，但是性能较高。

使用StringBuider无参数构造器，在底层创建了一个长度为16的char数组。

Char [] array = new StringBuider(16);

此时该数组只能储存16个字符，如果超过了得自动扩容。

自动扩容（创建长度更大的数组，在把之前的数组拷贝到新数组）

用Stringbuider创建一个长度为60的char数组：

char [] arr = new StringBuider(60);

---------------------------

常用方法：

1、append（Object obj）：表示增加任意数据类型。

2、insert(int offset,Object obj)将 Object 参数的字符串表示形式插入此字符序列中。

3、StringBuffer delete(int start,int end) 删除此序列的子字符串中的字符。 子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。 如果start等于end ，则不作任何更改。