Java学习之路之week4day4

最新推荐文章于 2024-07-22 22:58:19 发布

爱学cs的小陈

最新推荐文章于 2024-07-22 22:58:19 发布

阅读量198

点赞数

分类专栏： Java学习之路文章标签： java jvm 面试

本文链接：https://blog.csdn.net/weixin_43527493/article/details/125547635

版权

Java学习之路专栏收录该内容

11 篇文章 0 订阅

订阅专栏

向Java程序员的目标前进！

day18

学习内容

day18
常用类—续

常用类—续

String类—续

String类的转换功能

public char[] toCharArray()：将字符串转换为字符数组
public byte[] getBytes()：将字符串转换成字节数组(使用平台默认字符集编码)
public byte[] getBytes(String charSet):将字符串转换成字节数组(使用指定字符集编码)
String(byte[] bytes)：使用平台默认字符集解码(String的构造方法)
public String toLowerCase()：将字符串转换成小写
public String toUpperCase()：将字符串转换成大写
public static String valueOf(int/double/float/char[]/Object i)：万能方法：将任何数据类型转换成String
    
拓展：Arrays工具类：可以将任何数组转换成String
public static String toString(int[]/byte[]/double[]/float[]/Object[]等类型)

平台默认字符集是UTF-8，也就意味着一个中文字符对应着三个字节编码。而GBK用一个中文字符对应两个字节编码。

解码就是将看不懂的字节数组转换成能看懂的String，而编码则与之相反。在进行操作时，解码和编码的字符集必须统一。

计算机底层存储中文时，会将中文字符转换成二进制数，使用字节来表示。其中，第一个字节永远是负数。

String类的其它功能

public String replace(char oldChar,char newChar)：将指定的字符使用新字符进行替换
public String replace(String oldStr,String newStr)：替换指定字符串
public String trim()：去除两端空格

String类的比较功能

public int compareTo(String anotherString)：将两个字符串按照字典顺序进行比较

String类的比较功能的源码分析

public int compareTo(String anotherString) {
    // 获取第一个String的长度
    int len1 = value.length;
    // 获取第二个String的长度
    int len2 = anotherString.value.length;
    // 获取两个长度中较短的那个，作为限制
    int lim = Math.min(len1, len2);
    // 分别获取两个String的字符数组形式
    char v1[] = value;
    char v2[] = anotherString.value;
	// 定义统计变量k=0
    int k = 0;
    // k循环至lim时结束
    while (k < lim) {
        // 分别获取两个String中相同位置的字符值
        char c1 = v1[k];
        char c2 = v2[k];
        // 如果c1的ASCII值和c2的ASCII值不相等，则将c1和c2的值相减并返回
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    // 最终底层将两个字符串的字符数组长度相减并返回
    return len1 - len2;
}

String类的练习

/**
 * 练习1：给定一个字符串，进行遍历输出
 */
public class StringTest {
    public static void main(String[] args) {
        //创建一个字符串
        String str = "helloJava" ;
        //最原始的做法
        System.out.println(str.charAt(0));
        System.out.println(str.charAt(1));
        System.out.println(str.charAt(2));
        System.out.println(str.charAt(3));
        System.out.println(str.charAt(4));
        System.out.println(str.charAt(5));
        System.out.println(str.charAt(6));
        System.out.println(str.charAt(7));
        System.out.println(str.charAt(8));

        System.out.println("-------------------------------------------") ;
        
        //str指定的字符串对象 charAt指定的方法,变化的是里面的角标
        //上面代码重复读高  charAt(int index)+length()获取长度结合使用
        for(int i = 0 ; i < str.length() ; i++){
            System.out.print(str.charAt(i)+"\t");
        }
        System.out.println();
        
        System.out.println("-----------------------------------------------") ;

        //方式2:转换功能 toCharArray()---->char[],遍历字符数组
        char[] chs = str.toCharArray();
        for (int i = 0; i <chs.length ; i++) {
            //每一个字符
            char ch = chs[i] ;
            System.out.print(ch+"\t");
        }
    }
}

/**
 * 练习2：键盘录入一个字符串数据，按指定的格式输出
 * 举例：输入“XiaoChenwholovecs”，输出“xIAOCHENWHOLOVECS”。
 */

/**
 * 分析:
 * 1)创建键盘录入数据
 * 2)将指定的字符串的第一个字符截取出来 subString(0,1)
 * 3)将2)的结果转换成小写 toLowerCase()
 * 4)将第一个字符后面的所有数据截取出来subString(1),默认截取到末尾
 * 5)将4)的结果转换成大写
 * 6)然3)和5)的结果拼接成一个新的字符串
 */
public class StringTest2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入
        System.out.println("请您输入字符串数据:");
        String line = sc.nextLine() ;
        String result = getString(line);

        System.out.println(result);
    }

    public static String getString(String line) {
        //将核心代码选中:alt+alt+m:抽取一个method方法

       /* String s1 = line.substring(0, 1);//截取第一个字符
        //将s1转换成小写
        String s2 = s1.toLowerCase();

        //在将从1开始后面的字符序列截取出来
        String s3 = line.substring(1);//从1默认截取到末尾
        //将s3转换成大写
        String s4 = s3.toUpperCase();
        //然后s2和s4拼接
        return s2.concat(s4);*/

        //链式编程
        String reuslt = line.substring(0,1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
        return reuslt ;
    }
}

