第十一章常用类库(Object String Date Calender Arrays StringBuilder System Arrays Math)

最新推荐文章于 2024-07-22 14:15:06 发布

Esther-m

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量180

点赞数

分类专栏： java基础学习文章标签： java maven intellij-idea javaee

本文链接：https://blog.csdn.net/LLLlucky_boy/article/details/118961327

版权

java基础学习专栏收录该内容

17 篇文章 4 订阅

订阅专栏

java基础11

第十一章常用类库(Object String Date Calender Arrays StringBuilder System Arrays Math)
总结

第十一章常用类库(Object String Date Calender Arrays StringBuilder System Arrays Math)

11.1 API

11.1.1 概述

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

11.1.2 API使用步骤

打开帮助文档。
点击显示，找到索引，看到输入框。
你要找谁？在输入框里输入，然后回车。
看包。java.lang下的类不需要导包，其他需要。
看类的解释和说明。
学习构造方法。
使用成员方法。

11.1.3 API使用练习

了解了API的使用方式，我们通过Scanner类和Random类，熟悉一下查询API，并使用类的步骤。

练习1：获取键盘录入的字符串

查看类
- java.util.Scanner ：该类需要import导入后使用。
查看构造方法
- public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描
  的。
查看成员方法
- public int nextInt() ：获取下一个int数字。
- public String nextLine() ：获取下一行完整字符串。

使用Scanner类，完成接收键盘录入数据的操作，代码如下：

//1. 导包 
	import java.util.Scanner; 
public class Demo01_Scanner { 
	public static void main(String[] args) { 
	//2. 创建键盘录入数据的对象 
	Scanner sc = new Scanner(System.in); 
	//3. 接收数据 
	System.out.println("请录入一个字符串："); 
	String line = sc.nextLine(); //4. 输出数据 
	System.out.println("您输入的字符串:"+line); } }

练习2：获取一个1-33之间（包含1和33）的随机数。
查看类
- java.util.Random ：该类需要 import导入使后使用。
查看构造方法
- public Random() ：创建一个新的随机数生成器。
查看成员方法
- public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和指定值 n （不包括）之间的int 值。


import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random random = new Random();
        int i = random.nextInt(33)+1;
        System.out.println(i);
    }
}

备注：创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数

11.2 String类

11.2.1 String类概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实例。
类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

11.2.2 构造方法

