Java的第一遍学习笔记 常用类1

包装类（封装类型）

针对八种基本定义相应的引用类型——包装类。有了类的特点，就可以调用类中的方法。

 

装箱与拆箱

    在JDK5之前，进行的是手动的装箱与拆箱。所谓装箱，就是进行 int -> Integer 的转换，而拆箱就是 Integer -> int 之间的转换（其它基本元素类似）。

        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1); //手动装箱(把基本数据变成对象)

        int n2 = integer.intValue(); // 手动拆箱

  在JDK5后，就可以自动装箱和自动拆箱。自动将一个原始数据类型转换为一个封装类型称为自动装箱，自动将一个封装类型转换为一个原始数据类型被称为自动拆箱。

        int n1 = 100;
        Integer integer = n1; //自动装箱，底层使用的是 Integer.valueOf(n1)方法
        int n2 = integer; //自动拆箱，底层使用的是 intValue()方法

Object obj1 = true?new Integer(1):new Double(2.0);
System.out.println(obj1);  //最大精度为double，输出1.0

       注意输出的是1.0而不是1，因为三元运算符是一个整体，在执行时会把所数据类型的精度上升到最大的那个。

Object obj1 = true?new Integer(1):new Integer(2);
System.out.println(obj1); // 最大精度为int，输出1

Integer与String相互转换

Integer -> String：

        Integer n = 100;
        String str1 = n + "";  // 第一种方法
        String str2 = n.toString(); // 第二种方法
        String str3 = String.valueOf(n); // 第三种方法

String -> Integer：

        String str = "12345";   
        Integer n1 = Integer.parseInt(str);  //第一种方法
        Integer n2 = new Integer(str);   // 第二种方法，构造器
        Integer n3 = new Integer(str);  // 第三种方法

常用方法 

Integer创建机制

    public static void main(String[] args) {
        Integer a = new Integer(1);
        Integer b = new Integer(1);
        System.out.println(a==b);  //a和b都是new出的对象，地址肯定不相同
        Integer m = 1;  //底层是Integer.valueOf
        Integer n = 1;
        System.out.println(m==n);

        Integer x = 128;
        Integer y = 128;
        System.out.println(x==y);
    }

  对于使用 Integer.valueOf 创建的对象，注意 m和n 与 x和y 之间的区别：当使用自动装箱时，底层调用的是Integer的valueOf方法，它会根据传入数值的大小决定是否new一个对象。 

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)  //low是-128,high是127
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    通过查看源码得知，如果传入的参数在 -128~127之间，不会创建新的对象，而是直接调用内部数组cache，返回一个数（但还是Integer对象，只不过地址相同）。而在其他范围的参数就会new一个新对象。 

   因此m和n是一个相同的Integer对象。而x和y则是地址不同的对象。

  如果基本数据类型和类比较是否相等，那么就比较数值是否相等。 

    public static void main(String[] args) {
        Integer n1 = 127;
        int n2 = 127;
        System.out.println(n1==n2);  //true
        Integer n3 = 128;
        int n4 = 128;
        System.out.println(n3==n4);  //true
    }

String类

串行化：可以在网络传输。 

基本信息

1. String 对象用于保存字符串，也就是一组字符序列。

2. 字符串常量就是双引号括起的字符序列，比如 "jack"。

3. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节。

4. String 类有很多构造器。

String s5 = new String(byte[] b);

5. String是final类，不能被其他的类继承。

6. String 有属性 private final char value[] 用于存放字符串内容（所以本质还是字符数组）。注意value是final类型，由于数组名相当于数组首地址，因此value不能指向新的地址，但是单个字符内容是可以变化的。

创建方式

方式一：先从常量池查看是否有 "hsp" 数据空间，如果有，字符串直接指向该空间。如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址。

方式二：先在堆中创建空间，里面维护了value属性，如果常量池里有 "hsp"，value指向常量池的"hsp"地址。如果常量池没有 "hsp"，重新创建，然后再指向。s2 最终指向的是堆中的空间地址。

综合训练  P497 

String 对象特性

String s1 = "hello";
s1 = "haha";

       一共创建了两个对象，"hello"与"haha"，值得注意的是，上面说的String的value属性是final类型，不能更换地址，指的是"hello"与"haha"不能更换地址。这两个才是String对象，而s1只是一个指向String对象的指针罢了，因此s1可以指向不同的对象，而"hello"和"haha"并不能更换地址。

String a = "hello" + "abc"; // 字符串常量相加

 创建了一个对象。String a = "hello" + "abc"  会被优化等价于  String a = "helloabc"。对于这种字符串常量相加的情况，编译器会自动优化，然后就等价于一个新的字符串常量对象赋给指针。

String a = "hello";
String b = "abc";
String c = a + b; //字符串对象相加

 对于字符串对象相加，最关键的问题就是分析出 String c = a + b是怎么执行的。