StringBuffer类

如果用之前介绍的方式对String进行拼接操作，每次拼接后JVM就会构建一个新的String对象，这样的方式浪费了计算机的资源。StringBuffer的出现就解决了这样的问题。

综上所述，StringBuffer是一个线程安全的可变字符序列，本质是一个字符串缓冲区。

面试题：StringBuffer和StringBuilder的异同点

A：共同点：两者都是具有相互兼容的API（StringBuffer能用的String也可以）

不同点：StringBuffer是一个线程安全的类（是一个同步操作的类，执行效率低）StringBuilder是一个线程不安全的类（是一个不同步操作的类，执行效率高）

举例：StringBuffer——银行网站、医疗网站等等

StringBuilder——论坛网站等等

所以单线程环境下都会使用StringBuilder去替换StringBuffer，因为执行效率高。

StringBuffer的构造方法

StringBuffer()：空参构造

StringBuffer(String str)：有参构造

int length()：获取字符串缓冲区的长度（缓冲区中实际的字符序列的长度）

public int capacity()：获取缓冲区的容量大小，英文字符默认是16个初始长度。

StringBuffer(int capacity)：指定缓冲区的容量大小

一般情况下，空参构造和有参构造较为常用。

StringBuffer的成员方法

添加功能

public StringBuffer append(任何类型数据)：在缓冲区中的默认的字符序列后面依次追加，返回值是字符串缓冲区本身。
public StringBuffer insert(int offset/char c/String str)：在指定的位置插入指定的字符或者字符串，返回值是字符串缓冲区本身。

通常append方法更为常用。

删除功能

public StringBuffer deleteCharAt(int index)：删除指定索引处的字符，返回字符串缓冲区本身
public StringBuffer delete(int start,int end)：删除从执行位置从指定位置的字符序列开始，到end-1处结束，返回字符串缓冲区本身。

反转功能

public StringBuffer reverse()：返回字符串缓冲区本身

截取功能

StringBuffer的截取功能和String一样

String subString(int beginIndex)：从指定位置默认截取到末尾，完成后返回新的字符串
String subString(int beginIndex,int endIndex)：从指定开始
截取到指定位置（endIndex-1处）结束，完成后返回的新的字符串

StringBuffer和String的类型转换

String转StringBuffer