查看类
- java.lang.String ：此类不需要导入。
查看构造方法
- public String() ：初始化新创建的 String对象，以使其表示空字符序列。
- public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
- publicString(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
- 直接赋值的方式创建字符串对象
  构造举例，代码如下：

public class StringDemo {
    public static void main(String[] args) {
        //空字符串
        String s1 = new String();
        System.out.println(s1);
        //方式1
        char[] chars = {'a','b','c'};
        String s2 = new String(chars);
        System.out.println(s2);
        //方式2
        byte[] bytes = {97,98,99};
        String s3 = new String(bytes);
        System.out.println(s3);
        //方式3
        String s4 = "abc";
        System.out.println(s4);

    }
}

11.2.3 常用方法

判断功能的方法

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

方法演示，代码如下：

/*
	判断功能的方法举例 
	s1.equals(s2):比较s1和s2的内容是否一模一样,如果一样返回true,否则返回false 
	s1.equalsIgnoreCase(s2):比较s1和s2的内容是否相同,但是不区分大小写 
	s1.contains(s2): 判断s1中是否包含s2,包含则返回true,不包含则返回false */ 
public class String_Demo01 { 
	public static void main(String[] args) { 
	// 创建字符串对象 
	String s1 = "hello"; 
	String s2 = "hello"; 
	String s3 = "HELLO"; 
	// boolean equals(Object obj):比较字符串的内容是否相同 
	System.out.println(s1.equals(s2)); // true 
	System.out.println(s1.equals(s3)); // false 
	System.out.println("-----------"); 
	//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写 
	System.out.println(s1.equalsIgnoreCase(s2)); // true 
	System.out.println(s1.equalsIgnoreCase(s3)); // true 
	System.out.println("-----------"); 
	} 
}

Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

字符串的比较：==号和equals的作用

==比较基本数据类型：比较的是具体的值
==比较引用数据类型：比较的是对象地址值
equals比较String类型: 比较的是对象的内容是否相同

public class StringDemo02 { 
	public static void main(String[] args) { 
	//构造方法的方式得到对象 
	char[] chs = {'a', 'b', 'c'};
	String s1 = new String(chs); 
	String s2 = new String(chs); 
	//直接赋值的方式得到对象 
	String s3 = "abc"; 
	String s4 = "abc"; 
	//比较字符串对象地址是否相同 
	System.out.println(s1 == s2); 
	System.out.println(s1 == s3); 
	System.out.println(s3 == s4); 
	System.out.println("--------"); 
	//比较字符串内容是否相同 
	System.out.println(s1.equals(s2)); 
	System.out.println(s1.equals(s3)); 
	System.out.println(s3.equals(s4)); 
	} 
}

获取功能的方法

public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。


public class String_Demo02 { 
	public static void main(String[] args) { 
	//创建字符串对象 
	String s = "helloworld"; 
	// int length():获取字符串的长度，其实也就是字符个数 
	System.out.println(s.length()); 
	System.out.println("--------"); 
	// String concat (String str):将将指定的字符串连接到该字符串的末尾. 
	String s = "helloworld"; 
	String s2 = s.concat("**hello java"); 
	System.out.println(s2);// helloworld**hello java 
	// char charAt(int index):获取指定索引处的字符 
	System.out.println(s.charAt(0)); 
	System.out.println(s.charAt(1)); 
	System.out.println("--------"); 
	// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1 
	System.out.println(s.indexOf("l")); 
	System.out.println(s.indexOf("owo")); 
	System.out.println(s.indexOf("ak")); 
	System.out.println("--------"); 
	// String substring(int start):从start开始截取字符串到字符串结尾 
	System.out.println(s.substring(0)); 
	System.out.println(s.substring(5)); 
	System.out.println("--------"); 
	// String substring(int start,int end):从start到end截取字符串。含start，不含end。 
	System.out.println(s.substring(0, s.length())); 
	System.out.println(s.substring(3,8));
	}
}

转换功能的方法

public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

方法演示，代码如下：

public class String_Demo03 { 
	public static void main(String[] args) { 
	//创建字符串对象 
	String s = "abcde"; 
	// char[] toCharArray():把字符串转换为字符数组 
	char[] chs = s.toCharArray(); 
	for(int x = 0; x < chs.length; x++) 
	{ System.out.println(chs[x]); }
	System.out.println("-----------"); 
	// byte[] getBytes ():把字符串转换为字节数组 
	byte[] bytes = s.getBytes(); 
	for(int x = 0; x < bytes.length; x++) 
	{ System.out.println(bytes[x]); }
	System.out.println("-----------"); 
	// 替换字母hello为大写HELLO String str = "hello world, hello java"; 
	String replace = str.replace("hello", "HELLO"); 
	System.out.println(replace); // HELLO world, HELLO java 
	System.out.println("-----------");
	}
	}

CharSequence是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

方法演示，代码如下：

public class String_Demo03 { 
	public static void main(String[] args) { 
	//创建字符串对象 
	String s = "aa,bb,cc"; 
	String[] strArray = s.split(","); // ["aa","bb","cc"] 
	for(int x = 0; x < strArray.length; x++) { 
	System.out.println(strArray[x]); // aa bb cc 
	} 
	} 
	}

11.3 Object 类

11.3.1 概述

java.lang.Object类是java语言中的根类，每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

如果一个类没有特别指定父类，那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ { // ... }

11.3.2 native本地方法

在Object类的源码中定义了 native 修饰的方法， native 修饰的方法称为本地方法。

本地方法的特点：

被native修饰的方法，非Java语言编写，是由C++语言编写。
本地方法在运行时期进入本地方法栈内存，本地方法栈是一块独立内存的区域。
本地方法的意义是和操作系统进行交互。

private static native void registerNatives(); 
static { 
registerNatives(); 
}

当程序运行的时候，Object类会最先被加载到内存中。类进入内存后首先加载自己的静态成员，static代码块中调用了本地方法 registerNatives() ，和操作系统进行交互。

native方法可以看做是对java方法的扩展,native方法不是由java去实现的,是由操作系统去实现的.java只能调用本地方法

https://www.cnblogs.com/KingIceMou/p/7239668.html

11.3.3 toString（）方法

方法声明： public String toString() ：返回该对象的字符串表示。

Object类toString()方法源码：

public String toString() { 
return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

源码分析：

getClass.getName()返回类的全限定名字。
hashCode() 方法返回int值，可以暂时理解为对象的内存地址。
Integer.toHexString() 将int类型的值转成十六进制。
因此调用对象的toString()方法将看到内存的地址值。

创建Person类，并调用方法toString()

public static void main(String[] args){ 
	Person person = new Person();
	String str = person.toString(); 
	System.out.println(str); 
	System.out.println(person); 
	}

通过程序运行，得到结论，在输出语句中打印对象，就是在调用对象的toString()方法

toString()方法的重写

由于toString方法返回的结果是内存地址，而在开发中，内存地址并没有实际的应用价值，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

public class Person { 
	private String name; 
	private int age; 
	@Override 
	public String toString() { 
	return "Person"+name+":"+age; 
	}
	// 省略构造器与Getter Setter 
	}

11.3.4 equals方法

方法声明： public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。

Object类equals()方法源码：

public boolean equals(Object obj) { 
	return (this == obj); 
	}

源码分析：

this是当前对象，哪个对象调用的equals方法就表示哪个对象。
obj表述传递的参数，参数类型Object，可以传递任意类型对象。
this==obj 比较两个对象的内存地址是否相同

equals方法默认比较两个对象的内存地址是否相同，相同则返回true。

equals方法的重写

实际应用中，比较内存地址是否相同并没有意义，我们可以定义对象自己的比较方式，比较对象中成员变量的值是否相同。需要对方法进行重写。

需求：重写equals（）方法，比较两个对象中姓名和年龄是否相同，如果姓名和年龄都相同返回true，否则返回false。

public class Person { 
	private String name; 
	private int age; 
	public boolean equals(Object obj){ 
	//判断两个对象地址弱相同，即为同一个对象 
	if(this == obj)
	return true; 
	//obj对象为空，无需比较，返回false 
	if(obj == null) 
	return false; 
	//obj如果是Person类型对象，则强制转换 
	if(obj instanceof Person){ 
	Person person = (Person)obj; 
	//比较两个对象的name属性和age属性，如果相等，返回true 
	return this.name.equals(person.name) && this.age == person.age; }
	return false; 
	} 
}

11.4 Date类

java.util.Date 类表示特定的瞬间，精确到毫秒。1000毫秒等于1秒。

11.4.1 Date类构造方法

public Date() ：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date) ：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

public static void main(String[] args) { 
	// 创建日期对象，把当前的时间 
	System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020 
	// 创建日期对象，把当前的毫秒值转成日期对象 
	System.out.println(new Date(0)); // Thu Jan 01 08:00:00 CST 1970 
	}

11.4.2 Date类的常用方法

public long getTime() 把日期对象转换成对应的时间毫秒值
pulic void setTime() 把方法参数给定的毫秒值设置给对象日期

public static void main(String []args)
{
	//创建日期对象
	Date date = new Date(); 
	//public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值 
	System.out.println(date.getTime()); 
	//public void setTime(long time):设置时间，给的是毫秒值 date.setTime(0); 
	System.out.println(date); 
}

11.4.3 日期对象和毫秒值的相互转换

日期是不能进行数学计算的，但是毫秒值可以，在需要对日期进行计算时，可以现将日期转成毫秒值后在进行计算。

日期对象转成毫秒值：
- Date date = new Date(); date.getTime()
- System.currentTimeMillis()
毫秒值转成日期对象：
- Date date = new Date(long 毫秒值)
- date.setTime(long 毫秒值)

11.5 DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化：按照指定的格式，把Date对象转换为String对象。
解析：按照指定的格式，把String对象转换为Date对象。

11.5.1 构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat 。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

public SimpleDateFormat(String pattern) ：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档

11.5.2 转换方法

String format(Date date)传递日期对象，返回格式化后的字符串。
Date parse(String str)传递字符串，返回日期对象。

public static void main(String[] args) throws ParseException { 
	//格式化：从 Date 到 String 
	Date d = new Date(); 
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); 
	String s = sdf.format(d); 
	System.out.println(s); 
	System.out.println("--------"); 
	//从 String 到 Date 
	String ss = "2048-08-09 11:11:11"; 
	//ParseException 
	SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
	Date dd = sdf2.parse(ss); 
	System.out.println(dd); 
	}

11.6 Calendar日历类

11.6.1 概念

日历我们都见过
在这里插入图片描述
java.util.Calendar 是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

11.6.2 日历对象获取方式

Calendar是抽象类，不能创建对象，需要使用子类对象。java.util.GregorianCalendar 类是Calendar的子类，但是创建日历对象需要根据本地的时区，语言环境来创建，比较困难，Calendar类提供了静态方法 getInstance()直接获取子类的对象。

public static Calendar getInstance() ：使用默认时区和语言环境获得一个日历。

Calendar cal = Calendar.getInstance();

11.6.3 常用方法

public int get(int field) ：返回给定日历字段的值。
public void set(int field, int value) ：将给定的日历字段设置为给定值。
public abstract void add(int field, int amount) ：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime() ：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

11.6.4 日历字段

Calendar类中提供很多静态成员，直接类名调用，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周一为1，可以使用-1）

代码使用简单演示：

public static void main(String[] args) { 
	// 创建Calendar对象 
	Calendar cal = Calendar.getInstance(); 
	// 获取年 
	int year = cal.get(Calendar.YEAR); 
	//设置年份为2020年 
	cal.set(Calendar.YEAR, 2020); 
	//将年份修改为2000年 
	cal.add(Calendar.YEAR,-20) 
	//将日历对象转换为日期对象
	Date d = cal.getTime();
	System.out.println(d);
	}

11.7 基本类型包装类

11.7.1 概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

11.7.2 Integer 类

Integer类概述
包装一个对象中的原始类型int的值
Integer 类构造方法及静态方法

方法名	说明
public Integer(int value)	根据int值创建Integer对象（过时）
public Integer(String s)	根据String值创建Integer对象（过时）
public static Integer valueOf(int i)	返回表示指定的int值的integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer 对象String


public static void main(String[] args) { 
//public Integer(int value)：根据 int 值创建 Integer 对象(过时) 
	Integer i1 = new Integer(100); 
	System.out.println(i1); 
	//public Integer(String s)：根据 String 值创建 Integer 对象(过时) 
	Integer i2 = new Integer("100"); 
	//Integer i2 = new Integer("abc"); //NumberFormatException 
	System.out.println(i2); 
	System.out.println("--------"); 
	//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例 
	Integer i3 = Integer.valueOf(100); 
	System.out.println(i3); 
	//public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 
	String Integer i4 = Integer.valueOf("100"); 
	System.out.println(i4); 
	}

11.7.3 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数 
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

11.7.4 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4); 
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; 
//加法运算完成后，再次装箱，把基本数值转成对象。

