常用类之包装、String类笔记

常用类

1、包装类

2、String类

3、StringBuffer和StringBuilder类

4、Math类

5、Date日期类 、Calendar日历类 以及新的日期

6、System类

7、Arrays类

8、Biglnteger类和BigDecimal类

1、包装类

包装类的分类

1、针对八种基本数据类型相应的引用类型–包装类

2、有了类的特点，就可以调用类中的方法

基本数据类型	包装类
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

包装类和基本数据类型的转换

包装类和基本数据类型的相互转换

1、jdk5前的手动装箱和拆箱方式，装箱：基本数据类型—>包装类型，反之，拆箱

2、jdk5以后（含）的自动装箱和拆箱方式

3、自动装箱底层调用的是valueOf()方法，比如Integer.valueOf()

package Wrapper_;

public class Integer01 {
    public static void main(String[] args) {
        //演示int<-->装箱和拆箱
        //jdk5以前是手动装箱
        //手动装箱int--->Integer
        int n1=100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
//        System.out.println(integer);
//        System.out.println(integer1);
//        System.out.println(integer.equals(integer1));
        //手动拆箱
        //Integer--->int
        int i = integer.intValue();

        //jdk5以后就可以自动装拆箱
        int n2=200;
        //自动装箱
        Integer integer2=n2;
        //底层使用的是valueOf(n2),本质没有发生变化
        //自动拆箱
        int n3=integer2;
        //底层仍然使用的是intValue()方法
        
    }
}

下面的代码是否正确
Double d=100d;//体现自动装箱  正确
Float f=10f;//体现自动装箱  正确

包装类型和String类型的相互转换

package Wrapper_;

public class WrapperVSSTring {
    public static void main(String[] args) {
        //包装类--->String
        Integer i=100;//包装类
        //方式1
        String Str1=i+"";//i数据类型没有变化，得到以i为基本数值的一个转换---str1
        //方式2
        String str2=i.toString();
        //方法3
         String str3=String.valueOf(i);
         
         //String类--->包装类
        String str4="1234";
        //方式1
        Integer i2=Integer.parseInt(str4);
        //方式2
        Integer i3 = new Integer(str4);
    }
}

包装类的一些常用方法

1、Integer和Character类的常用方法

package Wrapper_;

public class WrapperMerhod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);//返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值
        System.out.println(Character.isDigit('a'));//判断是否是数字
        System.out.println(Character.isLetter('a'));//判断是否是字母
        System.out.println(Character.isUpperCase('a'));//判断是否是大写
        System.out.println(Character.isLowerCase('a'));//判断是否是小写
        System.out.println(Character.isWhitespace('a'));//判断是否是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写
    }
}
具体方法查看API

Integer创建机制

package Wrapper_;

public class WrapperMerhod {
    public static void main(String[] args) {
        Integer i=new Integer(1);
        Integer j=new Integer(1);
        System.out.println(i==j);//判断是否是同一个对象
        System.out.println(i.equals(j));

        //这里主要就是看范围，-128~127就是直接返回，否则就是new一个Integer(xxx)
        //如果i在IntegerCache。low（-128）~IntegerCache.high(127)就直接从数组返回，如果不在就直接new Integer(i)
        Integer m=1;//底层 Integer.valueOf(1)
        Integer n=1;
        System.out.println(m==n);//true
        Integer x=128;
        Integer y=128;
        System.out.println(x==y);//false
    }
}

package Wrapper_;

public class WrapperExercise03 {
    public static void main(String[] args) {
        Integer i1=new Integer(127);
        Integer i2 = new Integer(127);//new 出来的就是不同的对象
        System.out.println(i1==i2);//false
        System.out.println("*******************");
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3==i4);//false
        System.out.println("*******************");
        Integer i5=127;//在-128~127范围之内
        Integer i6=127;
        System.out.println(i6==i5);//true
        System.out.println("*******************");
        Integer i7=128;
        Integer i8=128;//不在范围之内
        System.out.println(i7==i8);//false
        System.out.println("*******************");
        Integer i9=127;//直接从数组里面取的
        Integer i10 = new Integer(127);//new的
        System.out.println(i9==i10);//false
        System.out.println("*******************");
        Integer i11=127;
        int i12=127;//只要有基本数据类型，判断的是值相等
        System.out.println(i11==i12);//true
        System.out.println("*******************");
        Integer i13=128;
        int i14=128;//有基本数据类型，判断的是值是否相等
        System.out.println(i13==i14);//true
    }
}