String s = "hello" ;
//方式1：无参构造方法+append()追加
StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
System.out.println("sb:"+sb);
System.out.println("--------------------------------------") ;
//方式2：有参构造直接StringBuffer(String s)
StringBuffer sb = new StringBuffer(s) ;
System.out.println("sb:"+sb) ;

StringBuffer转String

//StringBuffer----String
StringBuffer buffer = new StringBuffer("XiaoChen") ;
//方式1:public String(StringBuffer buffer)
String str = new String(buffer) ;
System.out.println("str:"+str);
System.out.println("--------------------------------------") ;
//方式2:public String toString();
String result = buffer.toString();
System.out.println("result:"+result) ;

面试题：String和StringBuffer的区别

A：String是一个特殊的引用类型，形参的改变不会实际参数，效果和基本类型一致！而且String是常量，一旦被赋值后值就不能被更改!

StringBuffer：是线程安全的一个类，它支持可变的字符序列。

引用类型除String外，在使用时形参改变会直接影响实际参数！

Integer类

包装类类型是什么？

包装类类型就是将基本数据类型与一些方法进行“封装”，方便我们使用而定义的类型。常用的基本数据类型和包装类类型如下表所示。

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

Integer类的定义

Integer类将基本数据类型int封装成了对象，让我们可以在对象中定义更多的功能方法操作该数据。

Integer类提供了多种方法，能使int类型与String类型互相转换。当然，它还提供了更多处理int类型的常量和方法。

Integer类的相关方法

构造方法

public Integer(int value)：将基本类型数据int转换为Integer
public Integer(String s) throw NumberFormatException：Integer的静态转int类型功能。这里的形式参数必须为“数字字符串”，否则会出现数字格式化异常。

成员方法

public static int parseInt(String s)：将String类型的数字转换为int类型
public static Integer valueOf(int i)：将int类型转换为Integer类型
public static Integer valueOf(String s)：将String类型的数字转换为Integer类型

常用的进制转换方法

public static String toBinaryString(int i)：以字符串形式将十进制数据转换为二进制数据
public static String toOctalString(int i)：以字符串形式将十进制数据转换为八进制数据
public static String toHexString(int i)：以字符串形式将十进制数据转换为十六进制数据

JDK5的新特性——自动拆装箱

JDK1.5之后，简化了Integer的定义方式。原来的

Integer x = new Integer(4);

可以直接写成：

Integer x = 4; //自动装箱

而运算时，可以写成：

x = x + 5; //自动拆箱

注意：在使用时，直接定义Integer x = null;，运行时会出现空指针异常（NullPointerException）.

从上面的例子可以看到，自动装箱是自动将基本类型提升为对应的包装类型，而自动拆箱就是自动将包装类类型降为基本数据类型。

int与String类型的相互转换

int转String

//int--->String
int i = 100 ;
//方式1：最接的方式，空串拼接
String s = "" ;
String result = s+i ;
System.out.println(result); //"100"
System.out.println("---------------------------------") ;
//方式2：int---->Integer作为中间桥梁---->String
Integer integer= new Integer(i) ;//Integer类型了
//public String toString()：重写Object的，打印出对象名称是int类型的原始值，不是地址
String reuslt = integer.toString();
System.out.println(result);//"100"
System.out.println("---------------------------------") ;
//方法3：Integer的静态功能public static String toString(int i)(Integer的自己toString方法)
String result2 = Integer.toString(i);
System.out.println(result2);//"100"

String转int

//String--->int
String str = "50" ;
//String--->int 最为有效最接的方式  (最推荐的,使用最多)
//Integer的这个方法
//public static int parseInt(String s) throws NumberFormatException
//参数必须为数字字符串
//在其他的基本类型对应的引用类型 parseXXX(String s) --->XXX类型
int ii = Integer.parseInt(str);
System.out.println(ii); //50
System.out.println("----------------------------") ;
//String--Integer->int
//Integer的成员方法public int intValue()
Integer integer2 = new Integer(str) ;
int iii = integer2.intValue();
System.out.println(iii); //50

