JAVA函数笔记

最新推荐文章于 2023-04-06 17:13:19 发布

The_RedMaple

最新推荐文章于 2023-04-06 17:13:19 发布

阅读量255

点赞数

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/The_RedMaple/article/details/117701211

版权

JAVA 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

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(){}
}