java从入门到精通API01

Posted 2023-02-28 cgblpx皮皮霞

文章目录

• • 1 API1
  • • 1.1 Object
    • • 1.1.1 概念
      • 1.1.2 常用方法
      • 1.1.3 toString()
      • 1.1.4 equals(Object obj)
      • 1.1.5 hashCode()
    • 1.2 String
    • • 1.2.1 特点
      • 1.2.2 创建String对象
      • 1.2.3 字符串连接效率
      • 1.2.4 常用方法
      • 1.2.5 测试
    • 1.3 StringBuilder/StringBuffer
    • • 1.3.1 特点
      • 1.3.2 练习：测试字符串连接
      • 1.3.3 方法
    • 1.4 包装类
    • • 1.4.1 与基本类型的对应关系
      • 1.4.2 Number
      • 1.4.3 Integer
      • 1.4.4 Double
    • 1.5 日期类Date
    • • 1.5.1 概述
      • 1.5.2 创建对象
      • 1.5.3 常用方法
      • 1.5.4 练习1：测试日期类的常用方法
    • 1.6 日期工具SimpleDateFormat
    • • 1.6.1 概述
      • 1.6.2 创建对象
      • 1.6.3 常见方法
      • 1.6.4 练习1 ：计算存活天数
    • 1.7 拓展
    • • 1.7.1 进制
      • 1.7.2 StringBuilder和StringBuffer的区别
      • 1.7.3 自动装箱和自动拆箱
  • 2 IO1
  • • 2.1 BigDecimal/BigInteger
    • • 2.1.1 概述
      • 2.1.2 创建对象
      • 2.1.3 常用方法
      • 2.1.4 练习1：测试常用方法
    • 2.2 IO简介
    • • 2.2.1 继承结构
      • 2.2.2 流的概念
    • 2.3 File文件流
    • • 2.3.1 概述
      • 2.3.2 创建对象
      • 2.3.3 常用方法
      • 2.3.4 练习1：测试常用方法
      • 2.3.5 练习2：递归求目录总大小
      • 2.3.6 练习3：递归删除文件夹
    • 2.4 字节流读取
    • • 2.4.1 InputStream抽象类
      • 2.4.2 FileInputStream子类
      • 2.4.3 BufferedInputStream子类
    • 2.5 字符流读取
    • • 2.5.1 Reader抽象类
      • 2.5.2 InputStreamReader子类
      • 2.5.3 FileReader子类
      • 2.5.4 BufferedReader子类
    • 2.6 综合练习：文件的读取
    • 2.7 扩展1
    • • 2.7.1 字符流和字节流的区别
      • 2.7.2 字符流读写乱码
      • 2.7.3 常见字符编码表
      • 2.7.4 JDK1.7新特性之IO关流
  • 3 IO2
  • • 3.1 字节流写出
    • • 3.1.1 OutputStream抽象类
      • 3.1.2 FileOutputStream子类
      • 3.1.3 BufferedOutputStream子类
    • 3.2 字符流写出
    • • 3.2.1 Writer抽象类
      • 3.2.2 OutputStreamWriter子类
      • 3.2.3 FileWriter子类
      • 3.2.4 BufferedWriter子类
    • 3.3 综合练习：文件的写出
    • 3.4 IO综合练习
    • • 3.4.1 练习1：文件复制
      • 3.4.2 练习2：批量读写
    • 3.5 序列化 / 反序列化
    • • 3.5.1 概述
      • 3.5.2 应用场景
      • 3.5.3 特点
      • 3.5.4 序列化：ObjectOutputStream
      • 3.5.5 反序列化：ObjectInputStream
      • 3.5.6 练习1：将学生信息序列化至磁盘【序列化】
      • 3.5.7 Java 中的序列化存在安全问题
    • 3.6 编码转换流
    • • 3.6.1 工具类
      • 3.6.2 常见字符编码表
      • 3.6.3 测试
    • 3.7 扩展
    • • 3.7.1 IO中flush()和close()的区别
      • 3.7.2 封装释放资源的close()
      • 3.7.3 BIO、NIO、AIO的区别
      • 3.7.4 数组和链表区别
      • 3.7.5 读一行写一行
  • 4 泛型+集合1
  • • 4.1 泛型
    • • 4.1.1 概念
      • 4.1.2 作用
      • 4.1.3 泛型示例
      • 4.1.4 泛型声明
      • 4.1.5 常用名称
      • 4.1.6 用途：编译时类型检查
      • 4.1.7 用途：代码通用性更强
      • 4.1.8 泛型擦除
      • 4.1.9 泛型加强
    • 4.2 Collection接口
    • • 4.2.1 概述
      • 4.2.2 集合的继承结构
      • 4.2.3 常用方法
      • 4.2.4 练习1：测试常用方法
    • 4.3 List接口
    • • 4.3.1 概述
      • 4.3.2 特点
      • 4.3.3 常用方法
      • 4.3.4 练习1：测试常用方法
    • 4.4 ArrayList
    • • 4.4.1 概述
      • 4.4.2 创建对象
      • 4.4.3 练习1：测试常用方法
    • 4.5 LinkedList
    • • 4.5.1 概述
      • 4.5.2 常用方法
      • 4.5.3 练习1：测试迭代器遍历
    • 4.6 扩展
    • • 4.6.1 ArrayList扩容
      • 4.6.2 HashMap扩容
  • 5 集合2
  • • 5.1 Set接口
    • • 5.1.1 概述
      • 5.1.2 特点
      • 5.1.3 常用方法
      • 5.1.4 练习1：测试常用方法
    • 5.2 HashSet
    • • 5.2.1 概述
      • 5.2.2 练习1：获取HashSet里的元素
      • 5.2.3 练习2：Set存储属性值相同的对象
    • 5.3 Map接口
    • • 5.3.1 概述
      • 5.3.2 特点
      • 5.3.3 继承结构
      • 5.3.4 常用方法
      • 5.3.5 练习1：测试常用方法
    • 5.4 HashMap
    • • 5.4.1 概述
      • 5.4.2 练习1：读取HashMap的数据
      • 5.4.3 练习2：字符串中的字符统计
    • 5.5 Collections工具类
    • • 5.5.1 常用方法
      • 5.5.2 测试
    • 5.6 扩展
    • • 5.6.1 集合和数组的区别
      • 5.6.2 HashMap实现原理

1 API1

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.1 特点

是一个封装char[]数组的对象

字符串不可变

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.3.3 方法

append()
charAt()

1.4 包装类

1.4.1 与基本类型的对应关系

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以上是关于java从入门到精通API01的主要内容，如果未能解决你的问题，请参考以下文章
 
 java从入门到精通API01
 java从入门到精通API02
 java从入门到精通API02
 java从入门到精通API02
 java从入门到精通01
 2021最新Java学科全阶段视频教程（从入门到精通）