1 Day11--API1

最新推荐文章于 2022-03-22 20:23:17 发布

abu1216

最新推荐文章于 2022-03-22 20:23:17 发布

阅读量216

点赞数

本文链接：https://blog.csdn.net/abu1216/article/details/110350852

版权

API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。

java.lang包，这个包会自动导入。

java.lang.Object

java.lang.String

java.lang.StringBuilder/StringBuffer

正则表达式

包装类等

1.1 Object

1.1.1 概念

所有对象的顶级父类

存在于java.lang包中，这个包不需要我们手动导包

1.1.2 常用方法

boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。

protected void finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

int hashCode()

返回该对象的哈希码值。

String toString()

返回该对象的字符串表示。

1.1.3 toString()

默认返回类名@地址的格式，来展示对象的地址值，如：a00000.Student@a0834e7。

如果想看属性值我们可以重写这个方法，重写后返回的就是把属性值拼接成一个字符串。

如：Student [name=苏大强, age=20, id=10001]

package cn.tedu.object;

//测试Object用法

public class Test1_Object {

public static void main(String[] args) {

//创建对象测试

Person p = new Person("熊大",20,10,"森林");

System.out.println(p);//要是不重写toString()就是使用的Object提供的默认方式只能打印对象在内存的地址

System.out.println(p);//由于重写了toString()所以打印的是属性的值

}

//定义类，提供属性

class Person{

//构造：source-generate constrctor using fileds

public Person() {}

public Person(String name, int age, double salary, String addr) {

this.name = name;

this.age = age;

this.salary = salary;

this.addr = addr;

}

//属性

private String name;

private int age;

private double salary;

private String addr;

//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;

}

public double getSalary() {

return salary;

}

public void setSalary(double salary) {

this.salary = salary;

}

public String getAddr() {

return addr;

}

public void setAddr(String addr) {

this.addr = addr;

}

//toString()：source - generate toString()-ok

@Override//重写的是Object提供的toString()是为了查看属性值

public String toString() {

return "Person [name=" + name + ", age=" + age + ", salary=" + salary + ", addr=" + addr + "]";

}

1.1.4 equals(Object obj)

当前对象和参数对象比较大小，默认是比较内存地址，如果要比较对象的属性，可以重写该方法。

package javase.base;

import javase.base.extend.Tiger;

public class TestArea {

public static void main(String[] args) {

//基础类型是按值比较

int i1 = 10;

int i2 = 10;

int i3 = 12;

System.out.println(i1==i2);//true

System.out.println(i1==i3); //false

//对象为引用类型，引用类型按内存地址比较

Tiger t1 = new Tiger();

Tiger t2 = new Tiger();

Tiger t3 = t1;

System.out.println(t1);

System.out.println(t2);

System.out.println(t3);

System.out.println(t1.equals(t2));//false

System.out.println(t1 == t2);//false

System.out.println(t1.equals(t3));//true

System.out.println(t1 == t3);//true

}

1.1.5 hashCode()

返回该对象的哈希码值。

package cn.tedu.object;

//测试equals() ==

public class Test2_Object2 {

public static void main(String[] args) {

//1，==比较八大基本类型时：判断的是值

int a = 1;

int b = 1;

System.out.println(a==b);//true

//2，==比较对象时，比较的是对象的地址值

Integer x = 5;

Integer y = 10;

Integer z = x;//把x的地址赋值给了z

System.out.println(x==y);//false

System.out.println(x==z);//true

//3，equals()用来比较对象存着的值

System.out.println(x.equals(z));//true

//4，测试hashCode()哈希值

System.out.println(x.hashCode());//5

System.out.println(y.hashCode());//10

System.out.println(z.hashCode());//5

}

1.2 String

字符串对象

1.2.2 创建String对象

1、如果是第一次使用字符串，java会在字符串常量池创建一个对象。

2、再次使用相同的内容时，会直接访问常量池中存在的对象。

方式1：new String(char[])

其实字符串底层维护了一个char[]

char[] c = {'a','b','c','d'};

String s = new String(c);//堆中分配新的内存

System.out.println(s);

方式2：直接创建

常量池里直接创建对象(本质还是char[])，再次使用相同内容，会去常量池中找到已经存在的对象，不会新建。

String s2="abcd";//常量池中分配新的内存

System.out.println(s2);

System.out.println(s==s2);//地址不同

System.out.println(s.equals(s2));//内容相同

//如果使用过了就不再创建，引用存在的对象

String s3="abcd";//访问常量池中已经存在的对象

System.out.println(s3==s2);//true

1.2.3 字符串连接效率

利用String类，在做字符串拼接的过程效率极其低下。

String s1="aaa";

String s2="bbb";

String s3="ccc";

String s4=s1+s2+s3;//字符串不可变，每次加会创建新对象，这行代码要产生右侧的5个新对象，慢

package a00000;

public class TT {

public static void main(String[] args) {

String s = "abcdefghijklmnopqrstuvwxyz";

String news="";//字符串是不能被修改的，拼接时，每次会创建对象，

long start = System.currentTimeMillis();

for (int i = 0; i < 100000; i++) {

news += s;

}

long end = System.currentTimeMillis();

System.out.print(end-start);

}

1.2.4 常用方法

length()

charAt()

lastIndexOf()

substring()

equals()

startsWith()

endsWith()

split()

trim() 去除字符串两端的空格

1.2.5 测试

package cn.tedu.String;

import java.util.Arrays;

import java.util.Iterator;

//String的常用方法

public class Test4_String2 {

public static void main(String[] args) {

String s = "abcdefghijk";

System.out.println(s.charAt(3));//d,返回指定索引处的 char 值。

System.out.println(s.endsWith("jk"));//true,是否以指定后缀结束

String s1 = "abc";

System.out.println(s.equals(s1));//false,判断两个字符串的内容是否相同

System.out.println(s.length());//11,字符串的长度

String s2="1,2,3,4,5";

String[] strs = s2.split(",");//根据指定的规则切割字符串

System.out.println(Arrays.toString(strs));//查看数组元素

System.out.println(s2.startsWith("1,"));//true

//截取时含头不含尾[3,7)

System.out.println(s.substring(3,7));//defg

//把指定的参数转换成String类型

//把数字10转成字符串10

System.out.println(String.valueOf(10));

}

1.3 StringBuilder/StringBuffer

1.3.1 特点

1、封装了char[]数组

2、是可变的字符序列

3、提供了一组可以对字符内容修改的方法

4、常用append()来代替字符串做字符串连接

5、内部字符数组默认初始容量是16：initial capacity of 16 characters

6、如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;

7、 StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全

1.3.2 练习：测试字符串连接

package day010;

public class Test5_SB {

public static void main(String[] args) {

String s="abcdefghijklmnopqrstuvwxyz";

StringBuilder sb=new StringBuilder();

long start = System.currentTimeMillis();

for (int i = 0; i < 100000000; i++) {

sb.append(s);//在后面空白处，添加

}

long end = System.currentTimeMillis();

System.out.println(end-start);

}

1.4 包装类

1.4.2 Number

数字包装类的抽象父类。

子类：

常用的方法：

提供了各种获取值的方式，已经完成了强转。

1.4.3 Integer

创建对象

new Integer(5);新建对象

Integer.valueOf(5);

在Integer类中，包含256个Integer缓存对象，范围是 -128到127。

使用valueOf()时，如果指定范围内的值，访问缓存对象，而不新建；如果指定范围外的值，直接新建对象。

Integer a = new Integer(5);//创建对象

Integer b = Integer.valueOf(5);//读取缓存

Integer c = Integer.valueOf(5);//读取缓存

System.out.println(b==c);//true

System.out.println(a==b);//false

System.out.println(a.equals(b));//true

方法

parseInt();字符串转换成int

toBinaryString();把整数转换成2进制数据

toOctalString();把整数转换成8进制数据

toHexString();把整数转换成16进制数据

1.4.4 Double

创建对象

new Double(3.14)

Double.valueOf(3.14)//和 new 没有区别

方法

Double.parseDouble();

1.5 日期类Date

1.5.1 概述

存在于java.util.Date包。

用来封装一个毫秒值表示一个精确的时间点。

从1970-1-1 0点开始的毫秒值。

1.5.2 创建对象

new Date()：封装的是系统当前时间的毫秒值

new Date(900000000000L)：封装指定的时间点

1.5.3 常用方法

getTime()：取内部毫秒值

setTime()：存取内部毫秒值

getMonth()：获取当前月份

getHours()：获取当前小时

compareTo(Date)：当前对象与参数对象比较。当前对象大返回正数，小返回负数，相同0。

1.5.4 练习1：测试日期类的常用方法

package cc;

import java.util.Date;

public class bb {

public static void main(String[] args) {

Date d = new Date();

System.out.println(d);//输出当前时间

System.out.println(d.getTime());//输出1970-1-1至今的毫秒值

System.out.println(d.~~getMonth~~());//获取当前月份

System.out.println(d.~~getHours~~());//获取当前小时

}

1.6 日期工具SimpleDateFormat

1.6.1 概述

日期格式化工具，可以把Date对象格式化成字符串，也可以日期字符串解析成Date对象。

1.6.2 创建对象

new SimpleDateFormat(格式)

格式：yyyy-MM-dd HH:mm:ss

MM/dd/yyyy..

1.6.3 常见方法

format(Date)：把Date格式化成字符串

parse(String)：把String解析成Date

1.6.4 练习1 ：计算存活天数

接收用户输入的出生日期，计算存活天数

package cc;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

public class bb {

public static void main(String[] args) throws ParseException {

//生存XX天

String birth = new Scanner(System.in).nextLine();

SimpleDateFormat s =new SimpleDateFormat("yyyy-MM-dd");

Date date = s.parse(birth);

long birthday = date.getTime();

long now=System.currentTimeMillis();

System.out.println((now-birthday)/1000/60/60/24);

}

1.7 拓展

1.7.1 进制

概念

进制也就是进位计数制，是人为定义的带进位的计数方法，类似于统计“正”字。

对于任何一种进制---X进制，就表示每一位置上的数运算时都是逢X进一位。

十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推。

通常情况下，1byte=8个二进制位

所以表示一个数字用二进制来表示的话就可以这样表示：0000 0000

把这8个位进行组合，每三位组合就形成了八进制，每四位组合就形成了十六进制。

特点

二进制：0和1，逢二进一，以0b开始

八进制：0-7，逢八进一，以0开始

十进制：0-9，逢十进一

16进制：0-9，abcdef，逢16进一，以0x开始

进制的转化：

十进制转二进制：不断除以2商0为止，取余，倒着写。

把十进制11转成2进制：1011。

二进制转十进制：从低位次，每位乘以2的位次次幂再求和。

计算二进制数据：0000 1101对应的十进制

计算二进制数据：0110 1110对应的十进制

二进制转八进制：从低位次开始，每三位为一组，产生一个八进制数字，最高位不足补零。

计算二进制数据110 0111对应的八进制

八进制转二进制：把一个数字转为3个数字，不足三位的，最高位补零。

计算八进制数据：023 0653对应的二进制数据

二进制转十六进制：四个一组，转为1个数字，以0x开始

略。。。

十六进制转二进制：一个数字变成4个数字

略。。。

1.7.2 StringBuilder和StringBuffer的区别

1、在线程安全上，

--StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0

--StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5

2、在执行效率上，StringBuilder > StringBuffer > String

3、源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。

1.7.3 自动装箱和自动拆箱

自动装箱：把基本类型包装成一包装类的对象

Integer a = 5;//a是引用类型，引用了包装对象的地址。

编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5);

自动拆箱：从包装对象中，自动取出基本类型值

int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。

编译器会完成自动拆箱：int i = a.intValue();

package cn.tedu.api;
//测试object类
/*为什么要重写？
* toString()--是因为，默认打印的是地址值，但我们想打印的是属性值
* equals()--默认打印的是两个对象间的地址值，但我们想要比较的是属性值
* */
public class Test1_Object {

public static void main(String[] args) {
Student s=new Student("钟南山",45);

//       System.out.println(s.getName());//钟南山
//       System.out.println(s.getAge());//45
       //继承Object并且重写toString()
       System.out.println(s);//Student [name=钟南山, age=45]
       //cn.tedu.api.Student@15db9742
       //底层会帮你调用Object的toString()
       System.out.println(s.hashCode());//366712642 该对象的哈希码值
       //给对象分配的存储位置
       System.out.println(s.getClass());//class cn.tedu.api.Student
       //返回Object的运行时类
       Student s2=new Student("钟南山",45);
       System.out.println(s.equals(s2));//false
       //引用类型比较的是地址值
       //使用Object的equals(),默认就是拿着两个对象进行==比较
       //==比较基本类型的值时，比的是值本身，2==3
       //==比较运用类型的值时，比的是地址值，s==s2
   }

}
//创建学生类
//默认继承了Object()
class Student extends Object{