String结构刨析

String类的理解和创建对象

1、String对象是用于保存字符穿的，也就是一组字符序列

2、字符串常量对象是用双引号括起的字符序列，例如"你好"、“1200”、"ass"等

3、字符串的字符使用Unicode字符编码，一个字符（不区分字母或汉字）占两个字节

4、String类常用的构造方法,即构造器的重载

String s1=new String();
String s2=new String(String original);
String s3=new String(char[] a);
String s4=new String(char[] a, int startIndex,int count);
......

5、String类实现了接口Serializable，说明String对象可以串行化，可以在网络传输

​ String类实现了接口Comparable，说明String对象可以比较大小

6、String是final类，不能被其他类继承

7、String中有属性private fianl char value[]用于存放字符串内容

8、value是final类型，一旦赋值后不可修改（不是说数组的字符不可修该，而是说数组的地址不可修该，value不能指向新的地址，value里单个字符内容可以改变）

package String_;
/**
*value是final类型，一旦赋值后不可修改（不是说数组的字符不可修该，而是说数组的地址不可修该，value不能指向新的地址，value里单个
*字符内容可以改变）
*/
public class String01 {
    public static void main(String[] args) {
        final char[] value={'a','b','c'};//fianl修饰
        value[0]='h';//可以
        char[] value2={'t','o','m'};
//        value=value2;//无法将值赋给 final 变量 'value',不能修改地址
    }
}

String对象的两种创建方式及细节

1、方式一

直接赋值：
String s="asdjka";

2、方式二

调用构造器：
String s=new String("sdasda");

两种创建对象的区别

1、方式一：先从常量池查看时候有"asdjka"数据空间，如果有，直接指向，如果没有则创建，然后指向，s最终指向是常量池的空间地址

2、方式二：先在堆中创建空间，里面维护了value属性，指向常量池的"sdasda"空间，如果常量池中没有"sdasda"，重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址

package String_;

public class String01 {
    public static void main(String[] args) {
        String a="abc";
        String b="abc";
        System.out.println(a.equals(b));//String 的equals方法被重写,把字符串的内容取出一个一个比较
        System.out.println(a==b);//a先创建一个常量池存放abc，然后创建b的时候在常量池中判断是否存在abc，有则直接指向，所以a和b都指向一个常量池
    }
}

package String_;

public class String02 {
    public static void main(String[] args) {
        String a="abc";//a直接指向常量池中的"abc"
        String b=new String("abc");//b指向堆中的对象，堆中的对象指向常量池"abc"
        System.out.println(a.equals(b));//比较的是字符串中的内容  T
        System.out.println(a==b);//比较的是地址，a和b指向的地址不同
        /**
         * 当调用intern方法时，
         * 如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，
         * 则返回来自池的字符串。 
         * 否则，此String对象将添加到池中，
         * 并返回对此String对象的引用。
         * 
         * b.intern()最终返回的是常量池的地址
         */
        System.out.println(a==b.intern());//T
        System.out.println(b==b.intern());//F  b指向的堆，b.intern()指向的是常量池
    }
}

String对象特性

1、String对象是一个final类，代表不可变的字符序列

2、字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

package String_;

public class String03 {
    public static void main(String[] args) {
        String s1="hello";
        s1="haha";
        System.out.println(s1);
    }
}
//以上语句创建了几个对象
//第一步，现在常量池中创建"hello",s1指向，
//第二步，再在常量池中创建"haha"，解除s1指向"hello",改为指向"haha"
//所以一共创建了两个对象

package String_;

public class String03 {
    public static void main(String[] args) {
        String a="hello"+"abc";
        //编译器会优化，等价于：String a="helloabc"
        System.out.println(a);
    }
}
//所以只创建了一个对象

package String_;

public class String03 {
    public static void main(String[] args) {
        String a1="hello";
        String b1="abc";
        String c1=a1+b1;
        //1、先创建一个 StringBuilder sb=StringBuilder()
        //2、执行sb.append("hello);
        //3、执行sb.append("abc");
        //4、String c=sb.toString();
        //最后是让c指向堆中的对象（String）value -->常量池中的“helloabc”;
        System.out.println(c1);
        String d="helloabc";
        System.out.println(c1==d);//false
        String e="hello"+"abc";//直接看池 e指向常量池
        System.out.println(d==e);//true
        
    }
}
总结：
    底层是StringBuilder sb=new StringBuilder();
	sb.append(a);
	sb.append(b);
	sb在堆中，并且append是在原来字符串的基础上追加的
