Object类
| protected Object clone() | 对象克隆(浅克隆) |
| int hashCode() | 获取对象哈希值 |
|
boolean equals(Object obj) {return (this == obj);} |
判断两个对象是否相等 默认比较的是两个对象的内存地址 需要重写 重写的equals函数里的参数还是要是Object obj,否则不是重写，而是重载 |
| String toString() |
将对象转换成字符串形式 默认返回内容是：类标识符@十六进制地址 子类需要重写此方法 println()输出引用本身时，会默认输出引用.toString()方法 |
| Protected void finalize() | 垃圾回收器调用的方法 不需要手动调动，垃圾回收器负责（但要垃圾数量到达一定数量） 开发中用来记录释放时间 System.gc(); 建议启动垃圾回收器（只是建议） |
public static native void arraycopy(Object src , int srcPos , Object dest ,
int destPos , int length);
//src 拷贝源
//srcPos 拷贝起始位置
//dest 拷贝目的位置
//destPos 目标起始位置
//length 拷贝长度
java.lang.String类
用双引号括起来的字符串是字符串常量，直接存储在“方法区”的“字符串常量池”中
（字符串本身是类（应该在堆栈中），但是在开发中使用的太频繁，因此SUN公司把字符串放到了方法区中）
String的几种常用构造方法
String x = "abc"; //第一种
byte[] bytes = {97,98,99};
String x = new String(bytes); //第二种
//abc
byte[] bytes = {97,98,99};
String x = new String(bytes,1,2); //第三种
//bc
String常见方法
| char String.charAt(int index) | 返回 index 号位置上的字符 |
| int compareTo(String str) | 比较字符串，相等返回0，大于返回1，小于返回-1 |
| boolean contains(String str) | 是否包含str |
| boolean endsWith(String str) | 是否以str结尾 |
| boolean startsWith(String str) | 是否以str开始 |
| boolean equals() | 判断两个字符串是否相同 |
| boolean equalsIgnoreCose() | 判断两个字符串是否相等（忽略大小写） |
| byte[] getBytes() | 将字符串转换成 字节 数组 |
| char[] toCharArray() | 将字符串转换成 字符 数组 |
| int indexOf(String str) | 返回str在字符串中第一次出现的位置 |
| int lastIndexOf(String str) | 返回str在字符串中最后一次出现的位置 |
| boolean isEmpty() | 判断字符串是否为空 |
| int length() | 返回字符串的长度（数组length是属性，字符串是方法） |
| String replace(char oldChar,char newChar) | 返回替换后的字符串 |
| String split(String regex) | 依照regex字符串进行拆分，返回拆分后的字符串数组 |
| String substring(int startIndex,int endIndex) | 截取并返回以index为分界线的字符，重载方法(endIndex可以不填） 获取的范围是[ startIndex,endIndex ) |
| String toLowerCase() | 转换成小写 |
| String toUpperCase() | 转换成大写 |
| String trim() | 去除字符串前后空白 |
| String valueOf() | 将括号内的内容(非字符串)转换成字符串，String类中唯一一个静态方法 |
StringBuffer类
StringBuffer的底层其实是一个字符数组，初始化大小为16，满了会自动扩容
优化StringBuffer，因为扩容会产生系统内耗，所以尽可能给一个大一点的初始化容量，减少扩容次数
多线程安全的
StringBuffer strbuf = new StringBuffer(100); //构造方法
StringBuffer.append(); //追加内容
StringBuilder类
多线程不安全
八种包装类
为了把基本数据类型转变成引用数据类型（装箱）
再用包装类的方法把引用数据类型变成基本数据类型（拆箱）
这样就实现了数据类型的转换
| byte | java.lang.Byte | 父类 Number |
| short | java.lang.Short | 父类 Number |
| int | java.lang.Integer | 父类 Number |
| long | java.lang.Long | 父类 Number |
| float | java.lang.Float | 父类 Number |
| double | java.lang.Double | 父类 Number |
| boolean | java.lang.Boolean | 父类 Object |
| char | java.lang.Character | 父类 Object |
包装类里有 MAX_VALUE 和 MIN_VALUE 属性，可以访问当前基本数据类型对于的最大值和最小值
在JDK1.5之后支持自动装箱和自动拆箱了，不再需要包装类里的函数
就算用了包装类也不可以用 == 来比较，因为 == 比较的还是两个对象的地址
JAVA为了提高程序的效率，将-128到127的整形在类加载时就创建好放在了方法区常量池中，因此就算用了包装类，只要值在-128到127内，就不会再重新new一个对象，而是直接在常量池里获取
Integer 里面不能放中文字符串，编译虽然不会报错，但会有运行错误（数字格式化异常）
int --> String String.valueOf(int); //△
Integer --> String String.valueOf(Integer i）
String --> int Integer.parseInt("123") //△
Integer --> int Integer.intvalue() //拆箱
String --> Integer Integer.valueOf(String s)
int --> Integer Integer.valueOf(int i) //装箱
//拆箱和装箱可以不记因为现在可以自动拆箱和装箱
java.util.Date类
Date nowTime = new Date(); //获取当前系统时间（精确到毫秒）
Date nowTime = new Date(long t); //根据1970年到现在的毫秒来创建对象
java.text.SimpleDateFormat类
SimpleDateFormat smp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
//括号里填日期格式
日期格式：
| yyyy | MM | dd | HH | mm | ss | SSS |
| 年 | 月 | 日 | 时 | 分 | 秒 | 毫秒 |
smp.format(nowTime);
//返回一个规定的格式化日期字符串（Date类型转String类型）
Date dateTime = sdf.parse(time);
//将String类型转换成Date类型并且返回,time格式要符合SimpleDateFormat格式
System类
| System.out | out是System的静态变量 |
| System.out.println() | println不是System类的，是PrintStream类的 |
| System.gc() | 建议启动垃圾回收器（只是建议） |
| System.currentTimeMillis() | 获取1970年到现在的总毫秒数 |
| System.exit(0) | 退出JVM |
java.text.DecimalFormat类
DecimalFormat df = new DecimalFormat("###,###.##");
//括号里填数字格式
数字格式：
| # | , | . | 0 |
| 任意数字 | 千分位 | 小数点 | 不够时补0(只可以补左边) |
String s = df.format(1234.56);
//输出为 1,234.56
java.math.BigDecimal类
BigDecimal v1 = new BigDecimal(100); //精度极高的100
BigDecimal v2 = vi.add(v1); //v2为200
//加减乘除都有
java.util.Random类
int i = random.nextInt(); //获取随机数一个
int i = random.nextInt(101); //获取随机数一个(100以内)
所有异常类都有 getMessage() 和 printStackTrace() 两个方法
例：
NullPointerException e = new NullPointerException("空指针异常");
String msg = e.getMessage();
System.out.println(msg); //打印结果：空指针异常
e.printStackTrace(); //打印异常信息
集合继承结构图
所有的集合类都在java.util中
Collection接口
Collection c = new ArrayList();
c.add(1200); //想集合里添加元素，1200自动装箱
c.size(); //获取集合个数
c.clear()； //清空集合
c.isEmpty() //判断是否为空
Object[] toArray() //转换成数组
boolean contains(Object o) //判断是否包含元素o
c.remove(Object o) //删除元素o
/*
* contain，remove函数深入：
* contain，remove的实现调用了是Object里面的equals函数，因此如果集合要存入的是对象
* 因此对象的equals方法要重写
*/
Iterator迭代器
要使用时在声明迭代器，迭代器生成是依照集合当前状态生成的
即迭代器生成后不能改变集合结构，但是可以通过迭代器来删除元素
Iterator it = c.iterator();
boolean hasNext(); //如果还有下一个元素可以迭代返回true
Object next(); //将迭代指针向下移动一个并返回下一个元素
List接口
List l = new ArrayList();
void add(int index,Object element); //指定位置插入元素
Object remove(int index); //删除指定位置元素
Object get(int index); //获取指定位置元素
Object set(int index,Object element); //修改指定位置元素
int indexOf(Object o); //获取元素o的位置
int lastIndexOf(Object o); //获取元素o最后一次出现的位置
ArrayList类
ArrayList初始化容量为10（底层先创建一个初始化为0的数组，当加入第一个元素时，初始化容量为10）
扩容后的容量是原容量的 1.5 倍
构造方法：
ArrayList a = new ArrayList();
ArrayList a = new ArrayList(int initialCapacity); //指定初始化容量
ArrayList a = new ArrayList(Collection<?extends E> c);
//包含一个Collection接口的类进行初始化（可以用于将Set接口下的类转换成List类）
LinkedList类
LinkedList初始化first，last都是 null
假如要频繁的增删改数据或者内存要求比较大，才使用LinkedList
Vector类
初始化容量 10；底层也是数组；扩容后是原来的 2 倍
Map接口
void clear(); //清空
boolean containsKey(Object key); //是否包含key
boolean containsValue(Object value); //是否包含value
V get(Object key); //根据key获取value
V put(K key,V value); //设置键值对
boolean isEmpty(); //是否为空
V remove(Object key); //根据key，删除元素（包括key）
int size(); //返回元素个数
Set<K> keySet(); //返回集合中所有的key
Collection<V> values(); //获取所有的value
Set<Map.Entry<K,V>> entrySet();
//将Map集合转换成Set集合，<Map.Entry<K,V>>也只是一个泛型而已，和<String>性质相同
//Set里面的每一个元素是一个Node，而Node里面存储了key和value
HashMap类
加载因子是 0.75（即顺序表上数据存储占了总容量的75%就开始扩容）
初始化容量是 16（手动赋值必须是 2的倍数）
HashMap里面有 Node 节点，其中包括Object k，Object v，int hash，Node next
hash是k通过哈希算法得到的hash值,同一链表上hash值是相等的
因此用hash来查找顺序表数组下标，然后在该下标的链表下用k来遍历链表，获取value
传入数据，先用hashCode()方法获取hash值，然后找到hash值对应的链表，最后使用k.equals()来判断key是否一致
如果key重复了，链表上的value会被覆盖掉；允许key为null
哈希表的查询和增删改效率都高，因为他用了顺序表作为主要查询表，而要增删改的数据部分都使用了链表的结构
这样就同时兼并了顺序表查找快，链表增删改方便的特点
在HashMap中的对象的 equals方法重写，hashCode方法也需要重写
对于一个equals相等的结构，说明是同一数据（HashMap元素不可重复），同一数据肯定在同一链表上
那么对于的hash值就必须相等，因此hashCode()返回的结果就必须相同，因此需要重写hashCode()方法
JDK8之后，如果单链表上上节点数超过 8，会自动变成树结构(也叫红黑树)，当节点又小于 6 时，会自动变回单链表结构
Hashtable类
key和value值都不能为空
初始化容量 11，默认加载因子 0.75，扩容后是 2*原容量+1
Properties类
setProperty(Object key,Object value); //添加键值对
getProperty(Object key); //获取值
FileReader reader = new FileReader("文件路径");
Properties pro = new Properties();
pro.load(reader); //自动将等号左边做key，右边做value，并且类型都是String
TreeSet类
对String可排序（升序）
实现排序方法：
- 自定义类实现Comparable接口，重写compareTo()方法（返回值是0,>0,<0）
- 编写一个比较器，比较器也要实现java.util.Comparator接口
TreeSet<> w = new TreeSet<>(new comparator);
java.util.Collections工具类
Collections.sort(List list); //排序（还是要实现Comparable接口和实现compareTo()方法）
Collections.synchronizedList(list); //线程安全
java.io类
- java.io.InputStream类
- java.io.OutStream类
- java.io.Reader类
- java.io.Writer类
以上四个都是抽象类
java.io.Flushable接口
flush(); //将管道内未输出的数据强行输出完，作用于清空管道
java.io.FileInputStream类
FileInputStream fis = new FileInputStream("文件路径");
int read(); //读取一个字节,若读到文件末尾，返回-1
int read(byte[] b); //往数据内读数据，返回值是读到的字节数，当读到0个字节时时返回-1
read(byte[] b,int offse,int length); //读入具体数量的数据
fis.close(); //关闭流
int available(); //返回流中剩余没有读的字节数量
long skip(); //跳过几个字节不读取
java.io.FileOutputStream类
fos = new FileOutputStream("文件路径",ture)； //ture代表在文件末尾处追加，默认为false
write(); //写入数据
write(byte[] b); //写入数据
write(byte[] b,int offse,int length); //写入具体数量的数据
以上两个类读和写可以拷贝任意类型的文件（包括图片和视频）
java.io.FileReader类
只能读取普通文本
与 FileInputStream 的区别就是变成了char数组
java.io.FileWriter类
只能读取普通文本
write(char[] c);
write(String str);
java.io.InputStreamReader类
InputStreamReader reader = new InputStringReader(FileInputStream in);
java.io.OutputStreamWriter类
OutputStreamReader reader = new OutputStringReader(FileOutputStream in);
java.io.BufferedReader类
自带缓冲区，不需要传入数组
当一个流的构造方法中需要一个流的时候，被传入的流叫 节点流
外部的流叫做 包装流 或者 处理流
BufferedReader br = new BufferedReader(Read in);
String readline(); //一次读取一行，不带换行符，文件末尾返回null
java.io.BufferedWriter类
和BufferedReader类似
java.io.BufferedInputStream类
java.io.BufferedOutputStream类
java.io.DataOutputStream类
可以将数据连同数据类型一起写入文件
只能用DataInputStream来读取数据，并且提前知道数据的存储顺序
DataOutputStream dis = new DataOutputStream(FileOutputStream out);
dis.writeByte();
dis.writeShort();
dis.writeInt();
dis.writeLong();
dis.writeFloat();
dis.writeDouble();
dis.writeBoolean();
dis.writeChar();
java.io.DataInputStream类
java.io.PrintWriter类
java.io.PrintStream类
标准输出流不需要手动关闭
PrintStream ps = System.out；
ps.println("abcdefg~");
PrintStream ps = new PrintStream(new FileOutputStream("文件路径"))；
System.setOut(PrintStream ps); //将输出方向转到文件里
java.io.ObjectOutputStream类
ObjectOutputStream oos = new ObjectOutputStream(OutputStream os);
os.writeObject(s);
os.writeObject(list); //可以序列化一个对象集合
java.io.ObjectInputStream类
用于实现反序列化
java.io.File类
File f1 = new File("文件路径");
f1.exists(); //判断文件是否存在
f1.createNewFile(); //创建文件
f1.mkdir(); //以目录形式创建
f1.mkdirs(); //以多重目录形式创建
f1.getParent(); //获取父路径
f1.getAbsolutePath(); //获取绝对路径
f1.getName(); //获取文件名
f1.isDirectory(); //判断是否是一个目录
f1.isFile(); //判断是否是一个文件
f1.lastModified(); //获取文件的最后修改时间，返回值是一个long类型毫秒
f1.length(); //获取文件大小，按字节算
f1.listFiles(); //获取路径下所有子文件
Thread类
String getName(); //获取线程名字
voide setName(String s); //设置线程名字
Thread.currentThread(): //获取当前线程
static void sleep(long hm); //只能让出现sleep所在的进程睡眠（进入阻塞状态），单位是毫秒
void setPriority(); //设置优先级
int getPriority(); //获取线程优先级
static void yield(); //让位方法（进入就绪队列）
void join(); //合并线程（当前所在线程会让t先运行玩在继续运行）
t.setDaemon(true); //将线程设置为守护线程
java.util.Timer类
timer.schedule(TimerTask t, Date firstTime, long hm);
//从firstTime开始，每隔hm毫秒执行一次t任务
//例：
Timer timer = new Timer();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-03-14 09:30:00");
timer.schedule(new LogTimerTask(),firstTime,1000*10);
class LogTimerTask extends TimerTask{
public void run(){}
}
270
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
