本文主要是介绍Java初学笔记16，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java初学笔记16

• 一、包装类
• • 1.分类
• 二、包装类和基本数据的转换
• 三、包装类与String类的转换
• • 1.String类转包装类
  • 2.包装类转String类
• 四、Integer类与Character类常用方法
• 五、String类
• • 1.介绍
  • 2.创建String对象的两种方式及其区别
  • 3.创建String对象的内存分布图
  • 4.练习题
• 六、字符串的特性
• • 1.解释
  • 2.练习题
• 七、String类的常见方法
• • 1.equals
  • 2.equalsIgnoreCase
  • 3.length
  • 4.indexOf
  • 5.lastIndexOf
  • 6.substring
• 八、StringBuffer类
• • 1.介绍
  • 2.StringBuffe的构造器
• 九、String 与 StringBuffe作比较
• 十、String 和 StringBuffer 相互转换
• • 1.String---->StringBuffer
  • • （1）使用构造器
    • （2）使用 append 方法
  • 2.StringBuffer ---->String
  • • （1）使用 StringBuffer 提供的 toString 方法
    • （2）使用构造器来搞定
• 十一、StringBuffer 类常见方法
• • 1.增append
  • 2.删delete
  • 3 修改replace
  • 4.查找indexOf
  • 5.插insert
  • 6.长度length
• 十二、StringBuffer练习题
• 十三、StringBuild类
• • 1.介绍
• 十四、StringBuilder 常用方法
• 十五、String、StringBuffer 和 StringBuilder 的比较
• 十六、String、StringBuffer 和 StringBuilder 的使用选择

一、包装类

1.分类

（1）针对八种基本数据类型相应的引用类型-----包装类
（2）有了类的特点，就可以调用类中的方法。

二、包装类和基本数据的转换

（1）jdk5 前的手动装箱和拆箱方式。
装箱：基本类型->包装类型；
拆箱：包装类型->基本类型；
（2）jdk5 以后(含jdk5)的自动装箱和拆箱方式
（3）自动装箱底层调用的是valueOf方法，比如Integer.valueOf（）

三、包装类与String类的转换

1.String类转包装类

2.包装类转String类

四、Integer类与Character类常用方法

（1）System.out.println(lnteger.MIN_VALUE);1/返回最小值
（2）System.out.println(Integer.MAX_VALUE);//返回最大值
（3）System.out.println(Character.isDigit(‘a’));//判断是不是数字
（4）System.out.println(Character.isLetter(‘a’));//判断是不是字母
（5）System.out.println(Character.isUpperCase(‘a’));//判断是不是大写
（6）System.out.println(Character.isLowerCase(‘a’));//判断是不是小写
（7）System.out.println(Character.isWhitespace(‘a’));//判断是不是空格
（8）System.out.println(Character.toUpperCase(‘a’));//转成大写
（9）System.out.println(Character.toLowerCase(‘A’));//转成小写

五、String类

1.介绍

（1）String对象用于保存字符串，也就是一组字符序列
（2）字符串常量对象是用双引号括起的字符序列。例如:“你好”、“12.97”."boy"等’
（3）字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
（4） String类较常用构造器(其它看手册):
String s1 = new String0;
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 final char value[ ];用于存放字符串内容
（8）重点：一定要注意value是一个final类型，不可以修改，不可以修改string对象的地址值，即value不能指向新的地址，但是单个字符内容是可以变化。

2.创建String对象的两种方式及其区别

方式一：直接赋值String s = “hsp”;
方式二：调用构造器String s2 = new String(“hsp”);
1.方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
2.方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp",重新创建；如果有，直接通过value指向。最终String对象s2指向的是堆中的空间地址。

3.创建String对象的内存分布图

【jvm的内存：String的两种方 式创建的内存分布】

4.练习题

六、字符串的特性

1.解释

（1）String是一个final类，代表不可变的字符序列
（2）字符串在常量池中是不可变的。一个字符串对象一旦被分配，即在常量池中一旦建立，其内容是不可变的.

【重点】

【debug源码分析】
1.
2.
3.
4.
5.
6.

【重要规则】
（1）String c1 = “ab” + “cd”：常量相加，看的是池。
（2）String c1 = a+b：变量相加,是在堆中。

2.练习题

七、String类的常见方法

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));//llo

八、StringBuffer类

1.介绍

（1）它是对String类的增强
（2）java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
因为StringBuffer父类存储字符串的value没有final，所以可以变长

（3）很多方法与String相同，但StringBuffer是可变长度的。
（4）StringBuffer是一个容器。

2.StringBuffe的构造器

九、String 与 StringBuffe作比较

（1）String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[ ];
（2）StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高//char[ ] value。//这个放在堆.

十、String 和 StringBuffer 相互转换

1.String---->StringBuffer

String str = "hello tom";

（1）使用构造器

返回的是 StringBuffer 对象，对 str 本身没有影响

StringBuffer stringBuffer = new StringBuffer(str);

（2）使用 append 方法

StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str)

2.StringBuffer ---->String

StringBuffer stringBuffer3 = new StringBuffer("大志");

（1）使用 StringBuffer 提供的 toString 方法

String s = stringBuffer3.toString();

（2）使用构造器来搞定

String s1 = new String(stringBuffer3)

十一、StringBuffer 类常见方法

1.增append

2.删delete

3 修改replace

4.查找indexOf

5.插insert

6.长度length

十二、StringBuffer练习题

1.
2.
3.
4.

1.
2.

十三、StringBuild类

1.介绍

（1）一个可变的字符序列。此类提供一个StringBuffer 兼容的API，但不保证同步(StringBuilder 不是线程安全)。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类,因为在大多数实现中，它比StringBuffer要快。
（2）在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。
（3）StringBuffer 的直接父类AbstractStringBuilder，在父类中 AbstractStringBuilder 有属性 char[] value,不是 final，该 value 数组存放字符串内容，引出存放在堆中
（4）StringBuffer 实现了 Serializable, 即StringBuffer 的对象可以串行化
（5）StringBuffer 是一个 final 类，不能被继承
（6）因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String

十四、StringBuilder 常用方法

（1）StringBuilder 和 StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样。
（2）StringBuilder是final
（3）继承了 AbstractStringBuilder,属性char[] value,内容存到value
（4）实现了Serializable接口,序列化(所谓序列化即可以保存类型和数据本

十五、String、StringBuffer 和 StringBuilder 的比较

（1）效率：StringBuilder > StringBuffer > String
（2）StringBuilder和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
（3）String：不可变字符序列,效率低,但是复用率高。
（4）StringBuffer：可变字符序列、效率较高(增删)、线程安全
（5）StringBuilder：可变字符序列、效率最高、线程不安全。
（6）String使用注意说明:
string s=“a”; //创建了一个字符串
s += “b”; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab”)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能，所以，如果我们对字符串做大量修改，就不要使用String。

十六、String、StringBuffer 和 StringBuilder 的使用选择

（1）如果字符串存在大量的修改操作，一般使用StringBuffer 或StringBuilder
（2）如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
（3）如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer
（4）如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

这篇关于Java初学笔记16的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！