Java学习-第一部分-第二阶段-第四节：常用类

九天猎人 · 2022-9-16 17:19:41

常用类

笔记目录：(https://www.cnblogs.com/wenjie2000/p/16378441.html)
包装类

包装类的分类

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

基本数据类型包装类booleanBooleancharCharacterbyteByteshortShortintlntegerlongLongfloatFloatdoubleDouble继承体系

包装类和基本数据的转换
演示包装类和基本数据类型的相互转换,这里以int和 Integer演示。

jdk5 之前的手动装箱和拆箱方式，装箱:基本类型->包装类型,反之，拆箱
jdk5以后(含jdk5)的自动装箱和拆箱方式
自动装箱底层调用的是valueOf方法，比如Integer.valueOf()
其它包装类的用法类似，不一一举例

public static void main(String[] args) {
//jdk5前是手动装箱和拆箱
// 手动装箱int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer -> int
int i = integer.intValue();
//jdk5后，就可以自动装箱和自动拆箱
int n2 = 200;
//自动装箱int->Integer
Integer integer2 = n2;//底层使用的是 Integer.valueOf(n2)
//自动拆箱Integer->int
int n3 = integer2;//底层仍然使用的是 intValue()方法
}

复制代码

包装类型和String类型的相互转换
案例演示,以lnteger和String转换为例，其它类似:

public static void main(String[] args) {
//包装类(Integer)->String
Integer i = 100;//自动装箱
//方式1
String str1 = i +"";
//方式2
String str2 = i.toString();
//方式3
String str3 = String.valueOf(i);
//String ->包装类(Integer)
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器
System.out.println( "ok~~");
}

复制代码

Integer类和Character类的常用方法
Integer类和Character有些常用的方法，我们一起来使用一下。

public static void main(String[] args) {
System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit( 'a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写
System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写
}

复制代码

Integer面试题

看看下面代码,输出什么结果?为什么?
1. public static void main(String[] args) {
2. Integer i = new Integer(1);
3. Integer j = new Integer(1);
4. System.out.println(i ==j);//False
5. // 所以，这里主要是看范围-128 ~ 127就是直接返回
6. //源码
7. //public static Integer valueOf(int i) {
8. // if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
9. // return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
10. // return new Integer(i);
11. //}
12. //1.如果i 在IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
13. // 2．如果不在 -128~127,就直接 new Integer(i)
15. Integer m = 1;//底层Integer.value0f(1); ->阅读源码
16. Integer n= 1;//底层Integer.valueOf(1);
17. System.out.println(m==n); //T
18. // 所以，这里主要是看范围-128 ~ 127就是直接返回
19. // ，否则，就new Integer(xx);
20. Integer x = 128;//底层Integer.valueOf(1);
21. Integer y = 128;//底层Integer. valueOf(1);
22. System.out.println(x=y);//False
23. }
复制代码
看看下面代码,输出什么结果.
1. public static void main(String[] args) {
2. //示例1
3. Integer i1=127;
4. int i2=127;
5. //只要有基本数据类型，判断的是
6. //值是否相同
7. System.out.println(i1==i2);
8. //示例2
9. Integer i3=128;
10. int i4=128;
11. System.out.println(i3==i4);
12. }
复制代码

String类

String类的理解和创建对象

String对象用于保存字符串,也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如:"你好"、"12.97"、"boy"等
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
String类较常用构造器(其它看手册):

String s1 =new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startlndex,int count)

复制代码

说明：

public static void main(String[] args) {
//1.String对象用于保存字符串，也就是一组字符序列
// 2."jack"字符串常量，双引号括起的字符序列
// 3．字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
// 4.String类有很多构造器，构造器的重载
//常用的有String s1 = new String();//
//String s2 = new String(string original);
// String s3 = new String(char[] a);
// String s4 = new String(char[] a,int startIndex,int count)
// String s5 = new String(byte[] b)
// 5.String类实现了接口 Serializable 【String可以串行化:可以在网络传输】
//接口Comparable [String对象可以比较大小]
//6. String是final类，不能被其他的类继承
//7.String有属性 private final char value[];用于存放字符串内容
//8．一定要注意: value是一个final类型，不可以修改(需要功力):即value不能指向
// 新的地址，但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = { 'a' ,'b','c'};
char[] v2 = {'t','o','m'};
value[0] ='H';
//value = v2;//会报错因为存在 final，value中指向的各个地址不能改变，但各个地址对应的值能改变
}

复制代码

两种创建String对象的区别
方式一:直接赋值 String s = "hsp";
方式二:调用构造器 String s2 = new String("hsp");

方式一:先从常量池查看是否有"hsp"数据空间，如果有，直接指向;如果没有则重新创建,然后指向。s最终指向的是常量池的空间地址
方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp",重新创建,如果有，直接通过value指向。最终指向的是堆中的空间地址。
画出两种方式的内存分布图

测试试题
测试题1

String a = "abc";
String b="abc";
System.out.println(a.equals(b))://T
System.out.println(a==b);//T a和b指向同一个地址

复制代码

测试题2

String a = "hsp";
String b = new String("hsp");
System.out.println(a.equals(b));//T
System.out.println(a == b);//F
System.out.println(a == b.intern());//T
System.out.println(b == b.intern());//F
/*
知识点:
当调用intern方法时，如果池已经包含一个等于此 String对象的字符串(用equals(Object)方法确定)，则返回池中的字符串。否则,将此 String 对象添加到池中，并返回此 String对象的引用
解读;(1) b.intern()方法最终返回的是常量池的地址(对象).
*/

复制代码

测试题3

String s1 = "hspedu";
String s2 = "java";
String s4 = "java";
String s3 = new String("java");
System.out.println(s2 == s3);//f
System.out.println(s2 == s4);//t
System.out.println(s2.equals(s3));//t
System.out.println(s1 == s2);//f

复制代码

测试4

public class Test {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "hspedu";
Person p2 = new Person();
p2.name = "hspedu";
System.out.println(p1.name.equals(p2.name));//t
System.out.println(p1.name == p2.name);//t
System.out.println(p1.name == "hspedu");//t
String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1 == s2);//f
//可以画出内存布局图分析
}
}
class Person{
String name;
}

