Java基础类库：
一、Math
是一个帮我们用于进行数学计算的工具类；私有化构造方法，所有的方法都是静态的，
调用的时候不用创建实例
1.常用方法
a. abs() 获取参数绝对值 f. max() 获得两个int中的较大值
b. ceil() 向上取整 g. pow() 返回a的b次幂
c. floor() 向下取整 h. random() 返回值为double 的随机值 [0.0,1.0）
e. round() 四舍五入 i. sqrt() 返回a的平方根 cbrt()返回a的立方根
package com.itheimademo1;
public class MathDemo1 {
public static void main(String[] args) {
for(int i = 0;i <10;i++){
System.out.println(Math.floor(Math.random()*100)+1);
//Math.random() [0.0 10.)
// *100 [0.0 100.0)
//floor 去调了后面的小数点
//+1 [1 100.0)
}
}
}
二、system类
也是一个工具类，提供了一些与系统相关的方法
a. exit() 终止当前运行的java程序
当需要结束整个程序时，就可以调用这个方法 System.exit()
b. currentTimeMillis（） 返回当前系统的时间的毫秒形式
返回long类型的值
c. arraycopy(数据源数组、起始索引、目的地数组、起始索引、拷贝个数) 数组的拷贝
package com.itheimademo1.MathDemo2;
public class SystemDeom1 {
public static void main(String[] args) {
int[] arr1 ={1,2,3,4};
int[] arr2 = new int[10];
System.arraycopy(arr1,0,arr2,0,4);
for (int i = 0; i < arr2.length; i++) {
System.out.print(arr2[i]+" ");
}
}
}
注意：a.如果数据源数组和目的地数组都是基本数据类型，那么两者的类型必须保持一致，否则报错 b.在拷贝的时候需要考虑数组的长度，超出否则报错 c.如果数据源数组和目的地数组都是引用数据类型，那么子类类型可以赋值给父类类型
三、Runtime类
Runtime表示当前虚拟机的运行对象 它的方法不是静态的 需要创建对象
package com.itheimademo1.MathDemo2;
public class RuntimeDemo1 {
public static void main(String[] args) {
//1/获取runtime对象
//只能有一个对象，表示当前虚拟机的运行环境，创建多个对象没有意义
Runtime r1 =Runtime.getRuntime();
//2.停止虚拟机
// r1.exit(0);
System.out.println("这行代码没有被执行");
//3.获得CPU的线程数
System.out.println(r1.availableProcessors());
//4.获得总内存大小 单位时byte
System.out.println(r1.maxMemory()/1024/1024);
//5.已经获取的总内存大小
System.out.println(r1.totalMemory()/1024/1024);
//6.剩余内存的大小
System.out.println(r1.freeMemory()/1024/1024);
}
}
四,Object类
1，Object 的构造方法：只有无参构造
2，Object中的成员方法
a.toString 方法返回对象的字符串表示形式
默认情况下，Object类中的toString方法返回的是地址值 如果要看到对象内部的属性，应该重写父类的toString方法
b.equals() 比较两个对象是否相等
如果没有重写equals方法，那么默认使用Object中的方法（Object中默认是使用==号比较两个对象的地址值）进行比较，比较的是地址值是否相等
如果重写以后，则比较的是对象内部的属性值了
c. clone（） 对象克隆
方法在底层会帮我们创建一个对象 并把原对象中的数据拷贝过去
首先，重写Object中的clone方法；让类实现Cloneable接口，创建原对象并且调用clone
clone()方法是浅克隆
a.浅克隆
不管对象内部的属性是基本数据类型还是引用型数据类型，都完全拷贝过来
会随着原对象的改变而改变
b.深克隆
基本数据类型拷贝过来 字符串复用 引用型数据类型会重新创建新的
不会随着原对象的改变而改变
d.getclass()方法
是final方法，不能被重载 它返回一个对象在运行时所对应的类的表示
e.finalize方法
用于垃圾收集前清除对象
五、Objects工具类
是一个对象工具类
equals(对象1，对象2）；先做非空判断，比较两个对象
isNull(对象) ; 判断对象是否为空
nonNull(对象) ; 判断对象是否不是为空
六、String类
String 对象用于保存字符串，也就是一组字符序列 字符串常量对象是用双引号括起的字符序列。
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
String类较常用构造器:String s1 = new String();// String s2 = new String(String original);
1.String实现的接口
实现了Serializable 接口 说明可以串行化，可以在网络传输；实现Comparable接口，说明String对象可以相互比较
2.String是final类
不能被其它类继承；它的底层是属性value[]用于存放字符串的内容；！！value不能修改，创建之后不能指向新的地址，但是单个字符可以变化(可以修改字符数组的某个元素）
3.创建String对象的两种方式：
a.直接赋值 String s = "sss";
b.调用构造器 String s = new String ("qqq")
方式一:先从常量池查看是否有"sss"数据空间，如果有，直接指向;如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址;( s.intern() 返回常量池的地址） 方式二:先在堆中创建空间，里面维护了value属性， value指向常量池的hsp空间 如果常量池没有"qqq"重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。
eg：
4.字符串的特性
a.String 是一个final类，代表不可变的字符序列
b.字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的
public class Test1 {
public static void main(String[] args) {
String a = "123";
a = "233";
//因为String被创建后不可以改变，所以a=”233“ 说明 a 被指向了新的空间”233“的空间
System.out.println(a);
}
}
public class StringTest {
public static void main(String[] args) {
String a = "hello";//创建 a对象
String b = "abc";//创建 b对象
//1.先 创建一个 stringBuilder sb = stringBuilder()
//2.执行 sb.append("hello");
//3. sb.append("abc");
//4.string c= sb.tostring()
//最后其实是 c指向堆中的x橡(string)value[]-> 池中"helloabc"
String c = a + b;
String d = "helloabc";
System.out.println(c == d);//F
String e = "hello"+"abc";
System.out.println(d == e);//T
}
}
String c1 = "sa" +"han" 两个常量相加，看的是池
String c2 = a+b 两个变量相加，实在堆中
eg1:
6.常见的方法
equals // 区分大小写，判断内容是否相等 equalslgnoreCase //忽略大小写的判断内容是否相等 length // 获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastlndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串 trim //去前后空格 charAt:获取某索引处的字符,注意不能使用Str[index]这种方式,
toUpperCase 将字符串全部转换为大写
toLowerCase 将字符串全部钻换为小写
concat
replace 替换字符串中的字符 split 分割字符串
compareTo //比比较两个字符串的大小 toCharArray //转换成字符数组 format //格式字符串,%s 字符串 %c 字符 %d 整型 %.2f 浮点型案例，将一个人的信息格式化输出
public class Test1 {
public static void main(String[] args) {
String s = "QQQ";
System.out.println(s.toLowerCase());
//连接
String b1 = "aaa";
String s1 = "aas";
s1 = s1.concat("eee").concat("www").concat("123");
System.out.println(s1);
//替换
s1 = "A and E and E E";
s1 = s1.replace("E","B");
//在s1中，将所有的”E“ 替换成"B"
System.out.println(s1);
//s1 执行后 返回的结果才是替换过的 如果s1.replace("E","B");不返回，对s1没有任何影响
//分割
String poem = "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦。";
String[] split = poem.split(",");
for(int i =0;i<split.length;i++){
System.out.println(split[i]);
}
String file = "E:\\aaa\\bbbb";
String[] split1 = file.split("\\\\");// 转义符 / 转义符 /
for(int i =0;i<split1.length;i++){
System.out.println(split1[i]);
}//E: aaa bbbb
//在对字符串分割时，如果有特殊字符，需要加入转义字符
//将字符串转换为字符数组
String s4 = "happy";
char[] chs = s4.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
//比较字符串的大小
//如果前者比后者大 返回正数
String a = "jchn";
String b = "jack";
System.out.println(a.compareTo(b));// 依次比较 返回值是'c'-'a'=2的值
String a2 = "jackeen";//len = 7
String b2 = "jack";//len =4
System.out.println(a2.compareTo(b2));//返回值是两个字符串长度之差 3
//如果长度一样，并且每个字符串内容也一样，则返回0
//格式化字符串
//String 里面提供了一个静态方法 format
String name = "q0";
int age = 19;
double score =100;
String info = String.format("我的姓名是%s,年龄是%d,成绩是%.2f",name,age,score);
System.out.println(info);
}
}
字符串的分割：
七、SringBuffer类
是可变的字符序列，可以对字符串的内容进行增删 很多方法与String 相同，但是StringBuffer是一个可变的
1.stringBuffer 的直接父类是AbstractstringBuilder
2.StringBuffer 实现了 Serializable，即StringBuffer的对象可以串行化
3.在父类中 AbstractstringBuilder 有属性 char[] value,不是final 该value 数组存放符串内容，存放在堆中的 字符内容是存在 char[] value,中的，在变化时，不用每次都创建新的对象，效率高于String
4.StringBuffer 是一个 final类，不能被继承
a.SringBuffer的构造器
b.StringBuffer类的方法
1)增 append 2） 删 delete(start,end) 3)改 replace(start,end,string)//将start----end 间的内容替换掉,不含end 4)查 indexOf //查找子串在字符串第1次出现的索引,如果找不到返回-1 5)插insert 6)获取长度 length
八、StringBuilder类
不是线程安全的 单线程建议采用
1)一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快
2)在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法以接受任意类型的数据。
实现了 Serializable，即StringBuilder的对象可以串行化；是final类，不能被继承
StringBuilder 对象序列任然是放在其父类当中AbstractstringBuilder，因此，字符序列是在堆中
三者比较：
九、日期类
1.Calendar 类
2. Date 类
3.SimpleDateFormat 格式化
import java.util.Calendar;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Locale;
import static java.util.Calendar.*;
// 定义一个名为CalendarDate的类
class CalendarDate {
public static void main(String[] args) throws java.text.ParseException {
// 获取一个Calendar实例，它会根据当前系统时间和默认时区进行初始化
Calendar calendar = Calendar.getInstance();
// 使用roll方法对月份进行滚动操作，这里将月份滚动1个月
// roll方法与add方法不同，它不会影响更大的时间字段（比如年份），只会在当前月份范围内滚动
calendar.roll(MONTH, 1);
// 获取滚动后的月份（注意：在Calendar中，月份是从0开始计数的，所以这里需要加1才是实际的月份）
// 并输出格式为 "X月Y日" 的日期信息，其中X是月份，Y是日期
System.out.println((calendar.get(MONTH) ) + "月" + calendar.get(DAY_OF_MONTH) + "日");
// 创建一个Date对象，它会表示当前的日期和时间
Date date = new Date();
// 创建一个SimpleDateFormat对象，用于将日期格式化为指定的字符串格式
// 这里指定的格式是 "yyyy-MM-dd HH:mm:ss"，并且使用了中国的本地化设置，以确保日期格式符合中文习惯
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA);
// 使用formatter将date对象格式化为指定格式的字符串，并输出
System.out.println(formatter.format(date));
// 使用SimpleDateFormat的parse方法将指定的字符串日期 "2013-4-23" 解析为一个Date对象
date = new SimpleDateFormat("yyyy-MM-dd").parse("2005-5-28");
// 将解析得到的Date对象设置到Calendar实例中，以便后续对该日期进行各种操作
calendar.setTime(date);
// 获取并输出该日期对应的星期几的完整中文名称
// 使用getDisplayName方法，指定获取星期几的字段（DAY_OF_WEEK），以长格式（LONG）输出，并使用中国本地化设置
System.out.println(calendar.getDisplayName(DAY_OF_WEEK, LONG, Locale.CHINA));
}
}4.Java8中的time api
DateTimeFormat 格式日期类
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
