19-Java-核心类库2-包装类、Integer类、String类、StringBuffer类、StringBuilder类

一、包装类

　　概念：包装类是为了值类型数据与对象之间能相互转换、提供自动装箱和自动拆箱机制的类。

　　　　　　　　(基本数据类型默认存储0，包装类型默认存储null)

　　　　　　　　

　　自动装箱：自动进行基本数据类型向包装类转换。

　　自动拆箱：自动进行包装类向基本数据类型转换。

二、Integer类（java.lang.Integer类，其余数值型的基本类型的包装类与此相似）

　　public final class Integer 
　　　　　　extends Number 
　　　　　　implements Comparable<Integer>

　    概念：java.lang.Integer类是java.lang.Number类的直接子类，是java.lang.Object类的间接子类。

　　　　　  用于包装int基本类型的数据。

　　　　　  该类由final关键字进行修饰，不可被继承，不可被修改。

　　　　　  该类重写了Object类的equals()、hashCode()、toString()方法

　　   Fields：

static int BYTES
用于二进制补码形式表示 int值的字节数。
static int MAX_VALUE
恒控股的最大值的 int可以有，2 三十一-1。
static int
MIN_VALUE
恒持最小值的 int可以有，- 2 三十一。
static int
SIZE
用于二进制补码形式表示 int值的比特数。
static 类<Integer> TYPE
类代表原始类型的实例 int。

　　   构造方法：

Integer(int value)
构建了一个新分配的 Integer表示指定的 int价值。
Integer(String s)
构建了一个新分配的 Integer表示 int值表示的 String参数。

　　   接口方法：

byte byteValue()
作为一个窄化转换后 byte返回该 Integer价值。
int comparaTo(Integer anotherInteger)
比较两 Integer对象数值。
double doubleValue()
为扩大基本转换后的 double返回该 Integer价值。
boolean equals(Object obj)
将此对象与指定的对象进行比较。
float floatValue()
为扩大基本转换后的 float返回该 Integer价值。
int hashCode()
返回此 Integer哈希代码。
int intValue()
作为一个 int返回该 Integer价值。
long longValue()
为扩大基本转换后的 long返回该 Integer价值。
short shortValue()
作为一个窄化转换后 short返回该 Integer价值。
String toString()
返回表示这 Integer价值 String对象。

　　   静态方法：

static int bitCount(int i)
返回在二进制补码表示的指定 int值的比特数。
static int compare(int x, int y)
比较两 int值的数值。
static int compareUnsigned(int x, int y)
比较两 int值数值处理的值为无符号。
static Integer decode(String nm)
解码 String为 Integer。
static int divideUnsigned(int dividend, int divisor)
返回将第一个参数除以每个参数的第二个值的无符号商，并将结果解释为一个无符号值。
static Integer getInteger(String nm)
用指定的名称确定系统属性的整数值。
static Integer getInteger(String nm, int val)
用指定的名称确定系统属性的整数值。
static Integer getInteger(String nm, Integer val)
用指定名称返回系统属性的整数值。
static int hashCode(int value)
返回一个 int值的哈希代码兼容 Integer.hashCode()。
static int highestOneBit(int i)
返回一个 int值在一个单一的一个点，在最高的位置（“左”）在指定 int价值一点。
static int lowestOneBit(int i)
返回一个 int值在一个单一的一个点，在最低阶的位置（“右”）在指定 int价值一点。
static int max(int a, int b)
返回大两 int值如果通过调用 Math.max。
static int min(int a, int b)
返回小两 int值如果通过调用 Math.min。
static int numberOfLeadingZeros(int i)
返回零位前最高阶数（“左”）的二进制补码表示的指定 int价值一点。
static int numberOfTrailingZeros(int i)
返回零位以下的最低阶数（“右”）在二进制补码表示的指定 int价值一点。
static int parseInt(String s)
将字符串参数作为带符号的十进制整数。
static int parseInt(String s, int radix)
将字符串参数作为一个符号整数，进制由第二个参数指定。
static int parseUnsignedInt(String s)
将字符串参数为一个无符号的十进制整数。
static int parseUnsignedInt(String s, int radix)
将字符串参数作为进制由第二个参数指定一个无符号整数。
static int remainderUnsigned(int dividend, int divisor)
返回由第二个在每个参数和结果被解释为一个无符号值的第二个分区的第一个参数的无符号的剩余部分。
static int reverse(int i)
返回通过逆转的二进制补码表示的指定 int值的比特顺序得到的值。
static int reverseBytes(int i)
返回通过逆转的二的补码表示指定的 int值的字节的顺序得到的值。
static int rotateLeft(int i, int distance)
返回通过旋转的二进制补码表示的指定 int值指定的位数左得到的值。
static int rotateRight(int i, int distance)
返回值通过旋转的二进制补码表示的指定 int值指定的位数吧。
static int signum(int i)
返回指定 int价值符号函数。
static int sum(int a, int b)
按+运算符添加两个整数。
static String toBinaryString(int i)
在基地 2无符号整数返回整数参数的字符串表示形式。
static String toHexString(int i)
在基地 16无符号整数返回整数参数的字符串表示形式。
static String toOctalString(int i)
在基地 8无符号整数返回整数参数的字符串表示形式。
static String toString(int i)
返回表示指定的整数 String对象。
static String toString(int i, int radix)
返回由第二个参数指定的基数的第一个参数的字符串表示形式。
static long toUnsignedLong(int x)
转换参数的符号转换 long。
static String toUnsignedString(int i)
返回一个参数的字符串表示形式，作为一个无符号的十进制值。
static String toUnsignedString(int i, int radix)
将第一个参数的字符串表示形式，返回在第二个参数指定的基数中的符号整数值。
static Integer valueOf(int i)
返回一个 Integer实例表示指定的 int价值。
static Integer valueOf(String s)
返回一个 Integer对象持有指定的 String价值。
static Integer valueOf(String s, int radix)
返回一个 Integer持物提取指定的 String解析时由第二个参数给定值的基数。