复制代码

字符串的特性
说明

String是一个final类，代表不可变的字符序列
字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的.（指的是常量池中创建好的字符串数据不能手动改变）

以下语句创建了几个对象?画出内存布局图。

String s1 = "hello";
s1="haha";//s1指向的地址发生了改变

复制代码

面试题
题1
String a= "hello" +"abc";
创建了几个对象?
//解读: String a = "hello" +"abc"; //==>优化等价 String a = "helloabc"; 所以只创建了一个对象
题2
String a = "hello";
String b ="abc";
String c=a+b;创建了几个对象?画出内存图?
//关键就是要分析String c =a + b;到底是如何执行的
//一共有3对象。

public static void main(String[] args) {
String a = "hello" ;//创建a对象
String b = "abc";
// 创建b对象
// 解读
// 1。先创建一个StringBuilder sb = StringBuilder()//StringBuilder具体会在后面讲
// 2。执行sb.append("hello");
// 3. sb.append("abc");
// 4.String c= sb.toString()
// 最后其实是c指向堆中的对象(String) value[] ->池中"helloabc"
String c = a + b;
String d="helloabc";
System.out.println(c ==d);//真还是假? F
}

复制代码

小结:底层是StringBuilder sb = new StringBuilder(); sb.append(a); sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的.
重要规则，Stringc1 = "ab" + "cd";常量相加，看的是池。String c1 = a+b;变量相加，是在堆中
题3
下列程序运行的纹果是什么,尝试画出内存布局图?

class Test1 {
String str = new String("hsp");
final char[] ch = {'j', 'a', 'v', 'a'};
public void change(String str, char ch[]) {
str = "java";
ch[0] = 'h';
}
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.println(ex.ch);
}
}//思考，认真看，仔细想 hsp and hava

复制代码

内存分析：

String类的常见方法
●说明
String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低,因此java设计者还提供了StringBuilder和 StringBuffer 来增强String的功能,并提高效率。[后面我们还会详细介绍StringBuilder和StringBuffer]

String s = new String("");
for( int i = 0; i<80000; i++){
s +="hello";
}

复制代码

toCharArray //转换成字符数组

String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//f

复制代码

compareTo //比较两个字符串的大小

String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equalsIgnoreCase(str2));//t

复制代码

format //格式化字符串,%s字符串%c字符%d整型%.2f 浮点型

String str1 = "hello";
System.out.println(str1.length());//5

复制代码

案例,将一个人的信息格式化输出.
StringBuffer类

基本介绍
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是可变长度的。
StringBuffer是一个容器。

String str1 = "hello";
System.out.println(str1.indexOf("lo"));//3

复制代码

String Vs StringBuffer

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址(当空间不够时创建新的空间，并将之前的字符串拷贝进去)，效率较高//char[] value;//这个放在堆.

StringBuffer的构造器
StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符。
StringBuffer(int capacity) //capacity [容量]
构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对 char[]大小进行指定
StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

String str1 = "hello";
System.out.println(str1.lastIndexOf("l"));

复制代码

String和StringBuffer相互转换
在开发中，我们经常需要将String 和StringBuffer进行转换,看看如何实现,看演示.

String str1 = "hello";
System.out.println(str1.substring(2));//从索引2开始截取所有内容 [2,-1] llo
System.out.println(str1.substring(2,4));//从索引2开始到索引4-1的内容 [2,4) ll

复制代码

StringBuffer类常见方法
[code]StringBuffer s = new StringBuffer("hello");//增s.append( ',');// "hello, "s.append("张三丰");//"hello,张三丰"s.append("赵敏").append(100) .append(true).append(10.5);//"hello,张三丰赵敏100true10.5System.out.println(s);//"hello,张三丰赵敏100true10.5"//删/*删除索引为>=start && 结论:如果我们对String做大量修改,不要使用String</ol>效率:StringBuilder > StringBuffer > String
String、StringBuffer 和StringBuilder的选择
使用的原则,结论:

如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情况,使用 StringBuilder
如果字符串存在大量的修改操作,并在多线程的情况,使用 StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等StringBuilder 的方法使用和StringBuffer一样,不再说.

Math类

Math类常见方法应用案例
[code]//看看Math常用的方法(静态方法)//1.abs 绝对值int abs = Math.abs(-9);System.out.println(abs);//9// 2.pow求幂double pow = Math.pow(2, 4);//2的4次方System.out.println(pow); //16//3.ceil向上取整,返回>=该参数的最小整数(返回double类型);double ceil = Math.ceil(-3.0001);System.out.println(ceil);//-3.0//4.floor向下取整，返回

		自动登录	找回密码
密码			立即注册

Java学习-第一部分-第二阶段-第四节：常用类

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块