12_常用类

时间：2019-06-05 11:32:06 阅读：94 评论：0 收藏：0 [点我收藏+]

常用类

讲解内容

包装类

String

StringBuffer、StringBuilder

包装类

包装类就是把基本数据类型封装到一个类中，并提供属性和方法方便未来操作该基本数据类型。

包装类位于java.lang包中。包装类的出现不是为了取代基本数据类型。继承结构

Number

Number 抽象类是所有数值类型(Byte、Short、Integer、Long、Float、Double)的抽象父类。并提供了把包装类转换成基本数据类型的抽象方法。

Integer

Integer 类在对象中包装了一个基本类型 int 的值，类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法.

常用属性方法

[1]静态属性

// Integer 静态属性
 System.out.println(Integer.MAX_VALUE);
 System.out.println(Integer.MIN_VALUE);

[2] 构造方法

public class Test01 {
 public static void main(String[] args) {
 
 // 构造方法
 Integer i1 = new Integer(10);
 System.out.println(i1.toString());
 
 // 传递"abc"参数会产生NumberFormatException
 Integer i2 = new Integer("123");
 System.out.println(i2.toString());
 }
}

常用方法

[1] xxxValue()把包装类转化成对象的xxx 基本数据类型。例如intValue()

Integer i1 = new Integer(10);
System.out.println(i1.intValue());

[2]Comparable 接口

Comparable 用于实现类对象的比较，比较此对象与指定对象的顺序。其定义的m.compareTo(n)方法返回一个int类型，表示

比较对象	比较结果	结论
m < n	负整数(-1)	升序
m == n	0	相等
m > n	正整数(1)	降序

public static void main(String[] args) {
 
 Integer i1 = new Integer(20);
// System.out.println(i1.intValue());
 
 Integer i2 = new Integer("20");
 
 // 【1】compareTo
 int r = 0;
 r = i1.compareTo(i2);
 System.out.println(r);
 
 // 【2】equals
 System.out.println(i1.equals(i2));
 
 // 【3】compare
 System.out.println(Integer.compare(10, 20));
 }

[3] 把字符串转化成基本数据类型

public class Test03 {
 public static void main(String[] args) {
 // Integer i1 = new Integer(10);
 // 10默认被指定为十进制
 int a = Integer.parseInt("10");
 // 1111被指定为二进制字符串
 int b = Integer.parseInt("1111",2);
 System.out.println(b);
 }
}

[4] 把基本数据类型转化成字符串

public static void main(String[] args) {
 // 把基本数据类型转化成字符串
 String str = Integer.toString(10);
 }

[5] valueOf() 快速构造Integer对象

public static void main(String[] args) {
 
 Integer i1 = Integer.valueOf(10);
 Integer i2 = Integer.valueOf("20");
 }

总结

[1] int、String -> Integer

Integer(int/String) 、valueOf(int/String) 

[2] Integer -> int、String

intValue()、toString()

[3] int Integer String

Integer.toString(int)

Integer.parseInt(String)

自动装箱/自动拆箱

自动装箱（auto-boxing）

基本数据类型可以自动转化成对于包装类

public class Test05 {
 public static void main(String[] args) {
 
 // 自动装箱
 Integer i1 = 10; // Integer.valueOf(10) / new Integer(10)
 System.out.println(i1);
 }
}

自动拆箱（auto-unboxing）

把包装类自动转化成对应的基本数据类型

Integer i2 = new Integer(20);
// 自动拆箱
int r = i2; // int r = i2.intValue();
System.out.println(r);

注意:

[1] 自动装箱和自动拆箱 jdk 1.5+ 特性。(查资料jdk1.5 and later的新特性)

[2] 不要频繁的装箱、拆箱！！！

其他包装类学习思路

字符串

字符本质

String 类代表字符串,java中所有字符串字面量(“123”、“abc”)都是String类的实例。

字符串本质上、在内存中是字符数组 => 字符串类是字符数组的包装类。

通过字面量创建的字符串是常量，分配在常量区（常量池），它们的值在创建之后不能更改。

因为 String 对象是不可变的，所以可以共享

构造方法

通过构造方法构造出来的字符串分配在堆区。

package cn.sxt02.string02;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;
public class Test01 {
 public static void main(String[] args) throws UnsupportedEncodingException {
 
 // 构造一个空字符串
 String str1 = new String();
 System.out.println(str1.length());
 
 //String(byte[] bytes) 
 byte[] bytes = {97,98,99};
 // System.out.println(Charset.defaultCharset());
 // 按照平台默认编码集解码
 String str2 = new String(bytes);
 System.out.println(str2);
 
 // bgk编码的字节序列
 byte[] bytes1 = {-42,-48};
 String str3 = new String(bytes1);
 System.out.println(str3);
 
 //utf8编码的字节序列
 byte[] bytes2 = {-28, -72, -83, -27, -101, -67};
 String str4 = new String(bytes2,"utf8");
 System.out.println(str4);
 
 // 按照gbk并指定位置和长度
 byte[] bytes5 = {97,98,99};
 String str5 = new String(bytes5,1,2);
 System.out.println(str5);
 
 
 //utf8编码的字节序列
 byte[] bytes6 = { -28, -72, -83, -27, -101, -67 };
 String str6 = new String(bytes6,3,3, "utf8");
 System.out.println(str6);
 
 
 }
}