// 底层是
StringBuilder s = new StringBuilder();
s.append(a);
s.append(b);
c = s.toString();

 public String toString() {  
        return new String(value, 0, count);  //截取 0~count-1
 }  

  底层是创建了一个 StringBuilder类，调用append方法把几个字符串对象相加，然后再调用toString方法返回一个新的字符串对象给c。

重要规则：String c1 = "ab" + "cd"; 常量相加，c1指向的是常量池中的地址。 String c2 = a + b; 对象相加，c2指向的是堆中的地址（对象地址）。

因此总共创建了三个对象（a,b,c分别对应的String，StringBuilder类调用后就销毁了）

public class Test {
    String str = new String("hsp");
    final char[] ch = {'j','a','v','a'};
    public void change(String str,char ch[]){ //注意str是形参，不同于真正的str
        str = "java";
        ch[0] = 'h';
    }
    public static void main(String[] args) {
        Test ex = new Test();
        ex.change(a.str,a.ch);
        System.out.println(ex.str + "  " + ex.ch);
    }
}

    分析： 主方法创建了一个Test对象，ex为对象指针，在栈中。对象实体在堆中。而在对象实体里，str为String类指针，指向String类的value属性，而value又指向常量池中的 "hsp"。ch是一个数组指针，指向堆中的数组。

    然后调用ex的change方法，会在栈中开辟一个方法区，在方法区中，str和ch都是形参(当然也可以改名)， str本来指向value， 更改后指向常量池中的"java"（但原先的str没变化！仍然指向value），但ch因为也指向字符数组，因此修改之后保持同步。调用完方法后，形参被销毁。

    最终输出 hsp  hava

String类常用方法

 

String format = String.format("%s,%s .%c",name,job,id);
System.out.println(format);

注：如果想对String进行操作，应该先用 toCharArray 方法把String转化成一个字符数组，对这个字符数组进行操作后再转换为String。

String str = "abcdef";
char[] chars = str.toCharArray(); //字符串转换为字符数组
......     // 对字符数组进行一系列操作
String str1 = new String(chars);  // 由字符数组建立一个新数组

StringBuffer

基本介绍

StringBuffer的父类有value属性用于存放字符串，这个value不是final的。

String与StringBuffer

 StringBuffer里的value属性只有在内存不够需要另外开辟空间时，才会更改指向。

构造器

对于第四种方法，数组大小为 指定的字符串长度 + 16 。

String与StringBuffer相互转换

String转StringBuffer：

// 第一种方式：直接调用构造器        
String str = "青眼究极龙";
StringBuffer ss = new StringBuffer(str);

// 第二种方式：用append方法 （前提是先new出一个StringBuffer对象）
StringBuffer ss2 = new StringBuffer();
ss2 = ss2.append(str);

StringBuffer转String：

// 第一种方式：StringBuffer的 toString方法
String s = ss.toString();
// 第二种方式：直接调用构造器
String s1 = new String(ss);

常用方法 

// append方法
StringBuffer a = new StringBuffer("Hello");
a.append(",World").append("!");  //可以连续调用
System.out.println(a);   // Hello,World!

String str = null;
StringBuffer ss = new StringBuffer();
ss.append(str);  //底层调用的是 父类的 appendNull方法，传入null时自动转化为字符串
System.out.println(ss.length()); // 输出4
System.out.println(ss); //输出 null
StringBuffer ss2 = new StringBuffer(str); //底层调用 super(str.length()+16);  
                                          //抛出 NullPointerException

// delete方法 删除[a,b)的元素
StringBuffer b = new StringBuffer("AAABBBBCC");
System.out.println(b.delete(3,7)); // 删除区间 [3,7)的元素 输出 AAACC

// replace方法 把[0,4)的字符串替换为指定字符串
StringBuffer c = new StringBuffer("BlueEyes");
System.out.println(c.replace(0,4,"Red")); //输出 RedEyes

// indexOf方法，返回字串第一次出现的位置
StringBuffer d = new StringBuffer("AAAC");
System.out.println(d.indexOf("AAA")); //输出0
// insert方法，在指定索引插入指定字符串
System.out.println(d.insert(0,"qqq"));//在索引为0的位置插入字符串，其他的后移 AAACqqq

StringBuilder

3. 实现了 Serializable，说明StringBuilder对象是可以串行化（对象可以网络传输，可以保存到文件）。

4. StringBuilder对象字符序列仍然是存放在其父类的 char[] value。因此字符序列是在堆中。

5. StringBuilder的方法没有做互斥处理（没有synchronized关键字），因此应在单线程的情况下使用。

String,StringBulider,StringBuffer比较

效率：

StringBuilder > StringBuffer > String

基本概念：

复用率 —— 可以有多个指针指向String。

使用原则：

注意事项：