11.7.5 基本类型与字符串之间的转换

基本类型转换为String

转换方式
- 方式一：直接在数字后加一个空字符串
- 方式二：通过String类静态方法valueOf()
示例代码

public static void main(String[] args) { 
	//int --- String 
	int number = 100; 
	//方式1 
	String s1 = number + ""; 
	System.out.println(s1); 
	//方式2 
	//public static String valueOf(int i) 
	String s2 = String.valueOf(number); 
	System.out.println(s2); 
	System.out.println("--------"); 
	}

String转换成基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s) ：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s) ：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s) ：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s) ：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s) ：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s) ：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s) ：将字符串参数转换为对应的boolean基本类型。

11.8 StringBuilder类

11.8.1 字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo { 
	public static void main(String[] args) { 
	String s = "Hello"; 
	s += "World"; 
	System.out.println(s); 
	} 
	}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即 “Hello” 、 “World” 和 “HelloWorld” 。引用变量s首先指向 Hello 对象，最终指向拼接出来的新字符串对象，即 HelloWorld。
在这里插入图片描述
由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用 java.lang.StringBuilder 类。

11.8.2 StringBuilder概述

查阅 java.lang.StringBuilder 的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
在这里插入图片描述

11.8.3 构造方法

根据StringBuilder的API文档，常用构造方法有2个：