   //丰富的构造方法,方便外界new
   public Student() {}
   public Student(String name, int age) {
       super();
       this.name = name;
       this.age = age;
   }
   //给属性赋值--调用set()+构造方法
   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;
   }

   //重写Object的toString()--想看属性值，不想看地址值
   @Override
   public String toString() {
       return "Student [name=" + name + ", age=" + age + "]";
   }



   //重写Object的equals()--比较属性值
//   public boolean equals(Object obj) {
//       Student stu=(Student)obj;
//       if(this.name==stu.name && this.age==stu.age) {
//           return true;
//       }
//       return false;
//   }
   @Override
   public boolean equals(Object obj) {
       if (this == obj)
           return true;
       if (obj == null)
           return false;
       if (getClass() != obj.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;
   }
}

package cn.tedu.api;

import java.util.Arrays;
import java.util.Scanner;

//测试String类
public class Test2_String {

public static void main(String[] args) {
// 创建对象

       char[] value= {'a','b','c','d','e','f'};
       //字符串底层维护了一个char数组，会把存入数据，字符串是常量不会被修改
       String s=new String(value);
       System.out.println(s);//触发构造：String(char[] value)

       String s2="abcdefg";//简写

       //2.常用方法

       System.out.println(s2.charAt(2));//获取下标2对应的字符 c
       System.out.println(s2.concat("jack"));
       //在原有串的后面拼接指定数据abcdefgjack
       System.out.println(s2.endsWith("efg"));
       //判断是否以指定数字结尾false
       System.out.println(s2.equals("abcdef"));
       //判断是否与指定数据相等
       //获取b第一次出现的索引值
       System.out.println(s2.indexOf("b"));
       //获取最后一次出现的索引值
       System.out.println(s2.lastIndexOf("a"));
       //判断字符串是否为空
       System.out.println(s2.isEmpty());
       //获取字符串的长度
       System.out.println(s2.length());
       //把原来字符串中的a替换成b
       System.out.println(s2.replace('a', 'b'));
       //是否以abc开始
       System.out.println(s2.startsWith("abc"));
       //以下标为3向后截取所有字符串
       System.out.println(s2.substring(3));
       //截取字符串[3,6)含头不含尾
       System.out.println(s2.substring(3, 6));
       //把字符串全转大写
       System.out.println(s2.toUpperCase());
       //去除前面和后面多余空格
       System.out.println(s2.trim());

       byte[] bs=s2.getBytes();//把字符串里的数据存入byte[]里
       System.out.println(Arrays.toString(bs));
       //把字符串里的数据存到char[]里

       s2="102030405";
       String[] ss=s2.split("0");//按照规则切割字符串
       System.out.println(Arrays.toString(ss));

       //把其他的类型的数据转成字符串
       System.out.println(String.valueOf(123)+1);

       //接收键盘输入的字符串，并且打印每个字符
       String str=new Scanner(System.in).nextLine();
       //既然字符串底层维护了char[],就可以按照下标遍历
       for(int i=0;i<str.length();i++) {
           char c=str.charAt(i);//根据下标获取对应的字符
           System.out.print(c);
       }
   }

}

package cn.tedu.api;
//测试字符串拼接
public class Test3_StringBuilder {

public static void main(String[] args) {
//method();//用+拼接

method2();//用工具类拼接
}