重要规则：
        String c1="ab"+"cd";常量相加，看的是池，
        String c1=a+b;变量相加，是在堆中    

package String_;

public class Test01 {
    String str=new String("hsp");
    final char[] ch={'j','a','v','a'};
    public void change(String str,char ch[]){
        str="java";
        ch[0]='h';
    }

    public static void main(String[] args) {
        Test01 ex = new Test01();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+"and");
        System.out.println(ex.ch);
    }
}
//输出：hspandhava

String类的常用方法

String 类是保存字符串的，每次更新都需要重新开辟空间，效率较低，因此还提供了StringBuilder 和 StringBuffer来增强String的功能，并提高效率

String s=new String("");
for(int i=0; i<80000;i++){
	s+="hello";
}
//每次不停的重新创建对象并重新指向

equals:区分大小写，判断内容是否相等
equalslgnoreCase忽略大小写的哦按段内容是否相等
length获取字符的个数，字符串的长度
indexOf获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到则返回-1
lastIndexOf获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
substring截取指定范围的子串
trim去前后空格
charAt：获取某索引处的字符，注意不能使用Str[index]这种方式

package String_;

/**
 * String常用方法
 */
public class String05 {
    public static void main(String[] args) {
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//
// 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }
// 3.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());
// 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0
// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4
// 6.substring 截取指定范围的子串
        String name = "hello,张三";
//下面 name.substring(6) 从索引 6 开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
//name.substring[0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
        System.out.println(name.substring(2,5));//ll
    }
}

toUpperCase
toLowerCase
concat
replace替换字符串中的字符
split分割字符串，对于某些分割字符，我们需要转义  比如|\\等
	案例：String poem="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦"和文件路径
compareTo比较两个字符串的大小
toCharArray转换成字符串数组
format格式字符串，%s字符串  %c字符 %d整型  %.2f浮点型
	案例:将一个人的信息格式化输出

package String_;

public class String06 {
    public static void main(String[] args) {
        String s="heLLo";
        //1、转换成大写
        System.out.println(s.toUpperCase());
        //2、转换成小写
        System.out.println(s.toLowerCase());
        String s1="12";
        //3、拼接字符串
        s1=s1.concat("34").concat("56").concat("78");
        System.out.println(s1);
        //4、替换字符串中的字符
        //s1.replace() 方法执行后，返回的结果才是替换过的.
        // 注意对 s1 没有任何影响
        String s2=s1.replace("123","abc");
        System.out.println(s1);
        System.out.println(s2);
        //5、分割字符串
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //老韩解读：
        // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        String[] split = poem.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        poem = "E:\\aaa\\bbb";
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        //6、转换成字符数组
        s="happy";
        char[] chs=s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }
        // 7.compareTo 比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回 0
        // 老韩解读
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        // 就返回 if (c1 != c2) {
        // return c1 - c2;
        // }
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        /**
         * 源码：
         * public int compareTo(String anotherString) {
         *         int len1 = value.length;
         *         int len2 = anotherString.value.length;
         *         int lim = Math.min(len1, len2);
         *         char v1[] = value;
         *         char v2[] = anotherString.value;
         *
         *         int k = 0;
         *         while (k < lim) {
         *             char c1 = v1[k];
         *             char c2 = v2[k];
         *             if (c1 != c2) {
         *                 return c1 - c2;
         *             }
         *             k++;
         *         }
         *         return len1 - len2;
         *     }
         */
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' -
// 8.format 格式字符串
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型
         *
         */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
//将所有的信息都拼接在一个字符串.
        String info ="我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我";
        System.out.println(info);
//老韩解读
//1. %s , %d , %.2f %c 称为占位符
//2. 这些占位符由后面变量来替换
//3. %s 表示后面由 字符串来替换
//4. %d 是整数来替换
//5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
//6. %c 使用 char 类型来替换
        String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
        String info2 = String.format(formatStr, name, age, score, gender);
        System.out.println("info2=" + info2);
    }
}