public StringBuilder() ：构造一个空的StringBuilder容器。
public StringBuilder(String str) ：构造一个StringBuilder容器，并将字符串添加进去

public class StringBuilderDemo01 { 
	public static void main(String[] args) { 
	//public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容 
	StringBuilder sb = new StringBuilder(); 
	System.out.println("sb:" + sb); 
	System.out.println("sb.length():" + sb.length()); 
	//public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象 
	StringBuilder sb2 = new StringBuilder("hello"); 
	System.out.println("sb2:" + sb2); 
	System.out.println("sb2.length():" + sb2.length()); 
	} 
	}

11.8.4 常用方法

StringBuilder常用的方法有3个：

public StringBuilder append(…) ：添加任意类型数据的字符串形式，并返回当前对象自身。
public StringBuilder reverse() ：返回反转的字符序列
public String toString() ：将当前StringBuilder对象转换为String对象。

代码简单演示：

public class StringBuilderDemo01 { 
	public static void main(String[] args) { 
	//创建对象 
	StringBuilder sb = new StringBuilder(); 
	//public StringBuilder append(任意类型)：添加数据，并返回对象本身 
	// StringBuilder sb2 = sb.append("hello"); 
	// System.out.println("sb:" + sb);
	//System.out.println("sb2:" + sb2); 
	// System.out.println(sb == sb2); 
	// sb.append("hello"); 
	// sb.append("world"); 
	// sb.append("java"); 
	// sb.append(100); 
	//链式编程 
	sb.append("hello").append("world").append("java").append(100); 
	System.out.println("sb:" + sb); 
	//public StringBuilder reverse()：返回相反的字符序列 sb.reverse(); 
	System.out.println("sb:" + sb); 
	String str = sb.toString(); 
	System.out.println("str: "+str); 
	} 
	}