package cn.sxt02.string02;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;
public class Test02 {
 public static void main(String[] args) throws UnsupportedEncodingException {
 
 char[] c1 = {‘中‘,‘国‘};
 String str1 = new String(c1);
 System.out.println(str1);
 
 char[] c2 = {‘中‘,‘国‘};
 String str2 = new String(c2,0,1);
 System.out.println(str2);
 
 String str3 = "abc";
 String str4 = new String(str3);
 System.out.println(str4);
 }
}

常用方法

[1]字符串的比较

public static void main(String[] args) {
 
 String str1 = "Abcde";
 String str2 = "ad";
 
 System.out.println(str1.compareTo(str2));
 System.out.println(str1.compareToIgnoreCase(str2));
 
 System.out.println(str1.contentEquals(str2));
 
 System.out.println(str1.equals(str2));
 System.out.println(str1.equalsIgnoreCase(str2));
 
 // 需求:请输入验证码
 String validCode = "aCtD";
 System.out.println("请输入验证码:"+validCode);
 Scanner sc = new Scanner(System.in);
 String str3 = sc.next();
 
 if(str3.equalsIgnoreCase(validCode)) {
 System.out.println("验证码正确");
 }else {
 System.out.println("验证码错误");
 }
 }

CharSequence 接口是 char 值的一个可读序列。

[2]是否包含子串

public static void main(String[] args) {
 
 // 【1】字符串连接
 String str1 = "hello";
 String str2 = str1.concat(" world"); // +
 System.out.println(str2);
 
 String str3 = "world";
 // 【2】查看字符串是否包含子串
 System.out.println(str2.contains("d"));
 
 String fileName = "abc.mp3";
 // 以xxx为后缀
 System.out.println(fileName.endsWith(".mp3"));
 // 以xxx为前缀
 System.out.println(fileName.startsWith("abc"));
 // 从指定位置开始判断是否存在xxx前缀
 System.out.println(fileName.startsWith("bc", 1));
 }

[3] 查找子串位置

public static void main(String[] args) {
 
 // 【3】 查找子串的位置
 String str1 = "hello worlod";
 // 从前向后查找指定字符第一次出现的位置，如果没找到，返回-1
 int r = -1;
 r = str1.indexOf(‘o‘);
 // 从前向后自定位置（fromIndex）查找指定字符第一次出现的位置，如果没找到，返回-1
 r = str1.indexOf(‘o‘, 5);
 // 从前向后查找指定字符串第一次出现的位置，如果没找到，返回-1
 r = str1.indexOf("lo");
 // 从前向后自定位置（fromIndex）查找指定字符串第一次出现的位置，如果没找到，返回-1
 r = str1.indexOf("lo",5);
 System.out.println(r);
 
 // 需求:不文明词语过滤
 String str2 = "你是沙雕";
 String str3 = "沙雕";
 int loc = -1;
 if( (loc=str2.indexOf(str3)) >=0 ) {
 String newStr =  str2.replace(str3, "**");
 System.out.println(newStr);
 }
 
 
 String str4 = "hello java";
 int r2 = -1;
 // 从后向前查找指定字符第一次出现的位置，如果没找到，返回-1
 r2 = str4.lastIndexOf(‘a‘);
 /*
 * str.lastIndexOf(‘xx‘,fromIndex)
 * str.lastIndexOf("xx")
 * str.lastIndexOf("xx",fromIndex)
 */
 System.out.println(r2);
 }

[4] 替换字符串

public static void main(String[] args) {
 
 // 【4】 替换字符串
 String str1 = "186-1234-1234";
 /**
 * \0 ascii 空字符
 * \u0000 unicode 空字符
 * char c = ‘\u4EC1‘;
 * System.out.println(c);
 * https://unicode-table.com/cn/#control-character
 */
 
 String str2 = str1.replace(‘-‘,Character.MIN_VALUE);
 String str3 = str1.replace("-","");
 System.out.println(str3);
 
 String str4 = "a1bc123cc11c";
 // 通过正则全部替换
 String str5 = str4.replaceAll("\\d+", "");
 // 通过正则替换第一次出现的字符串
 str5 = str4.replaceFirst("\\d+", "");
 // str5 = str1.replaceAll("-", "");
 System.out.println(str5);
String str6 = "123";
 // 判断字符串是否符合指定正则表达式
 System.out.println(str6.matches("\\d*"));
 }

[5] 分割字符串

public static void main(String[] args) {
 
 // 【5】 分割字符串
 String str1 = "186-1234-1234";
 String[] arr1 = str1.split("-");
 System.out.println(Arrays.toString(arr1));
 
 // 需求:请创建大写26个字符存入数组中
 String str2 = "ABCDEFGHI";
 String[] arr2 = str2.split("");
 System.out.println(Arrays.toString(arr2));
 
 }

