目录
String类 --StringBuffer类--StringBuilder类
基本数据类型封装类
对于包装类来说，这些类的用途主要包含两种：
● 作为和基本数据类型对应的类类型存在。
● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操 作方法
包装类常用属性方法
8中基本数据类型各自所对应的包装类
以下方法以java.lang.Integer为例
代码
package com.ffyc.javaapi.datatype;
import java.util.Scanner;
public class IntegerDemo1 {
public static void main(String[] args) {
//如何获得一个int类型的包装对象
//通过构造方法 new
Integer a = new Integer(10);
System.out.println(a);//10
Integer b = new Integer("8");
System.out.println(b);//8
//通过valueOf()方法
Integer c = Integer.valueOf(10);
System.out.println(c);//10
Integer d = Integer.valueOf("8");
System.out.println(d);//8
//非静态方法 直接对包装对象中的值操作
int i = a.compareTo(b);//比较大小 返回-1 0 1
System.out.println(i);//1
System.out.println(a == b);//地址比:false
System.out.println(a.equals(b));//数值比:false
int j = a.intValue();//取出包装类型中的基本数据类型的值
System.out.println(j);//10
//静态方法 需要传参
int e = Integer.compare(10, 8);
System.out.println(e);//1
String f = Integer.toHexString(12138);
System.out.println(f);//返回16进制
Integer.max(10, 8);
int g = Integer.parseInt("20");//把字符串类型数值 转为基本类型int
}
}
运行
装箱和拆箱
装箱
何为装箱
装箱：将基本类型可以自动转为包装类型
int a = 10;
Integer a1 = Integer.valueOf(a);
Integer a2 = new Integer(a);
Integer aa = a;自动装箱 直接把基本类型 赋值给包装类型
底层是默认调用valueOf(a);
代码
package com.ffyc.javaapi.datatype;
public class IntegerDemo2 {
public static void main(String[] args) {
int a = 10;
Integer aa = a;
}
}
范围问题
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
自动装箱时，默认调用Integer类中valueOf(),
这份方法内部对-128 -- +127之间进行缓存（数组），在此区间的自动装箱，不会创建新的Integer对象，直接从数组中获取即可
超出此区间后，每次都会new 新的Integer对象
代码
package com.ffyc.javaapi.datatype;
public class IntegerDemo3 {
public static void main(String[] args) {
Integer a = 18;
Integer b = 18;
System.out.println(a == b);//true
System.out.println(a.equals(b));//true
Integer c = Integer.valueOf(128);
Integer d = Integer.valueOf(128);
System.out.println(c == d);//false
System.out.println(c.equals(d));//true
}
}
运行
拆箱
拆箱：将包装类型可以自动转为基本类型 型
底层用到的是intValue();
代码
package com.ffyc.javaapi.datatype;
public class IntegerDemo2 {
public static void main(String[] args) {
int a = 10;
Integer aa = a;
int bb = aa;
}
}
String类
概述
Java.lang.String代表字符串
Java中凡是""括起来的 都是String类的实例（对象）
字符串的值不可改变的，一旦字符串对象被创建，它的值就不能改变了
底层存储字符串内容的数组，是被final修饰的，必须在对象创建之处由构造方法去创建
private final char value[];
String s = "abc"; abc
s += "aaa"; abcaaa
s += "bbb"; abcaaabbb
s += "ccc"; abcaaabbbccc 每次+= + 其实都是创建了一个新的字符串对象
代码
package com.ffyc.javaapi.stringdemo;
public class StringDemo1 {
public static void main(String[] args) {
String s = "abc";//[a,b,c]
s += "aaa";
s += "bbb";
s += "ccc";
System.out.println(s);
}
}
运行
创建形式
Java中字符串创建的两种方式
方式一：
String s1 = "abc";
String s2 = "abc";
在第一次创建s1变量时，会去内存中有一个叫字符串常量池的空间检索，有没有此内容的一个字符串对象，
如果没有，就会在字符串常量池中创建一个字符串对象，把对象的地址赋给s1.
在第二次创建s2变量时，会去字符串常量池中查找，如果有，直接将之前创建的字符串对象赋值给s2.
一旦出现要创建的字符串对象内容一致，返回拿到的是同一个字符串对象的地址
方式二：
String s3 = new String("abc");
String s4 = new String("abc");
无论是否存在相同内容的字符串对象，都会创建一个新的字符串对象
画图讲解
代码
package com.ffyc.javaapi.stringdemo;
public class StringDemo2 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);//true
System.out.println(s1.equals(s2));//true
s1 += "aaa";
System.out.println(s1);
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true
}
}运行
构造方法
String 构造方法
String(); 无参
String("abc");有参
String(byte[] bytes);
String(char[] bytes);
代码
package com.ffyc.javaapi.stringdemo;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class StringDemo3 {
public static void main(String[] args) throws UnsupportedEncodingException {
String s1 = new String();// this.value = "".value;
String s2 = new String("abc");
String s3 = "abc你好";
//把字符串转为byte类型 转码
//byte[] bytes = s3.getBytes();
//把字符串转为byte类型 转码
byte[] bytes = s3.getBytes("utf-8");
System.out.println(bytes);//[B@1b6d3586
System.out.println(Arrays.toString(bytes));//[97, 98, 99, -28, -67, -96, -27, -91, -67]
//String s4 = new String(bytes);解码
String s4 = new String(bytes,"utf-8");//解码
System.out.println(s4);//abc你好
String s5 = "bced";
//字符串--->转为char数组
char chars[] = s5.toCharArray();
Arrays.sort(chars);
//char数组--->字符串
String s6 = new String(chars);
System.out.println(s6);//bcde
}
}
运行
成员方法
判断功能
成员方法
● 判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean isEmpty()D
boolean startsWith(String prefix)
boolean endsWith(String suffix)
代码
package com.ffyc.javaapi.stringdemo;
public class StringDemo4 {
public static void main(String[] args) {
String s1 = "abcd";
String s2 = "";
//null--->关键字 ""--->字符串对象的值是""
//String s3 = null;
//判断值是否相等
System.out.println(s1.equals("abcd"));//true
//忽略大小写
System.out.println(s1.equalsIgnoreCase("abcD"));//true
//判断是否包含子串（字串必须是连续的）
System.out.println(s1.contains("ab"));//true
System.out.println(s1.contains("ab"));//true
System.out.println(s1.contains("ac"));//false
//判断是否是空串""
System.out.println(s1.isEmpty());//false
System.out.println(s2.isEmpty());//true
//System.out.println(s3.isEmpty());
//判断是否以指定的子串开头
System.out.println(s1.startsWith("ab"));//true
//判断是否以指定的子串结尾
System.out.println(s1.endsWith("bd"));//false
}
}
运行
获取功能
成员方法
● 获取功能
int length()
char charAt(int index)
int indexOf(String str)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
代码
package com.ffyc.javaapi.stringdemo;
public class StringDemo5 {
public static void main(String[] args) {
String s1 = "abcdcde";
//0123456
//获取长度
System.out.println(s1.length());//4
//通过索引找位置
System.out.println(s1.charAt(1));//b
//返回指定字符首次出现的位置
System.out.println(s1.indexOf("c"));//2
//返回指定字符串首字母首次出现的位置
System.out.println(s1.indexOf("c"));//2
//从指定位置开始查找
System.out.println(s1.indexOf("c", s1.indexOf("c")+1));//4
//从后向前查找
System.out.println(s1.lastIndexOf("c"));// 4
//从指定位置开始查找
System.out.println(s1.lastIndexOf("c", 3));//2
/*//从指定的位置开始截取字符串，返回一个新的子字符串
String s = s1.substring(3);
System.out.println(s);//dcde*/
//从指定的位置开始到指定的位置结束（不包含结束）截取字符串，返回一个新的子字符串
String s = s1.substring(0,4);
System.out.println(s);//abcd
}
}
运行
转换功能
构造方法
● 转换功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
String toLowerCase()
String toUpperCase()
String concat(String str)
Stirng[] split(分割符);
代码
package com.ffyc.javaapi.stringdemo;
import java.util.Arrays;
public class StringDemo6 {
public static void main(String[] args) {
Integer a = null;
//System.out.println(a.toString());
//把其他类型转为字符串 建议使用的，避免出现空指针异常
String s = String.valueOf(a);
System.out.println(s);
char[] c = {'a','b','c'};
//基本数据类型转成字符串表示形式
String s1 = String.valueOf(c);
System.out.println(s1);//abc
String s2 = "abcDEF你好";
//将字符串的所有字符转换为小写字母。
System.out.println(s2.toLowerCase());//abcdef你好
//将字符串的所有字符转换为大写字母。
System.out.println(s2.toUpperCase());//ABCDEF你好
String s3 = s2.concat("wwwww");
//将指定的字符串拼接到字符串末尾，返回一个新的字符串
System.out.println(s3);//abcDEF你好wwwww
String s4 = "abc;de;fg";
//正则表达式 使用指定的一个字符，将字符串分割为一个String类型数组
String[] strings = s4.split(";");
System.out.println(Arrays.toString(strings));//[abc, de, fg]
}
}
运行
替换功能 去除字符串两侧空格
构造方法
● 替换功能
String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)
● 去除字符串两空格
String trim()
代码
package com.ffyc.javaapi.stringdemo;
public class StringDemo7 {
public static void main(String[] args) {
String s1 = "abcdecfg";
//替换字符串中指定字符的所有值
System.out.println(s1.replace('c', 'C'));//abCdeCfg
System.out.println(s1.replace("cd", "jj"));//abjjecfg
//replaceAll()使用正则表达式匹配需要替换的内容
System.out.println(s1.replaceAll("c", "CC"));//abCCdeCCfg
System.out.println(s1.replaceFirst("c", "o"));//abodecfg
String s2 = " asd sax ";
System.out.println(s2.length());//9
//求字符串长度
System.out.println(s2.trim().length());//7
System.out.println(s2.replace(" ", "").trim().length());//6
}
}
运行
StringBuffer类与StringBuilder类
StringBuffer类
因为String声明的对象值一旦给定不能再改变
每次拼接都会创建新的字符串对象，耗时占用空间
StringBuffer是内容可以改变的字符串
char[] value;没有使用final修饰，每次添加内容都是对此数组进行操作，不会创建新的字符串对象
添加功能
代码
package com.ffyc.javaapi.stringdemo;
public class StringBufferDemo {
public static void main(String[] args) {
//添加功能
//创建一个内容长度+16的char数组 20
StringBuffer s1 = new StringBuffer("abcd");
System.out.println(s1.append("efg"));
//空参的构造方法 指定底层数组的长度是16
StringBuffer s2 = new StringBuffer();
System.out.println(s2.append("cz"));
//自定义容量 自动扩容
StringBuffer s3 = new StringBuffer(10);
s3.append("chjbp");
s3.append("kl");
System.out.println(s3.append("ffgg"));
//指定位置添加元素
StringBuffer s4 = new StringBuffer("abc");
System.out.println(s4.insert(2, "A"));
}
}
运行
删除功能
代码
package com.ffyc.javaapi.stringdemo;
public class StringBufferDemo {
public static void main(String[] args) {
//删除功能
StringBuffer s1 = new StringBuffer("abcd");
//删除指定位置元素
System.out.println(s1.deleteCharAt(2));
//删除指定位置的元素 包含开始位置，不包含结束位置
System.out.println(s1.delete(0, 2));
}
}
运行
替换功能
代码
package com.ffyc.javaapi.stringdemo;
public class StringBufferDemo {
public static void main(String[] args) {
//替换功能
StringBuffer s1 = new StringBuffer("abcalkdswbc");
//替换指定区间元素，包含开始位置，不包含结束位置
System.out.println(s1.replace(0, 3, "aaa"));
}
}
运行
反转功能
代码
package com.ffyc.javaapi.stringdemo;
public class StringBufferDemo {
public static void main(String[] args) {
//反转功能
StringBuffer s1 = new StringBuffer("abcdefg");
//将字符串逆序
System.out.println(s1.reverse());
//截取字符串，从StringBuffer中截取一个字符串副本，返回一个新的String对象，StringBuffer对象本身不变
String str = s1.substring(0, 3);
System.out.println(str);
}
}
运行
StringBuilder类
StringBuilder类功能和StringBuffer功能完全一致, StringBuffer是线程 安全的
代码
package com.ffyc.javaapi.stringdemo;
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder();
StringBuilder s2 = new StringBuilder("abcd");
StringBuilder s3 = new StringBuilder(10);
System.out.println(s2.append("efg"));
System.out.println(s2.insert(1, " "));
}
}
运行
String类 --StringBuffer类--StringBuilder类
String:是一个值不可以改变的字符串
StringBuffer:值可以改变且不需要创建新对象,方法上都加了锁，是在多线程（任务）执行时是线程安全的
StringBuilder:值可以改变且不需要创建新对象，由于方法上都没有枷锁，在多线程（任务）执行时是线程不安全的，适合单线程
4776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