备注：StringBuilder已经覆盖重写了Object当中的toString方法

11.8.5 StringBuild和String的相互转换

StringBuilder转换为String

  public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String

String转换为StringBuilder

  public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为StringBuilder

实例代码：

public class StringBuilderDemo02  { 
	public static void main(String[] args) { 
	/*
	//StringBuilder 转换为 String 
	StringBuilder sb = new StringBuilder(); 
	sb.append("hello"); 
	//String s = sb; //这个是错误的做法 
	//public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String 
	String s = sb.toString(); 
	System.out.println(s); */
	//String 转换为 StringBuilder
	String s = "hello"; 
	//StringBuilder sb = s; //这个是错误的做法 
	//public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 
	StringBuilder StringBuilder sb = new StringBuilder(s); 
	System.out.println(sb); 
	} 
}

11.9 System类

11.9.1 概述

java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。System类私有修饰构造方法，不能创建对象，直接类名调用。

常用方法

方法名	说明
public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)
public static void arrayCopy(Object src, int srcPos, Object dest,int destPos, int length)	从指定源数组中复制一个数组
public static void gc()	运行垃圾回收器。

11.9.2 练习

在控制台输出1-10000，计算这段代码执行了多少毫秒

public static void main(String[] args) { 
	//获取当前时间毫秒值 
	System.out.println(System.currentTimeMillis()); 
	//计算程序运行时间 
	long start = System.currentTimeMillis(); 
	for (int i = 1; i <= 10000; i++) 
	{ 
	System.out.println(i); } 
	long end = System.currentTimeMillis(); 
	System.out.println("共耗时毫秒：" + (end - start)); 
	}

