day12

day12

一、StringBuilder

是一个可变的字符串。

StringBuilder 上的主要操作是 appendinsert 方法,可重载这些方法,以接受任意类型的数据。

1.1 为什么使用StringBuilder
public class Demo {

    public static void main(String[] args) {

        /*
            因为字符串String,都是常量,并且它们的值在创建之后不能更改。
            那么下方的代码就创建了3个常量,分别为"Hello"、"World"、"HelloWorld"

            以上这种操作,既浪费了空间,也浪费了时间。很不好,所以Java提供了一个新的类StringBuilder来改善

            StringBuilder是一个可变的字符串
         */
        String s = "Hello";
        s += "World";
        System.out.println(s);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5S5rnY0q-1620344684859)(img/image-20210421104549338.png)]

1.2 StringBuilder和String的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qAH8kgL9-1620344684862)(img/image-20210421105418071.png)]

1.3 构造方法
StringBuilder() 
StringBuilder(String str) 
    
注意:
    length()  	获取StringBuilder中字符的个数
    capacity()	获取StringBuilder的容量
public class Demo2 {

    public static void main(String[] args) {

        //StringBuilder()   创建一个StringBuilder对象,并且默认有16的容量
//        StringBuilder sb = new StringBuilder();
//
//        System.out.println(sb);              //
//        System.out.println(sb.length());     //0
//        System.out.println(sb.capacity());   //16

        //StringBuilder(String str)     创建一个StringBuilder对象,初始容量为16+str的长度
        StringBuilder sb = new StringBuilder("abcd");

        System.out.println(sb);             //abcd
        System.out.println(sb.length());    //4
        System.out.println(sb.capacity());  //20

    }
}
1.3 常见方法
添加和插入方法
append  添加
insert  插入

注意:
	1. 因为append方法的返回值是StringBuilder类型,实际上返回的是该类的对象,所以我们可以在append方法后面继续使用append方法,这种方式叫做”链式编程“。
	2. StringBuiler的默认容量为16,如果超过了这个容量,那么会自动扩容。扩容后的大小为 原来的容量*2 + 2 
    3. append和insert方法,有很多重载,可以接收任意数据类型(包括所有基本数据类型和引用数据类型)
public class Demo3 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

        StringBuilder sb1 = sb.append("abcd");
        StringBuilder sb2 = sb1.append("666");

        /*
            此处证明,StringBuilder使用append添加之后返回的对象和原来的StringBuilder对象是同一个(而不是一个新的对象)
            所以,我们以后可以全部通过同一个对象添加即可。
            如:
            sb.append("abcd");
            sb.append("6666");

            甚至可以写为:
            sb.append("abcd").append("6666");
            这种方式也被称为链式编程
         */
        System.out.println(sb == sb1);      //true
        System.out.println(sb1 == sb2);     //true

        /*
            因为sb和sb1和sb2实际上是同一个对象(也就是地址相同),所以都可以访问到容器中的内容abcd666
         */
        System.out.println(sb);     //abcd666
        System.out.println(sb1);    //abcd666
        System.out.println(sb2);    //abcd666
    }
}

public class Demo4 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        sb.append("HelloWorld");

        /*
            通过以下实验,我们发现了insert可插入的位置 从0到 索引+1
         */
//        sb.insert(0, "Java");   //JavaHelloWorld
//        sb.insert(1, "Java");   //HJavaelloWorld

//        sb.insert(9, "Java");   //HelloWorlJavad
//        sb.insert(10, "Java");  //HelloWorldJava

//        sb.insert(11, "Java");  //运行报错。 StringIndexOutOfBoundsException

        sb.insert(0, "Java").insert(0, "China").append("666");  //ChinaJavaHelloWorld666

        System.out.println(sb);


    }

}
删除功能
StringBuilder deleteCharAt(int index)  
StringBuilder delete(int start, int end)  
public class Demo5 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        sb.append("HelloWorld");

        //StringBuilder deleteCharAt(int index)      删除指定索引index处的字符