　　　Integer类常用的接口方法和静态方法：

　　　　　　int　intValue()　　作为一个 int返回该 Integer的值，用于Integer类的拆箱。

　　　　　　static Integer valueOf(int i)　　返回一个 Integer实例表示指定的 int价值，用于int基本类型的装箱。

　　　　　　Integer(int value)　　Integer类的构造方法，构建了一个新分配的 Integer表示指定的 int价值。

　　　　　　Integer(String s)　　Integer类的构造方法，构建了一个新分配的 Integer表示 int值表示的 String参数。

　　　　　　static int  parseInt(String s)　　将字符串参数作为带符号的十进制整数,用于将十进制数值类型的字符串转换为int。("12345a"像这样的字符串会报数据格式异常的错)。

　　　注意点(代码演示)：　

 1 public class IntegerTest {
 2     public static void main(String[] args){
 3         int intnum = 100;
 4         Integer integernum = 200;//此处有自动装箱，自动调用了Integer.valueOf()方法
 5         intnum = integernum;//此处有自动拆箱，自动调用了Integer.intValue()方法
 6         
 7         //以下内容为面试坑题
 8         Integer num1 = 128;
 9         Integer num2 = 128;
10         Integer num3 = new Integer(128);
11         Integer num4 = new Integer(128);
12         
13         System.out.println("check1 = "+(num1 == num2));//false
14         System.out.println("check2 = "+(num1.equals(num2)));//true
15         System.out.println("check3 = "+(num3 == num4));//false
16         System.out.println("check4 = "+(num3.equals(num4)));//true
17         System.out.println("-----------------------------------");
18         Integer num5 = 127;
19         Integer num6 = 127;
20         Integer num7 = new Integer(127);
21         Integer num8 = new Integer(127);
22         
23         System.out.println("check5 = "+(num5 == num6));//true
24         System.out.println("check6 = "+(num5.equals(num6)));//true
25         System.out.println("check7 = "+(num7 == num8));//flase
26         System.out.println("check8 = "+(num7.equals(num8)));//true
27         
28         //1.java中基本类型的包装类大都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean。
29         //2.以上5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。 
30         //3.两种浮点数类型的包装类Float,Double并没有实现常量池技术。
31         //4.String类也实现了常量池技术，String的面试坑题具体看我之前的博文有提到
32     }
33 }

　　　运行结果：

　　　　　　　

三、String类(java.lang.String类)

　  public final class String

　　　　　　extends Object

　　　　　　implements Serializable, Comparable<String>, CharSequence

　　概念：  java.lang.String类是java.lang.Object类的直接子类。

　　　　　  该类由final关键字进行修饰，不可被继承，不可被修改。

　　　　　  该类重写了Object类的equals()、hashCode()、toString()方法

　　　　　  该类重写了Comparable接口的compareTo()方法,CharSequence接口的charAt()方法等

