javaday09
目录
Day09---API1
1 Object1
1.1 概念. 1
1.2 常用方法. 1
1.2.1 toString()1
1.2.2 equals(Object obj)1
1.2.3 hashCode()1
1.3 测试. 1
2 String1
2.1 特点. 1
2.1.1 是一个封装char[]数组的对象. 1
2.1.2 字符串不可变. 1
2.2 创建String对象. 1
2.3 常见方法. 1
2.4 测试. 1
3 StringBuilder/StringBuffer1
3.1 特点. 1
3.2 常见方法. 1
3.3 练习：测试字符串连接效率. 1
4 包装类. 1
4.1 与基本类型的对应关系. 1
4.2 Number1
4.2.1 子类：. 1
4.2.2 常用的方法：. 1
4.3 Integer1
4.3.1 创建对象. 1
4.3.2 常见方法. 1
4.4 Double1
4.4.1 创建对象. 1
4.4.2 方法. 1
5 日期类Date1
5.1 概述. 1
5.2 创建对象. 1
5.3 常用方法. 1
5.4 练习1：测试日期类的常用方法. 1
6 日期工具SimpleDateFormat1
6.1 概述. 1
6.2 创建对象. 1
6.3 常见方法. 1
6.4 练习1 ：计算存活天数. 1
7 BigDecimal/BigInteger1
7.1 概述. 1
7.2 创建对象. 1
7.3 常用方法. 1
7.4 练习1：测试常用方法. 1
8 内部类. 1
8.1 内部类. 1
8.2 匿名内部类. 1
9 拓展. 1
9.1 ==和equals的区别. 1
9.2 StringBuilder和StringBuffer的区别. 1
9.3 自动装箱和自动拆箱. 1
9.4 简单了解内部类的分类. 1
Day09---API
API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。
java.lang包，这个包会自动导入。
java.lang.Object
java.lang.String
java.lang.StringBuilder/StringBuffer
正则表达式
包装类等
1 Object
1.1 概念
所有类的顶级父类
存在于java.lang包中，这个包不需要我们手动导包
1.2 常用方法
1.2.1 toString()
默认返回 类名@地址 的格式，来展示对象的地址值，如：a00000.Student@a0834e7。
如果想看属性值我们可以重写这个方法，重写后返回的就是把属性值拼接成一个字符串。
如：Student [name=苏大强, age=20, id=10001]
1.2.2 equals(Object obj)
当前对象和参数对象比较大小，默认是比较内存地址，如果要比较对象的属性，可以重写该方法。
1.2.3 hashCode()
返回该对象的哈希码值。
1.3 测试
创建day09工程
创建cn.tedu.objectdemo包
创建Test1_Object.java
package cn.tedu.objectdemo;
//测试Object
//1、toString()：默认的Object里提供的功能是，打印对象的地址值。如果要看对象的属性值，需要发生方法重写
public class Test1_Object {
public static void main(String[] args) {
//创建Person对象测试
Person p = new Person("jack",18);
//1、查看属性的值，不想打印对象时，默认调用Object的toString()，要重写toString()
//默认：cn.tedu.objectdemo.Person@659e0bfd
//重写后：Person [name=jack, age=18]
System.out.println(p.toString());
//2、hashCode()：对象在内存中的哈希码值/编号
System.out.println(p.hashCode());//1704856573
//TODO 3、equals(Object obj) ：指示其他某个对象是否与此对象“相等”。
//默认使用了Object提供的比较方式==比较，会比较两个对象的地址值
System.out.println( p.equals( new Person() ) );//false
}
}
//创建Person类
class Person extends Object{
//构造方法
public Person() {}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
private String name;
private int age;
//set()/get()
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//重写toString()用来查看属性值，否则就是用了Object默认的打印地址值
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
2 String
2.1 特点
2.1.1 是一个封装char[]数组的对象
2.1.2 字符串不可变
2.2 创建String对象
如果是第一次使用字符串，java会在字符串常量池创建一个对象。
再次使用相同的内容时，会直接访问常量池中存在的对象。
方式1：
String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String()
初始化一个新创建的 String 对象，使其表示一个空字符序列。
方式2：String name= ”abc”;
2.3 常见方法
length()
charAt()
lastIndexOf()
substring()
equals()
startsWith()
endsWith()
split()
trim() 去除字符串两端的空格
2.4 测试
package cn.tedu.stringdemo;
import java.util.Arrays;
import java.util.Scanner;
//测试String类
public class Test2_String {
public static void main(String[] args) {
//1、创建String对象
char[] a = new char[] {'h','e','l','l','o'};
String str = new String(a);//存在堆内存中
//存在堆内存中的常量池中，如果常量池中存过，直接用-提高效率
String str2 = "hello";
//2、调用功能
//TODO 测试String类的其他方法
System.out.println(str.charAt(4));//返回指定索引处的 char 值
System.out.println(str.endsWith("lo"));//测试此字符串是否以指定的后缀结束。
//默认Object里的equals()用来比对象的地址，String已经重写了equals()，用来把字符串存着的值进行比较
System.out.println(str.equals("hello"));//true
byte[] bs = str.getBytes();//string转byte[]
System.out.println(Arrays.toString(bs));
System.out.println(str.hashCode());//哈希码值
str="abcdabe";
System.out.println(str.indexOf("a"));//a第一次出现的索引值
System.out.println(str.lastIndexOf("a"));//a最后一次出现的索引值
System.out.println(str.length());
System.out.println(str.startsWith("abc"));
System.out.println(str.toLowerCase());
System.out.println(str.toUpperCase());
System.out.println(str.substring(3));
//substring(m,n)--m是开始的索引，n是结束的索引，含头不含尾--[m,n)
System.out.println(str.substring(3,5));//da
str=" a bc ";
System.out.println(str.trim());//a bc
System.out.println(String.valueOf(1000)+1);//10001
System.out.println("==============");
//接收键盘输入的一串数字，提取出来求和
String num = new Scanner(System.in).nextLine();
//遍历得到字符串的每个元素
int count = 0;//定义变量记录整数的和
for(int i = 0 ; i < num.length() ; i++) {
char c = num.charAt(i);
//把字符变成整数，是指把'1'变成数字49，拿着数字求和
Integer sum = Integer.valueOf(c);
//把数字求和
count = count+sum;
}
System.out.println(count);
}
}
3 StringBuilder/StringBuffer
3.1 特点
1、 封装了char[]数组
2、 是可变的字符序列
3、 提供了一组可以对字符内容修改的方法
4、 常用append()来代替字符串做字符串连接
5、 内部字符数组默认初始容量是16：super(str.length() + 16);
6、 如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
3.2 常见方法
append()
3.3 练习：测试字符串连接效率
package cn.tedu.stringdemo;
//测试字符串拼接效率
public class Test3_String2 {
public static void main(String[] args) {
// method();// 用+拼接字符串
method2();// 用工具类优化拼接效率
}
// 用工具类优化拼接效率
private static void method2() {
String str = "abcdefghijklmnopqrstuvwxyz";
// 拼接指定字符串10000次
// String result = "";// 记录拼接结果
StringBuffer sb = new StringBuffer();
long start = System.currentTimeMillis();// 获取当前的毫秒值
for (int i = 0; i < 10000; i++) {
// result = result + str;// +拼接
sb.append(str);
}
long end = System.currentTimeMillis();// 获取当前的毫秒值
System.out.println(end - start);// 给程序计时，2ms
}
// 用+拼接字符串
private static void method() {
String str = "abcdefghijklmnopqrstuvwxyz";
// 拼接指定字符串10000次
String result = "";// 记录拼接结果
long start = System.currentTimeMillis();// 获取当前的毫秒值
for (int i = 0; i < 10000; i++) {
result = result + str;// +拼接
}
long end = System.currentTimeMillis();// 获取当前的毫秒值
System.out.println(end - start);// 给程序计时，2305ms
}
}
4 包装类
把基本类型进行包装，提供更加完善的功能。
4.1 与基本类型的对应关系
4.2 Number
数字包装类的抽象父类。
提供了各种获取值的方式。
4.2.1 子类：
4.2.2 常用的方法：
4.3 Integer
4.3.1 创建对象
1、new Integer(5);
2、Integer.valueOf(5);
在Integer类中，包含256个Integer缓存对象，范围是 -128到127。使用valueOf()时，如果指定范围内的值，访问缓存对象，而不新建；如果指定范围外的值，直接新建对象。
4.3.2 常见方法
static int parseInt(String s)
将字符串参数作为有符号的十进制整数进行解析。
static Integer valueOf(String s)
返回保存指定的 String 的值的 Integer 对象。
4.4 Double
4.4.1 创建对象
1、new Double(3.14)
2、Double.valueOf(3.14)//和 new 没有区别
4.4.2 方法
static double parseDouble(String s)
返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样。
static Double valueOf(double d)
返回表示指定的 double 值的 Double 实例。
5 日期类Date
5.1 概述
存在于java.util.Date包。
用来封装一个毫秒值表示一个精确的时间点。
从1970-1-1 0点开始的毫秒值。
5.2 创建对象
new Date()：封装的是系统当前时间的毫秒值
new Date(900000000000L)：封装指定的时间点
5.3 常用方法
getTime()：取内部毫秒值
setTime()：存取内部毫秒值
getMonth()：获取当前月份
getHours()：获取当前小时
compareTo(Date)：当前对象与参数对象比较。当前对象大返回正数，小返回负数，相同0。
5.4 练习1：测试日期类的常用方法
package cn.tedu.date;
import java.util.Date;
//测试Date类
public class Test5_Date {
public static void main(String[] args) {
//1、创建日期对象java.util.Date
Date d = new Date();
//2、调用常用方法
System.out.println(d.getDate());//每个月的第几天
System.out.println(d.getDay());//星期几
System.out.println(d.getHours());//现在是几点
System.out.println(d.getMinutes());//现在是哪一分钟
System.out.println(d.getMonth());//11，因为底层代码用0-11表示一年的12个月
System.out.println(d.getSeconds());//哪一秒
System.out.println(d.getTime());//返回自 1970 年 1 月 1 日 00:00:00到现在的毫秒数
System.out.println(d.getYear());//从1900 年到现在是多少年了
}
}
6 日期工具SimpleDateFormat
6.1 概述
日期格式化工具，可以把Date对象格式化成字符串，也可以日期字符串解析成Date对象。
6.2 创建对象
new SimpleDateFormat(“格式”)
格式：yyyy-MM-dd HH:mm:ss
MM/dd/yyyy..
6.3 常见方法
format(Date)：把Date格式化成字符串
parse(String)：把String解析成Date
6.4 练习1 ：计算存活天数
接收用户输入的出生日期
计算存活天数
package cn.tedu.date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
//计算存活日期
public class Test6_Date2 {
public static void main(String[] args) {
//1、接收用户输入的出生日期
String birth = new Scanner(System.in).nextLine();
//2、把字符串类型的日期 转换成 Date类型
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
try {
//java.util.Date
Date date = sdf.parse(birth);
//列出出生那天的毫秒值
long birthday = date.getTime();
//现在的毫秒值
long now = System.currentTimeMillis();
System.out.println((now-birthday)/1000/60/60/24);
} catch (ParseException e) {
System.out.println("您输入的格式不正确！");
}
}
}
7 BigDecimal/BigInteger
7.1 概述
BigDecimal：常用来解决精确的浮点数运算。
BigInteger：常用来解决超大的整数运算。
7.2 创建对象
BigDecimal.valueOf(2);
BigDecimal(double val)
将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。
7.3 常用方法
add(BigDecimal bd)： 做加法运算
subtract(BigDecimal bd) ： 做减法运算
multiply(BigDecimal bd) ： 做乘法运算
divide(BigDecimal bd) ： 做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用
setScale(保留位数，舍入方式)：同上
pow(int n)：求数据的几次幂
7.4 练习1：测试常用方法
接收用户输入的两个数字，做运算。
package cn.tedu.bigdecimal;
import java.math.BigDecimal;
import java.util.Scanner;
//浮点数运算不精确的解决方案
public class Test7_BigDecimal {
public static void main(String[] args) {
//1、接收用户输入的两个小数
double a = new Scanner(System.in).nextDouble();
double b = new Scanner(System.in).nextDouble();
//2、做运算
System.out.println(a+b);//不精确
System.out.println(a-b);//不精确
System.out.println(a*b);//不精确
System.out.println(a/b);//不精确
System.out.println("========");
//尽量不要用double参数的构造方法，推荐用String参数的
BigDecimal bda = new BigDecimal(a+"");
BigDecimal bdb = new BigDecimal(b+"");
BigDecimal bdx = null;//记录运算结果
bdx = bda.add(bdb);//add加法运算
System.out.println(bdx);
bdx = bda.subtract(bdb);//subtract减法运算
System.out.println(bdx);
bdx = bda.multiply(bdb);//multiply乘法运算
System.out.println(bdx);
//当除不尽时，divide会报异常
// bdx = bda.divide(bdb);//divide除法运算
//divide(m,n,o)-m是要运算的对象，n是要保留几位小数，o是保留方式
bdx = bda.divide(bdb,3,BigDecimal.ROUND_HALF_UP);//divide除法运算
System.out.println(bdx);
}
}
8 内部类!
8.1 内部类
在 Java 中，允许在一个类（或方法、语句块）的内部定义另一个类，称为内部类(Inner Class)，有时也称为嵌套类(Nested Class)。内部类和外层封装它的类之间存在逻辑上的所属关系，一般只用在定义它的类或语句块之内，实现一些没有通用意义的功能逻辑，在外部引用它时必须给出完整的名称。内部类主要用于设计具有互相协作关系的类集合。
通过将一个类定义在另一个类的内部，也可以有效的隐藏该类的可见性，实现极好的封装特性。但不易理解，实际开发使用不多。
8.2 匿名内部类
没有名字的类，没法new，那就在定义时就new出来一个类
类似于：new Student().show();
9 拓展
9.1 ==和equals的区别
1、 当使用==比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地
值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。
2、 当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现
众所周知，任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过==来实现的。
9.2 StringBuilder和StringBuffer的区别
1、 在线程安全上，
--StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0
--StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5
2、 在执行效率上，StringBuilder > StringBuffer > String
3、 源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。
abstract class AbstractStringBuilder implements Appendable, CharSequence {
9.3 自动装箱和自动拆箱
自动装箱：把基本类型包装成一包装类的对象
Integer a = 5;//a是引用类型，引用了包装对象的地址。
编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);
自动拆箱：从包装对象汇总，自动去除基本类型值
int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。
编译器会完成自动拆箱：int i = a.intValue();
9.4 简单了解内部类的分类
如：静态内部类和非静态内部类