//        sb.deleteCharAt(0);
//        System.out.println(sb);   //elloWorld

        //StringBuilder delete(int start, int end)   删除从索引start开始到索引end结束中间的字符(包括start,但是不包括end)
        sb.delete(2, 5);
        System.out.println(sb);     //HeWorld
        
    }
}
替换和反转功能
StringBuilder replace(int start, int end, String str)  
StringBuilder reverse()  
public class Demo6 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        sb.append("HelloWorld");

        //StringBuilder replace(int start, int end, String str)
//        sb.replace(2, 5, "China");
//        System.out.println(sb);     //HeChinaWorld

        //StringBuilder reverse()
        sb.reverse();
        System.out.println(sb);       //dlroWolleH

    }
}
练习:
	1. 用StringBuilder改进 将数组int[] arr = {11, 22, 33}; 遍历的结果封装成[11, 22, 33]并打印
	2. 用StringBuilder改进,定义一个方法,实现字符串反转功能
public class Test {

    public static void main(String[] args) {

        int[] arr = {11, 22, 33};

        //1. 先定义一个StringBuilder,用来存储结果
        StringBuilder sb = new StringBuilder();
        sb.append("[");

        for (int i = 0; i < arr.length; i++) {

            if(i == arr.length-1){
                sb.append(arr[i] + "]");
            }else{
                sb.append(arr[i] + ", ");
            }
        }

        // 输出结果
        System.out.println(sb);
    }
}
public class Test2 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("abc");
        System.out.println(reverseString(sb));
    }

    public static StringBuilder reverseString(StringBuilder sb){

        return sb.reverse();
    }

}
1.4 StringBuilder和StringBuffer之间的区别
StringBuilder和StringBuffer几乎是一样的。都有append及insert方法

区别:
	StringBuiler是线程不安全的(不同步),效率高
	StringBuffer是线程安全的 (同步),效率低
1.5 String和StringBuilder之间的区别
关于存储字符串的方式:
	String:固定的常量
	StringBuilder:可变的字符序列

出现的版本:
	String:JDK1.0
	StringBuilder:JDK1.5
1.6 String和StringBuilder之间的互相转换
String转为StringBuilder
1. 通过StringBuilder的构造方法 StringBuilder(String str)
String s = "abc";

// 方式一:通过StringBuilder的构造方法 StringBuilder(String str)
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);  //abc
将StringBuilder转为String
1. 通过String类型的构造方法 String(StringBuilder sb)
2. 通过StringBuilder的toString方法
public class Demo3 {

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        sb.append("abc");

        // 方式一:通过String类型的构造方法 String(StringBuilder sb)
//        String s = new String(sb);
//        System.out.println(s);

        // 方式二:通过StringBuilder的toString方法
        String s = sb.toString();
        System.out.println(s);

    }
}
练习:
	写一个方法,判断一个字符串是否是对称的。
	如:字符串"abc" 不对称  字符串"abcba" 对称  字符串"1001" 对称
public class Test {

    public static void main(String[] args) {

        String s = "abc";

        //1. 将String类型转为StringBuilder
        StringBuilder sb = new StringBuilder(s);

        //2. 使用StringBuilder类型的reverse方法反转
        String ss = sb.reverse().toString();

        //3. 用反转之后的字符串和反转之前的字符串比较
        if(ss.equals(s)){
            //如果相同,那么证明是对称的
            System.out.println(s + "是对称的");
        }else{
            //如果不相同,那么证明是不对称的
            System.out.println(s + "是不对称的");
        }

    }
}

1.7 String和StringBuilder当做参数传递
public class Test2 {

    public static void main(String[] args) {

        String s = "abc";
        change(s);
        System.out.println(s);      //abc
        System.out.println("------------");

        StringBuilder sb = new StringBuilder();
        sb.append("abc");
        change(sb);
        System.out.println(sb);     //abcxyz

    }

    public static void change(String s){

        s += "xyz";
        System.out.println(s);  //abcxyz
    }
    public static void change(StringBuilder sb){

        sb.append("xyz");
    }

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6HLU16k3-1620344684864)(img/image-20210421154906803.png)]