11.9.3 arrayCopy方法：

Object src：要复制的数据源数组
int srcPost：数据源数组的开始索引
Object dest：复制后的目的数组
int destPos：目的数组开始索引
int length：要复制的数组元素的个数

11.9.4 练习：数组元素复制

将源数组中从1索引开始，复制3个元素到目的数组中

public static void main(String[] args){ 
	int[] src = {1,2,3,4,5}; 
	int[] dest = {6,7,8,9,0}; 
	//将源数组中从1索引开始，复制3个元素到目的数组中 
	System.arraycopy(src,1,dest,0,3); 
	for(int i = 0 ; i < dest.length;i++){ 
	System.out.println(dest[i]); 
	}

11.9.5 gc()方法

运行垃圾回收器，JVM将从堆内存中清理对象，清理对象的同时会调用对象的finalize()方法，JVM的垃圾回收器是通过另一个线程开启的，因此程序中的效果并不明显。

public class  Person { 
	protected void finalize() throws Throwable { 
	System.out.println("对象被回收");
	}
public static void main(String[] args){ 
	new Person(); 
	new Person(); 
	new Person(); 
	new Person(); 
	new Person(); 
	new Person(); 
	System.gc(); 
	}

11.10 Arrays类

11.10.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。Arrays类私有修饰构造方法，其所有方法均为静态方法，调用起来非常简单。

11.10.2 常用方法

方法名	说明
public static void sort(int[] a)	对指定的int数组进行升序排列
public static int binarySearch(int[] a,int key)	对数组进行二分查找法，找不到元素返回(-插入点)-1
public static String toString(int[] a)	将数组转成字符串

public static void main(String[] args){ 
	int[] arr = {5,1,9,2,33,18,29,51}; 
	//数组升序排列 
	Arrays.sort(arr); 
	//数组转成字符串 
	String arrStr = Arrays.toString(arr); 
	System.out.println(arrStr); 
	//数组二分查找 
	int index = Arrays.binarySearch(arr,9); 
	System.out.println(index);
}

11.11 Math类

11.11.1 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

11.11.2 常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int

public static void main(String[] args){ 
	//public static int abs(int a) 返回参数的绝对值 
	System.out.println( Math.abs(5)); //结果为5 
	System.out.println( Math.abs(-5)); //结果为5 
	//public static double ceil(double a) 返回大于或等于参数的最小double值，等于一个整数 
	System.out.println( Math.ceil(5.4)); //结果为6 
	//public static double floor(double a) 返回小于或等于参数的最大double值，等于一个整数 
	System.out.println( Math.floor(5.5)); //结果为5 
	//public static int round(float a) 按照四舍五入返回最接近参数的int 
	System.out.println( Math.round(5.5));//结果为6 
	System.out.println( Math.round(5.4));//结果为5 
	}

总结

常用类讲解完毕~

Esther-m

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十一章常用类库(Object String Date Calender Arrays StringBuilder System Arrays Math)

文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考一、pandas是什么？示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。二、使用步骤1.引入库代码如下（示例）：import numpy as npimport p
复制链接

扫一扫