　　　　　  注意：String类表示的字符串。java程序中的所有字符串，如 "abc"，实现这个类的实例。

　　　　　　　　  java字符串在内存中采用Unicode编码方式，任何一个字符对应两个字节的定长编码。

　　　　　　　　  字符串是常量，它们的值不能被创建后改变。支持可变字符串字符串缓冲区。因为字符串对象是不可改变的，所以它们可以被共享。　

　　　　　　　　  例如:　　　　String str = "abc";

　　　　　　　　  相当于：　　char data[] = {'a', 'b', 'c'}; String str = new String(data);

1 　　　　 String str1 = "abc";//在常量池新建立了一个字符串"abc",同时新建了一个String对象str1
2         System.out.println(str1.hashCode());
3         String str2 = "123";//在常量池新建立了一个字符串"123",同时新建了一个String对象str2
4         System.out.println(str2.hashCode());
5         str1 = "123";//此处并未修改"abc"字符串本身，只是str1对象修改了指向常量池中字符串的引用
6         System.out.println(str1.hashCode());

　　　　　　运行结果：

　   常用方法：String()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 初始化新创建的 String对象，它代表了一个空字符序列。

　　　　　　　  String(char[] value)　　　　　　　　　　　　　　　　　　　　　　　　　 分配一个新的 String，它代表了目前包含在字符数组参数字符序列。

　　　　　  　　String(char[] value, int offset, int count)　　　　　　　　　　　　 分配一个包含字符与字符数组数组参数的新 String。value阵列是字源，

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  offset参数指定的子阵列的第一个字符的索引和 count参数指定的数组的长度

　　　　　　　  char[]　toCharArray()　　　　　　　　　　　　　　　　　　　　　　　　　 将此字符串转换为一个新的字符数组。

　　　　　　  　String(String original)　　　　　　　　　　  　　　　　　　　　　　　 初始化新创建的对象 String所以它代表相同的字符序列的说法；

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  换句话说，新创建的字符串是一个副本的参数字符串。

　　　　　　　  String(StringBuffer buffer)　　　　　　　　　 　　　　　　　　　　　　 分配一个新字符串，该字符串包含当前包含在字符串缓冲区中字符序列的字符串。

　　　　　　　  String(StringBuilder builder)　　　　　　　　 　　　　　　　　　　　　 分配一个新的字符串，该字符串包含当前包含在字符串生成器参数中字符的序列。

　　　　　　　  char　charAt(int index)　　　　　　　　　　　 　　　　　　　　　　　　 返回指定索引的 char价值。

　　　　　　　  int　length()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 返回此字符串的长度。　　　

　　　　　　　  int　compareTo(String anotherString)　　　　　　　　　　　　　　　　　 比较两个字符串的字典。

　　　　　　　  int　compareToIgnoreCase(String str)　　　　　　　　　　　　　　　　　 按字典顺序比较两个字符串，忽略大小写的差异。

　　　　　　　  boolean　equals(Object anObject)　　　　　　　　　　　　　　　　　　　 将此字符串与指定的对象比较。

　　　　　　　  boolean　endsWith(String suffix)　　　　　　　　　　　　　　　　　　　 测试如果这个字符串以指定的后缀结束。

　　　　　　　  boolean　startsWith(String prefix)　　　　　　　　　　　　　　　　　　 测试这个字符串是否以指定的前缀开始。

　　　　　　　  static String　copyValueOf(char[] data)　　　 　　　　　　　　　　　　 相当于 valueOf(char[])。

 　　　　　　　 static String　copyValueOf(char[] data, int offset, int count)　　　 相当于 valueOf(char[], int offset, int count)。

　　　　　　　  void　getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)　将此字符串的字符复制到目标字符数组中。

　　　　　　      boolean　isEmpty()　　　　　　　　　　　　　　　　　　　　　　　　　　　返回 true如果，如果， length()是 0。

　　　　　　　  String　toUpperCase()　　　　　　　　　　　　　　　　　　　　　　　　　 转换为大写的字符串。

　　　　　　　  String　toLowerCase()　　　　　　　　　　　　　　　　　　　　　　　　　 转换为小写的字符串。

　　　　　　　  String　trim()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　返回一个字符串，它的值是字符串，任何前导和尾随空格删除。

　　　　　　　  boolean　matches(String regex)　　　　　　　　　　　　　　　　　　　　 告诉是否这个字符串匹配给定 regular expression。

　　　　　　　  String　substring(int beginIndex, int endIndex)　　　　　　　　　　　 返回一个字符串，这个字符串的子串。