[6]求子串

public static void main(String[] args) {
 
 // 【6】 求子串
 String str1 = "abcdef";
 // beiginIndex表示从指定位置开始截取，直到最后
 String str2 = str1.substring(3);
 // substring(beginIndex,endIndex)
 // 从beginIndex开始截取到endIndex,但不包含endIndex位置的字符
 // 含头不含尾
 str2 = str1.substring(0, 3);
 
 System.out.println(str2);
 }

[7]其他

public static void main(String[] args) {
 
 // 【7】 其他(大小写、去留白、格式化、返回指定编码的字节序列、判空、valueOf)
 // 大小写
 String str1 = "abc";
 System.out.println(str1.toLowerCase());
 System.out.println(str1.toUpperCase());
 
 // 去留白
 String str2 = " abc ";
 System.out.println(str2.length());
 System.out.println(str2.trim().length());
 
 // 格式化
 float price = 998.0f;
 float price2 = 1998.0f;
 char c = ‘￥‘;
 String s = "中";
 String str3 = String.format("$%f-$%f", price,price2);
 str3 = String.format("$%c", c);
 str3 = String.format("$%s", s);
 System.out.println(str3);
 
 // 返回指定编码的字节序列
 String str4 = "国";
 // byte[] byte4 = str4.getBytes();
 byte[] byte4 = null;
 try {
 byte4 = str4.getBytes("utf-8");
 } catch (UnsupportedEncodingException e) {
 e.printStackTrace();
 }
 System.out.println(Arrays.toString(byte4));
 
 // 判空
 String str5 = "";
 System.out.println(str5.isEmpty());
 
 // valueOf
 // 把其他数据类型->String
 String str6 = String.valueOf(10);
 System.out.println(str6);
 }

格式化占位符

%*	描述
%d	整形
%f	浮点型
%c	字符
%s	字符串

StringBuffer和StringBuilder

String 提供的API都是对包装的字符数组进行读取操作，不能对内部的字符数组进行修改。如果要对字符串进行破坏性操作(增、删、改)，一定需要一个字符串的可变版本。java字符串的可变版本有StringBuffer和StringBuilder

StringBuffer

StringBuffer是字符串的可变序列，本质上是一个字符数组的包装类。内部维护了一个char[] value 默认长度是16。当需要向StringBuffer添加元素时，首先有无足够空间，如果有，直接添加元素；如果没有，先拓容，后添加。

拓容原则: value*2+2即是新数组的容量，内部通过数组复制完成拓容。

StringBuffer是线程安全的

构造方法

public class Test01 {
 public static void main(String[] args) {
 // 默认16个unicode字符的空间
 StringBuffer sb1 = new StringBuffer();
 
 StringBuffer sb2 = new StringBuffer(32);
 
 StringBuffer sb3 = new StringBuffer("hello");
 System.out.println(sb3.capacity());
 }
}

常用方法

public class Test02 {
 public static void main(String[] args) {
 StringBuffer sb1 = new StringBuffer();
 
 // 【1】追加
 sb1.append(‘a‘);
 sb1.append("bc");
 sb1.append(10);
 System.out.println(sb1.length());
 
 // 【2】查看
 // 可能会产生StringIndexOutOfBoundsException
 //char c = sb1.charAt(5);
 //System.out.println(c);
 
 // 【3】删除(含头不含尾)
 sb1.delete(0, 3);
 System.out.println(sb1);
 
 // 【4】修改
 sb1.setCharAt(0, ‘A‘);
 System.out.println(sb1);
 }
}

 其他方法

public static void main(String[] args) {
 StringBuffer sb1 = new StringBuffer();
 
 // 【1】 自动拓容
 sb1.append("0123456789abcdef");
 System.out.println(sb1.capacity());
 
 sb1.append(‘A‘);
 System.out.println(sb1.capacity()); // 34 = 16*2+2
 
 // 【2】insert 在指定位置添加元素
 StringBuffer sb2 = new StringBuffer("abc");
 // 可能会出现ArrayIndexOutOfBoundsException
 sb2.insert(0, ‘A‘);
 System.out.println(sb2);
 
 // 【3】replace(start,end,str) 含头不含尾
 sb2.replace(0, 1, "中国");
 System.out.println(sb2.toString());
 
 // 中国abc
 // 【4】setLength(len) => 清空数组=>效率高
 sb2.setLength(0);
 
 
 // 【5】优化存储空间
 StringBuffer sb3 = new StringBuffer("abc");
 sb3.append("12");
 sb3.trimToSize();
 System.out.println(sb3.capacity());
 }

StringBuilder

相同点

[1] 都是字符串的可变序列 

[2] API都一样

不同点

[1] StringBuffer线程安全(同步操作)、效率低;StringBuilder线程不安全(不保证同步)、效率高

[2] stringbuffer jdk1.0;stringbuilder jdk1.5

字符串使用陷阱

String s = “a”; 造成性能问题！！！

[1] s = s + “b”

[2] for{ s = s + “b”}

12_常用类

原文：https://www.cnblogs.com/aknife/p/10978561.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)