   //用工具类拼接
   public static void method2() {
       //1.把指定的字符串拼接100次，打印拼接结果
       String s="abcdefghijklmnopqrstuvwxyz";
       //定义变量，记录拼接的结果
       String res="";

       //创建工具类的对象
       StringBuilder sb=new StringBuilder();

       //计时开始ms
       long start=System.currentTimeMillis();
       for(int i=0;i<10000;i++) {
           //res=res+s;//用+拼接
           sb.append(s);
       }
       long end=System.currentTimeMillis();
       System.out.println(end-start);//ms1262 1
   }
   public static void method() {
       //1.把指定的字符串拼接100次，打印拼接结果
       String s="abcdefghijklmnopqrstuvwxyz";
       //定义变量，记录拼接的结果
       String res="";
       //计时开始ms
       long start=System.currentTimeMillis();
       for(int i=0;i<10000;i++) {
           res=res+s;//用+拼接
       }
       long end=System.currentTimeMillis();
       System.out.println(end-start);//ms1262
   }
}

package cn.tedu.api;
//测试包装类
public class Test4_Number {

   public static void main(String[] args) {
       // 创建对象--把基本类型变成包装类型--自动装箱
       Integer a=new Integer(5);

       //静态方法valueof()高效，--如果包装类的数据范围在-128-127（缓冲区）
       //之间，只会保存一次
       Integer b=Integer.valueOf(5);
       //下次用，会直接使用已经存在的数据
       Integer in=Integer.valueOf(5);

       System.out.println(a==b);//false
       System.out.println(in==b);//true,会直接使用已经存在的数据




       //调用方法

       int x=a.intValue();//把包装类型包装的值，拆出来，变成基本类型--自动拆箱
       System.out.println(x);
       int y=Integer.parseInt("123");//把字符串类型的数字转成基本类型
       System.out.println(y);


       //Double--把一个基本类型小数包装成包装类型
       Double c=new Double(9.9);

       Double d=Double.valueOf(9.9);
       //把包装类型包装的值，拆出来，变成基本类型
       double m=c.doubleValue();
       System.out.println(m);
   }

}