　　　　　　　  int　lastIndexOf(int ch)　　　　　　　　　　　　　　　　　　　　　　　 返回在指定字符的最后一个发生的字符串内的索引。

　　　　　　　  int　indexOf(String str)　　　　　　　　　　　　　　　　　　　　　　　 返回指数在这个字符串指定的子字符串中第一个出现的。

　　　　　　　  int　lastIndexOf(String str)　　　　　　　　　　　　　　　　　　　　　 返回指数在这个字符串的指定子字符串中最后出现。

　　　　　　　  boolean　contains(CharSequence s)　　　　　　　　　　　　　　　　　　　如果并且只有当此字符串包含指定的字符序列的字符串值，则返回真值。

　　　　　　　  String　replace(char oldChar, char newChar)　　　　　　　　　　　　　 返回从字符串中替换所有出现在 newChar oldChar结果字符串。

 　　　　　　　 CharSequence　subSequence(int beginIndex, int endIndex)　　　　　　　 返回一个字符序列的子序列。

　　　　　　　  String[] split(String regex)　　　　　　　　　　　　　　　　　　　　　将此字符串以给定的 regular expression为间隔分割字符串为字符串数组。

三、StringBuffer类和StringBuilder类(java.lang.StringBuffer类和java.lang.StringBuilder类)

　　特点：    由于String类描述字符序列是不可以改变的，因此描述多个类似的字符串需要单独保存，但此时内存空间消耗比较大，

　　　　 为了节省内存空间而直接对对象字符序列本身进行修改，则使用StringBuffer和StringBuilder。

　　　　　　 该类没有重写Object类的equals()、hashCode()方法，但是重写了toString()方法

　　 区别：StringBuffer名为字符串缓冲区，是从JDK1.0开始就存在的，属于线程安全的类，但效率比较低

　　　　　 StringBuilder名为字符串生成器，是从JDK1.5开始出现的，属于非线程安全的类，但效率相对更高

 

 

　   常用方法：StringBuilder(String str)　　　　　　　　　　　　　　　　　　　　 构造一个初始化为指定字符串内容的字符串生成器(初始容量16个字符+参数长度)。

　　　　　　　 StringBuffer(String str)　　　　　　　　　　　　　　　　　　　　　构造一个初始化为指定字符串内容的字符串缓冲区(初始容量16个字符+参数长度)。

　　　　　　　 int　　capacity()　　　　　　　　　　　　　　　　　　　　　　　　 返回当前容量。

　　　　　　　 int　　length()　　　　　　　　　　　　　　　　　　　　　　　　　 返回长度（字符数）。

 

　　　　　　　 StringBuilder insert(int offset, String str) 　　　　　　　　　　 插入的 String参数的字符串表示形式进入这个序列的指定下标位置。

　　　　　　　 StringBuilder append(String str)　　　　　　　　　　　　　　　　　　　将指定的字符串，追加到这个字符序列的尾部。

　　　　　　　 StringBuilder delete(int start, int end) 　　　　　　　　　　　　　　　　  删除的字符在字符串序列分析。　

　　　　　　　 StringBuilder reverse() 　　　　　　　　　　　　　　　　　　　　　　   使这个字符序列被序列的反转所取代 

　　　　　　　 String substring(int start, int end) 　　　　　　　　　　　　　　　　　　  返回一个包含目前包含在这个序列的子序列特征的新 String。

　　　　　　　 StringBuilder replace(int start, int end, String str) 　　　　　　　　　　　  在一个字符串中替换指定的 String字符这个序列的特征。    

　　　　　　　 char charAt(int index) 　　　　　　　　　　　　　　　　　　　　　　　  返回指定索引在这个序列的 char价值。    

　　　　　　　 String toString() 　　　　　　　　　　　　　　　　　　　　　　　　　　返回表示该序列中的数据的字符串。

 1         //StringBuilder类描述的字符序列本身会改变
 2         StringBuilder sb1 = new StringBuilder("abcd");
 3         StringBuilder sb2 = sb1.append("1234");
 4         System.out.println(sb1);
 5         System.out.println(sb2);
 6         
 7         //String类描述的字符序列本身不会改变
 8         String sb3 = "abcd";
 9         String sb4 = sb3.toUpperCase();
10         System.out.println(sb3);
11         System.out.println(sb4);

　　　　　　

 

 

 

posted @ 2020-04-13 19:21  我只是一个码农  阅读(295)  评论(0)  编辑  收藏  举报