二、包装类

2.1 为什么使用包装类
1. 如求int类型的最大值、求整数66的2进制、16进制等操作
2. 以后开发过程中,前台传数据给后端可能全是以字符串的形式,比如:"1949-10-1"、年龄 "30"。后台拿到这些字符串之后,有可能会需要将这些字符串转为整数类型。

以上场景都需要用到包装类。
2.2 概述
包装类就是对基本数据类型进行包装,给每一个基本数据类型都提供了一个对应的引用数据类型。既然是引用数据类型了,那么肯定会有构造方法,及其它方法。这些方法就可以解决很多问题。比如上面说的两大类常见问题。
基本数据类型包装类类型(实际上就是引用数据类型)
byteByte
shortShort
intInteger 【重要】
longLong
floatFloat
doubleDouble
charCharacter 【重要】
booleanBoolean

三、Integer类

Integer 类在对象中包装了一个基本类型 int 的值。

Integer类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法。

3.1 构造方法
Integer(int value) 
Integer(String s) 
public class Demo {

    public static void main(String[] args) {

        //Integer(int value)
//        Integer i = new Integer(666);
//        System.out.println(i);

        //Integer(String s)
//        Integer i = new Integer("666");
//        System.out.println(i);

        /*
            Integer类的构造方法虽然可以接收字符串类型,但是只能接收整数的字符串类型
         */
        Integer i = new Integer("1949-10-1");   //运行报错。
        System.out.println(i);

    }
}
3.2 常见方法
重要的方法:
    int intValue() 					
    static Integer valueOf(int i) 
    static int parseInt(String s)  

不大重要的方法:
	static String toBinaryString(int i)  
	static String toOctalString(int i) 
 	static String toHexString(int i) 
 	static String toString(int i, int radix)  
 
 	String toString()  
public class Demo2 {

    public static void main(String[] args) {

        Integer i = new Integer(666);

        //int intValue()            将Integer类型的数字转为基本数据类型int
//        int ii = i.intValue();
//        System.out.println(ii);     //666

        //static Integer valueOf(int i)     将整数从基本数据类型int转为引用数据类型Integer
//        Integer ii = Integer.valueOf(666);
//        System.out.println(ii);     //666

        //static int parseInt(String s)     将字符串类型的数字转为int类型
        int ii = Integer.parseInt("666");
        System.out.println(ii);     //666

    }
}
public class Demo3 {

    public static void main(String[] args) {

        //static String toBinaryString(int i)    将整数转为二进制
//        System.out.println(Integer.toBinaryString(66));     //1000010

        //static String toOctalString(int i)     将整数转为八进制
//        System.out.println(Integer.toOctalString(66));      //102

        //static String toHexString(int i)      将整数转为十六进制
//        System.out.println(Integer.toHexString(66));        //42

        //static String toString(int i, int radix)
        /*
            通过探究,发现目前的进制范围为:2-36进制
         */
        System.out.println(Integer.toString(66, 36));  //1u

        //String toString()   将Integer类型转为String类型
        Integer i = new Integer(66);
        System.out.println(i.toString());

    }
}
3.3 常见常量
static int MAX_VALUE 	它表示 int 类型能够表示的最大值
static int MIN_VALUE 	它表示 int 类型能够表示的最小值 
public class Demo4 {

    public static void main(String[] args) {

        System.out.println(Integer.MAX_VALUE);      //2147483647
        System.out.println(Integer.MIN_VALUE);      //-2147483648

    }
}
n(Integer.toString(66, 36));  //1u

        //String toString()   将Integer类型转为String类型
        Integer i = new Integer(66);
        System.out.println(i.toString());

    }
}
3.3 常见常量
static int MAX_VALUE 	它表示 int 类型能够表示的最大值
static int MIN_VALUE 	它表示 int 类型能够表示的最小值 
public class Demo4 {

    public static void main(String[] args) {

        System.out.println(Integer.MAX_VALUE);      //2147483647
        System.out.println(Integer.MIN_VALUE);      //-2147483648

    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值