Integer类的练习

/**
 * 代码中分别定义了i1到i8的整型变量，逐个推断输出的内容
 */
public class Test {
    public static void main(String[] args) {
        Integer i1 = 127 ;
        Integer i2 = 127 ;
        
        System.out.println(i1==i2) ; //1) true
        System.out.println(i1.equals(i2)) ;//2) true
        Integer i3 = 127 ;
        Integer i4 = new Integer(127) ;
        
        System.out.println(i3==i4) ;//3) false
        System.out.println(i3.equals(i4)) ;//4) true

        Integer i5 = 128 ;      
        Integer i6 = 128 ;
        
        System.out.println(i5==i6) ; //5) false
        System.out.println(i5.equals(i6)) ;//6) true

        Integer i7 = new Integer(128) ;
        Integer i8 = new Integer(128) ;
        
        System.out.println(i7==i8) ;//7) false
        System.out.println(i7.equals(i8)) ;//8) true
    }
}

解析：

i1与i2中都定义了整型变量和127的常量，并使i1和i2指向常量127，所以内存地址值相同，结果为true
内容相同，所以结果为true
i3定义了栈内存变量、堆内存变量和常量127；i4定义了栈内存变量和常量127。所以栈内存变量指向的内存地址值不同，结果为false
同2，故此处省略
这是我当时看的原理的解析，博客说的很清楚：Integer缓存IntegerCache详解_谷哥的小弟的博客-CSDN博客_integercache
同2，故此处省略
i7、i8都定义了栈内存变量、堆内存变量和常量128，所以栈内存变量指向的内存地址值不同，结果为false
同2，故此处省略

Character类

Character是char类型的包装类型。其中，该类提供了几种方法，以确定字符的类别，并将字符转为大写或小写。

Character的相关方法

构造方法

public Character(char value)

成员方法

public static boolean isUpperCase(char ch)：判断是否为大写字母字符
public static boolean isLowerCase(char ch)：判断是否为小写字母字符
public static boolean isDigit(char ch)：判断是否为数字字符
public static char toUpperCase(char ch)：将字符转为大写字符
public static char toLowerCase(char ch)：将字符转为小写字符

Date类

java.util.Date类表示特定的瞬间（日期对象），精确到毫秒。

Date类的构造方法

构造方法

public Date()：空参构造方法
public Date(long date)

成员方法

public long getTime()：获取自1970年1月1日0时0分0秒以来，经过的毫秒数
public void setTime(long time)：设置日期

DateFormat类

DateFormat类是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。由于是抽象类，使用时不能直接去new，所以使用其子类SimpleDateFormat。

SimpleDateFormat构造方法

public SimpleDateFormat()
public SimpleDateFormat(String pattern)

SimpleDateFormat成员方法

public final String format(Date date)：将日期转为字符串
public Date parse(String source) throws ParseException：解析字符串调用本身这个方法就会出现问题，因为String类型的格式和SimpleDate这里面的模式不一致的话，会出现解析异常（编译时期异常）。

方法属于编译时期异常时，谁调用这个方法必须对这个做出处理，如果不处理就不能编译通过！

对于编译时期的异常，可以用throws抛出在main方法上，也可以用try…catch捕获异常（开发中业务层代码处理异常捕获）

博客难免会产生一些错误。如果写的有什么问题，欢迎大家批评指正。

爱学cs的小陈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习之路之week4day4

String类的其它功能String类的比较功能String类的比较功能的源码分析String类的练习StringBuffer类如果用之前介绍的方式对String进行拼接操作，每次拼接后JVM就会构建一个新的String对象，这样的方式浪费了计算机的资源。StringBuffer的出现就解决了这样的问题。综上所述，StringBuffer是一个线程安全的可变字符序列，本质是一个字符串缓冲区。A：共同点：两者都是具有相互兼容的API（StringBuffer能用的String也可以）不同点
复制链接

扫一扫