写在前面的部分
本周主要学习了JavaSE中常用类部分，其中学习了Object类，Class类，String类，System类，Scanner类，SItringBuffer类，Integer类，Character类
1.Object类
a. 定义：
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类(父类)。所有对象（包括数组）都实现这个类的方法。
b. 常用方法：
（1）hashcode() : public int hashCode()返回该对象的哈希码值
hashCode()----->通过哈希算法(哈希表:hashtable)---->地址值(不是实际意义上的地址值!)
每次运行引用类型得到的哈希码值为随机值，不固定；而常量的哈希码不变Student s1 = new Student() ; System.out.println(s1.hashCode());//1460821906 Student s2 = new Student() ; System.out.println(s2.hashCode());//2045891656
（2）getClass()：返回此
Object的运行时类（反射机制）返回值为Class类对象
全路径名称：包.类名Class c1 = s1.getClass() ; // System.out.println("c1:"+c1);//class org.westos.object_01.Student
扩充：Class类中getName()方法 :获取当前正在运行的这类的全路径名称!
（3）toString()：public String toString();返回该对象的字符串表示(建议所有子类都重写此方法)
由源码可知直接调用toString方法会返回全路径名称 + @ + 哈希码值//查看toString()源码: public String toString() { return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode()); } //toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
/*System.out.println("s1:"+s1);//org.westos.object_02.Student@7439aca7 //public String toString() System.out.println("toString():"+s1.toString());//org.westos.object_02.Student@7439aca7 System.out.println("--------------------------");*/
Java中如果直接输出对象名称，会自动编码为调用对象的toString方法，如果该类没有重写toString方法，那么会自动按照源码格式输出
所以建议所有子类重写此方法
自动生成时可根据局部变量自动生成对应的toString方法//当前toString()是自己去写的 /* @Override public String toString() { return name+"---"+age; }*/ //alt+shift+s->s //自动生成即可! @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; }（3）equals（obj）：public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。
1）思考：== 和equals的区别：
==:比较的是两个对象的地址值是否相同,
equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同2）源码：
底层调用equals方法还是用==实现public boolean equals(Object obj) { return (this == obj);3）重写：当想要让equals方法比较内容或局部变量的值是否相同时，可用工具自动生成重写的方法
（4）finalize()： protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法,但是,什么时候调用垃圾回收器不确定;//重写了Object类中的equals()方法 @Override public boolean equals(Object obj) { //Studnet s2 = new Student() ; if (this == obj) return true; if (obj == null) //当前传入过来的对象是否为空 return false; if (getClass() != obj.getClass()) //this.getClass() != s2.getClass() return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; }
扩充： System类中gc()方法 运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法（5） clone() ：protected Object clone() throws CloneNotSupportedException创建并返回此对象的一个副本
1）注意：
Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。
2）应用：
//学生类 //要去使用clone()方法,当前对象所在的类一定要实现cloneable接口, public class Student implements Cloneable{ //重写Object类中clone() @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }clone方法会得到一个和原对象没有任何关系的对象public class ObjectDemo { public static void main(String[] args) throws CloneNotSupportedException {//该异常是编译时期异常 //创建s1这个学生对象 Student s1 = new Student() ; s1.setName("高圆圆") ; s1.setAge(27) ; System.out.println(s1.getName()+"---"+s1.getAge()); //复制s1这个对象 Object obj = s1.clone() ; //向下转型: Student s2 = (Student) obj; System.out.println(s2.getName()+"---"+s1.getAge()); System.out.println("----------------------"); //没有讲clone方法之前: Student s3 = s1; //把s1地址值赋值s3对象,s3指向s1的堆内存中的地址值 System.out.println(s3.getName()+"---"+s3.getAge()); } }
2.Scanner类——文本扫描器（键盘录入）
a.IO流 （BufferedReader）
b. Scanner sc = new Scanenr(System.in);
System类中的静态字段
（1）in ：输入
（2）out：输出
（3）err：错误
c.常用方法：
（1） nextXXX(): 获取除char以外类型的数据（ nextInt()、nextLine()）
nextInt();
（2） hasNextXXX()：在录入数据之前,加上判断功能,判断录入的数据是否为XXX类型的数据
public boolean hasNextInt()
（3）java.util.InputMismatchException
d. 注意事项：
先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据
解决方案：
（1）录入Sreing类型时使用sc.next()而不是使用sc.nextLine()
（2）在第二次录入之前，重新创建sc对象录入
3.String类
a. 定义：代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变b. 常用的构造方法（1）String():表示一个空字符序列。
（2）public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第 二个参数
（3）public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
（4）public String(char[] value):将字符数组构造成一个字符串
（5）public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
（6）public String(String original):通过字符串常量构造一个字符串对象（7）获取字符串的长度的功能 ： public int length()扩充：
数组没有length(),length属性
字符串中有length()
集合中没有length(),获取集合中元素数量:size()
c. 注意事项： 字符串的一个特点:一旦被赋值,其值不能被改变(不可变的字符序列)public class StringDemo { public static void main(String[] args) throws UnsupportedEncodingException { //创建一个String对象 String s1 = new String() ; System.out.println("s1.length():"+s1.length()); System.out.println("s1:"+s1); System.out.println("----------------------"); //public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数 //创建一个字节数组 byte[] bys = {97, 98, 99, 100, 101} ; String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符 System.out.println("s2:"+s2); //abcde System.out.println("s2.length():"+s2.length());//5 System.out.println("----------------------"); / 编码和解码 / //定义一个字符串: String s = "你好" ; //[-60, -29, -70, -61] :GBK //[-28, -67, -96, -27, -91, -67]:utf-8 // byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码 utf-8:一个中文:对应三个字节 byte[] bys2 = s.getBytes() ; // System.out.println(bys2); //Arrays:数组工具类:toString(byte[] bys) System.out.println(Arrays.toString(bys2)); System.out.println("-------"); // String str = new String(bys2, "utf-8") ; String str = new String(bys2) ; System.out.println("str:"+str); System.out.println("------------------"); //public String(char[] value):将字符数组构造成一个字符串 //定义一个字符数组 char[] chs = {'我','爱','高','圆','圆'} ; String s3 = new String(chs) ; System.out.println("s3.length():"+s3.length()); System.out.println("s3:"+s3); System.out.println("--------------------"); String s4 = new String(chs, 1, 4) ; System.out.println("s4:"+s4); System.out.println("s4.length():"+s4.length()); System.out.println("--------------------"); //public String(String original):通过字符串常量构造一个字符串对象 String s5 = new String("hello") ; System.out.println("s5:"+s5); System.out.println("s5.length():"+s5.length()); String s6 = "hello" ; System.out.println("s6:"+s6); System.out.println("s6.length():"+s6.length()); } }String s = "hello"
和String s = new String("hello") 两个有什么区别?分别创建了几个对象
第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))
d. String类常用的判断功能：
（1）boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
（2）boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
（3）boolean contains(String str):判断str这个字符串是否包含在当前字符串中
（4）boolean startsWith(String str):是否以str子字符串开头
（5）boolean endsWith(String str):判断是否以str子字符串结尾
（6）boolean isEmpty():判断字符串是否为空
public class StringDemo { public static void main(String[] args) { //定义一个字符串 String s1 = "helloworld" ; String s2 = "HelloWorld" ; // boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同 System.out.println("equals:"+s1.equals(s2)); //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写 System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2)); //boolean contains(String str):判断str这个字符串是否包含在当前字符串中 System.out.println("contains:"+s1.contains("owo")); System.out.println("contains:"+s1.contains("ak47")); //boolean startsWith(String str):是否以str子字符串开头 System.out.println("starsWith:"+s1.startsWith("hel")); //boolean endsWith(String str):判断是否以str子字符串结尾 自己测试 //boolean isEmpty():判断字符串是否为空 System.out.println("isEmpty:"+s1.isEmpty()); } }
f. 注意事项：
（1） 字符串变量相加,先开辟空间,在相加（先开辟一个新的空间存储再把两个字符串相加存储进新的空间）——类似于匿名对象
（2）字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!
public class StringDemo2 { public static void main(String[] args) { String s1 = "hello"; String s2 = "world"; String s3 = "helloworld"; System.out.println(s3 == s1 + s2);// false //System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString()); // s1+s2 ====>new String("helloworld") System.out.println(s3.equals((s1 + s2)));//true , System.out.println(s3 == "hello" + "world");//true System.out.println(s3.equals("hello" + "world"));//true /* 通过反编译工具查看第三个输出语句: System.out.println(s3 == "helloworld"); System.out.println(s3.equals("helloworld")); */ }
g. 获取功能：
（1）int length() :获取字符串长度功能
（2）char charAt(int index):返回的是索引处对应的字符
（3）int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义:（ascii码）
（4）int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
（5）int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始 搜索。
（6）int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索 引开始搜索
（6）String substring(int start):从指定位置开始截取字符串,默认截取到末尾
（7）String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end 索引)
public class StringDemo { public static void main(String[] args) { //定义一个字符串: String str = "helloworld" ; //int length() :获取字符串长度功能 System.out.println("length:"+str.length()); //char charAt(int index):返回的是索引处对应的字符 System.out.println("charAt:"+str.charAt(1)); System.out.println("charAt:"+str.charAt(8)); System.out.println("-------------------------------"); //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引 System.out.println("indexof:"+str.indexOf('l')); System.out.println("indexof:"+str.indexOf('k'));//-1 //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引 System.out.println("indexOf:"+str.indexOf("owo")); System.out.println("-------------------------------"); //int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 System.out.println("indexOf:"+str.indexOf('l', 4)); //int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试) //String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!) System.out.println("substring:"+str.substring(5)); //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引) System.out.println("substring:"+str.substring(4, 8));//owor } }h. 转换功能：
（1）byte[] getBytes():将字符串转换字节数组
（2）char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
（3）static String valueOf(char[] chs):将字符数组转换成字符串
（4）static String valueOf(int i):将一个int类型的数据转换成字符串
注意: String类中的valueOf()可以将任何数据类型转换成字符串
（5）String toLowerCase():将字符串全部转成小写
（6）String toUpperCase():将字符串全部转换成大写
（7）String concat(String str):字符串拼接方法
public class StringDemo { //构造方法: //构造方法不能使用递归 /public StringDemo(){ StringDemo(); }/ public static void main(String[] args) { //定义一个字符串 String s = "JavaSE" ; //byte[] getBytes():将字符串转换字节数组 byte[] bys = s.getBytes() ; //遍历字节数组 for(int x = 0 ; x < bys.length ; x++){ System.out.println(bys[x]); } System.out.println("---------------------"); //char[] toCharArray():将字符串转换成 字符数组 char[] chs = s.toCharArray() ; for (int x = 0; x < chs.length; x++) { System.out.println(chs[x]); } System.out.println("---------------------"); //static String valueOf(char[] chs):将字符数组转换成字符串 String s2 = String.valueOf(chs) ; System.out.println("s2:"+s2); //static String valueOf(int i):将一个int类型的数据转换成字符串 String s3 = String.valueOf(100) ; System.out.println("s3:"+s3); //String toLowerCase():将字符串全部转成小写 System.out.println("toLowerCase:"+s.toLowerCase()); //String toUpperCase():将字符串全部转换成大写 System.out.println("toUpperCase:"+s.toUpperCase()); //String concat(String str):字符串拼接方法 String s4 = "hello" ; String s5 = "world" ; System.out.println("contact:"+s4.concat(s5)); String s6 = "java" ; s6 += "web" ; System.out.println("s6:"+s6);
i. 其他功能 ：
（1）替换功能：
1）public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
2）public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
（2）去除字符串两端空格:public String trim()
（3）比较： public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)
如果在str2长度范围内有不同的字符，则返回c1 - c2public int compareTo(String anotherString) {anotherString==>s2="hel" int len1 = value.length; //s1.length= 5 int len2 = anotherString.value.length;// s2.length: = 3 int lim = Math.min(len1, len2);// Math.min(5,3) ;=====>int lim = 3 ; char v1[] = value;//'h','e','l','l','0' char v2[] = anotherString.value;//"hel" int k = 0; while (k < lim) { k< lim=3 char c1 = v1[k]; // char c1 = 'h','e','l','l','0' = v1[k] = 'h' char c2 = v2[k]; //char c2 = 'h','e','l' = v2[k] = 'h' if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; // len1 - len2 = s1.length() - s2.lenth() = 5 -3 = 2 }如果str2长度范围内没有不同的字符，则返回len1-len2
4.递归
}a. 定义 ：方法调用本身的一种现象b. 条件（1） 需要定义个方法（2） 方法必须有出口条件（3） 必须有某一种规律
//需求:求5的阶乘 //5! = 5 4 3 2 1 ; //5! = 5 4! ; int jc = 1 ; //循环思想 for(int x = 2 ; x <=5 ; x ++){ jc = x; } System.out.println("5的阶乘是:"+jc); System.out.println("-------------------------"); //使用递归的思想: //需要定义个方法 System.out.println("5的阶乘是:"+jieCheng(5)); } /* 明确返回值类型: int类型 参数类型:int类型的值 2)出口条件: if(n==1){ return 1 ; } 3)要有规律 if(n!=1){ return n 方法名(n-1); } * / public static int jieCheng(int n){ if(n==1){ return 1 ; }else{ return n jieCheng(n-1) ; //5 4 3 1 １ } }
5.StringBuffer类
a. 定义 ：线程安全的可变字符序列b. StringBuffer和String 的区别?StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使 用StringBulider替代
StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
String:普通的一个字符串,从内存角度考虑,耗费空间!
c. 构造方法 ：
（1）public StringBuffer ()： 构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
（2）public StringBuffer(int capacity) ：构造一个不带字符，但具有指定初始容量的字符串缓冲区
（3）public StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。 该字 符串的初始容量为 16 加上字符串参数的长度。
d. 常用功能 ：
（1）public int length():获取字符串长度数
（2）public int capacity():获取当前字符串缓冲区的容量（3）添加有关的方法：public class StringBufferDemo { public static void main(String[] args) { // StringBuffer sb = "hello" ; // String s = "hello" ; // StringBuffer sb = s ; // public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符 //创建一个字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; System.out.println("sb.length:"+sb.length()); System.out.println("sb.capacity:"+sb.capacity());//16 System.out.println("----------------------------"); // public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区 StringBuffer sb2 = new StringBuffer(50) ; System.out.println("sb2.length:"+sb2.length()); System.out.println("sb2.capacity:"+sb2.capacity());//50 System.out.println("----------------------------"); StringBuffer sb3 = new StringBuffer("hello") ; System.out.println("sb3.length:"+sb3.length()); System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度 } }
1）：public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)2）public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身public class StringBufferDemo2 { public static void main(String[] args) { //创建一个字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //追加数据 /* sb.append("hello") ; sb.append(true) ; sb.append(13.45) ; sb.append('A') ; sb.append(12.56F);*/ //链式编程 sb.append("hello").append(true).append(13.45).append('A').append(12.56F); //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身 sb.insert(5, "world") ; //输出 System.out.println("sb:"+sb); } }（4）删除功能：
1）public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
2）public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!（包前不包后）
public class StringBufferDemo3 { public static void main(String[] args) { //创建字符串缓冲区对象 StringBuffer sb = new StringBuffer() ; //给缓冲区追加数据 sb.append("hello") ; sb.append("world") ; sb.append("java") ; public StringBuffer deleteCharAt(int index) //需求:要删除当前缓冲区中'e'这个字符 sb.deleteCharAt(1) ; //需求:要删除当前缓冲区中第一个'l'这个字符 sb.deleteCharAt(1) ; // public StringBuffer delete(int start,int end) sb.delete(5, 9) ; //从0索引开始,当前缓冲的字符串全部删除掉 sb.delete(0, sb.length()) ; //输出 System.out.println("sb:"+sb); } }（5）字符串反转功能：public StringBuffer reverse():将此字符串中的字符序列直接反转
public class StringBufferDemo4 { public static void main(String[] args) { //创建键盘录入对象 Scanner sc = new Scanner(System.in) ; //录入并接收数据 System.out.println("请您输入一个字符串:"); String line = sc.nextLine() ; //可以创建字符串缓冲区对象 StringBuffer sb = new StringBuffer(line) ; //public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String //反转功能 String result = sb.reverse().toString() ; System.out.println("result:"+result); } }//StringBuffer的rever()方法实现 public static String myReverse2(String s){ //创建字符串缓冲区对象h /*StringBuffer sb = new StringBuffer(s) ; //开始调用反转功能 sb.reverse() ; //返回 return sb.toString() ;*/ //一步完成: return new StringBuffer(s).reverse().toString() ; }（6）替换功能： public StringBuffer replace(int start, int end,String str) 从指定位置开始到指定位置结束的字符用str子字符串去替代
（7）截取功能：
1）public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
2）public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
e. StringBuffer和数组的区别
两个共同特点:都属于容器类型的变量
数组:只能存储同一种数据类型的元素,数组的长度是固定的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串
f. StringBuffer和String之间的转换
*/ public class StringBufferTest { public static void main(String[] args) { //String--->StringBuffer //定义一个字符串 String s = "hello" ; /*StringBuffer sb = "hello" ; StringBuffer sb = s ;*/ //方式1)使用StringBuffer的构造方式:StringBuffer(String str) //创建一个字符串缓冲区并指向这个字符串 StringBuffer sb = new StringBuffer(s) ; System.out.println("sb:"+sb); //方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append() StringBuffer sb2 = new StringBuffer() ; sb2.append(s) ; System.out.println("sb2:"+sb2); System.out.println("--------------------"); //StringBuffer--->String //有一个字符串缓冲区对象 StringBuffer buffer = new StringBuffer("world") ; //1)方式1String的另一种构造方法:String(StringBuffer buffer) String s2 = new String(buffer) ; System.out.println("s2:"+s2); //2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String String s3 = buffer.toString() ; System.out.println("s3:"+s3); } }
6.Integer
a. 概念：JDK5之后int类型自动装箱为Integer类b. 字段：
（1）MAX_VALUE值为 231－1 的常量，它表示int类型能够表示的最大值。（2）MIN_VALUE值为 －231 的常量，它表示int类型能够表示的最小值。c. 构造方法：
（1）public Integer(int value):将一个int类型的数据封装成一个引用类型
（2）public Integer(String s):将一个字符数类型封装成一个Integer类型（必须为数字字符串）
d. String与Int的转换
public class IntegerTest { public static void main(String[] args) { //定义一个int类型的数据 int number = 100 ; //方式1)字符串拼接符 String s1 = "" + number ; System.out.println("s1:"+s1); //方式2:int--->Integer类型 Integer i = new Integer(number) ; //Integer--->String //public String toString() String s2 = i.toString() ; System.out.println("s2:"+s2); //方式3)public static String toString(int i) String s3 = Integer.toString(number) ; System.out.println("s3:"+s3); //方式4) //public static Integer valueOf(int i) Integer integer= Integer.valueOf(number) ; String s4 = integer.toString() ; System.out.println("s4:"+s4); System.out.println("---------------------------"); //定义一个字符串: String s = "10" ; //方式1:String--->Integer---->int Integer ii = new Integer(s) ; //public int intValue()以 int 类型返回该 Integer 的值 int num = ii.intValue() ; System.out.println("num:"+num); //public static int parseInt(String s) int num2 = Integer.parseInt(s) ; System.out.println("num2:"+num2); //Integer的内存缓存区:IntegerCashe //low = -128 //high=127 Integer i1 = 127 ; //----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ; Integer i2 = 127 ; System.out.println(i1==i2);//true Integer i3 = 128 ; Integer i4 = 128 ; System.out.println(i3==i4);//false } }
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
