Java SE 基础部分笔记

Math常用方法

Math.abs(-2.0); //2.0  —— 绝对值
Math.ceil(3.3); //4.0  向上入——ceil天花板
Math.floor(3.6);//3.0  向下入——floor地板
Math.round(5.5);//6.0  四舍五入
Math.pow(2.0,2.0); // 4.0  第一个参数的第二个参数次幂

构造方法：子类对象调用父类构造方法

构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

public Fu{System.out.println("Fu");}
public Zi{System.out.prinyln("Zi");}

多态的特点：

    编译期检查父类：看父类是否有指定成员，如果没有则编译报错
    运行时：
        1.非静态的成员方法：如果子类有重写，则运行子类重写后的方法
        2.其他（静态方法，静态成员变量，非静态成员变量）：都使用父类

多态的缺点：

父类对象不能调用子类特有成员，如需调用，需要向下转型

多态的优点：

在方法的参数上，如果定义的类型是父类类型，则可以接收任意的子类对象

接口

public interface 接口名称{
    // 抽象方法    —— 可以省略abstranct，没有方法体，供子类实现使用(继承必须重写)
    // 默认方法    —— 不可省略default，供子类调用或者子类重写(继承后可以不重写） 
    // 子类可以默认使用接口定义的默认方法，假设有100个类使用了这个接口，如果有一天接口增加了新功能，那么所有的子类都要重写，这个时候，只需要在接口写默认方法，那么所有的子类就可以直接调用了。
    // 静态方法    —— 供接口直接调用
    // 私有方法    —— 供结构中的默认方法或者静态方法调用
}
public abstract 抽象方法{
    // 抽象类中可以有任意的成员，可以没有任意成员
}
若方法名与父类重名，则优先调用父类方法。

抽象类

一个类包含抽象方法，那么这个类就必须是抽象类
子类继承父类，要么它也是抽象类，要么它必须重写父类抽象方法

日历对象

Calendar类的月份表示是0——11月

Set和Map

Set和Map存储数据都是无序的，如果想有序存储数据，则使用他们对应的LinkedHashSet和LinkedHashMap就可以了

boolean containsKey()
boolean containsValue()

Map的key和value只能存放引用类型，不能存放基本类型（装箱） –> 集合只能存放引用类型，不能存放基本类型（自动装箱）

LinkedList：双向链表

特有功能：能在链表的两端进行操作（增删查）
    * linkedList = [a,b,c,d,e,f,g]
    * 获取d元素，list.get(4)，7/2=3，d的索引是4，所以从末尾开始获取元素
    * 在底层其实本质上链表没有索引，如果想获取链表中某个指定索引位置的元素
    * 先判断索引和长度/2的值谁更大，如果索引大，则从链表的末尾开始往前进行获取元素
    * 如果长度/2的值比较大，则从链表头开始获取元素
    * 尽量不要使用普通for遍历LinkedList，效率差，用增强for

List去重

String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"};
//直接调用方法contains
if(!list.contains(str)) list.add(str);

并发/并行

并发：理论上的同时发生，实际上CPU在多个线程种进行高速的切换，单个时刻其实只有一个线程在执行
并行：实际上的同时发生，在某个时刻，多个线程同时在执行
进程：指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以运行多个进程
线程：进程内部的一个独立执行单元，一个进程可以同时并发的运行多个线程`
Runnable比Thread优点在哪:Runnable可以被多个线程共享，并且可以继承有共性的父类
字符串是在常量池中存储的

sychronized

非静态方法的同步锁对象是this
静态方法的同步锁对象是该类的字节码对象，如MyTest.class（绝对唯一）
线程的6种状态：

New （新建） — start方法前
Runnable （可运行）
Blocked （锁阻塞）
Wait （无限等待）该方法会释放锁
TimeWait （计时等待）
Terminatesd （被终止）
wait()方法会释放锁，notify()方法不会释放锁

线程池 ThreadPool 的使用步骤优点:1.效率高 2.复用性高 3.节约资源

    //1. 创建线程池对象
    ExcutorService service = Excutors.newFixedThreadPool(int count); count:包含几个线程对象
    //2. 创建要执行的Runnable对象
    MyRunnable runnable = new MyRunnable();
    //3. 从线程池中获取线程对象，然后调用Runnable里面的run方法
    service.submit(runnalbe);//将runnable塞给线程池运行
    //4. 关闭线程池
    service.shutdown();

File类常用方法

构造方法：

File(String pathName)
File(File parent,String child)
File(String parent,String child)
File对象在创建的时候，需要在构造方法中声明文件的目录

String getAbsolutePath() 获取绝对路径 getAbsoluteFile()
String getPath() 获取构造路径
String getName()获取文件/目录名称 getParent() getParentFile
long length() 获取文件注意不能直接获取文件夹的大小(只能将该文件夹下的内容大小进行相加)

boolean exists()此File表示的文件/目录是否实际存在 isHidden() 判断文件的隐藏属性是否为true
boolean isDirectory() 此File表示的是否为目录
boolean isFile()此File表示的是否为我文件

boolean createNewFile() 仅当该文件名称不存在时/父路径存在时，创建【一个】新的文件
boolean delete()删除由此File表示的文件或目录 — 删除目录时，目录里面为空才能被删除
boolean mkdir() 创建单级目录
boolean mkdirs() 创建多级目录，包括任何必须但不存在的父目录

String[] list() 返回一个String数组，表示该File目录中的所有子文件或目录
File[] listFiles()返回一个File数组，表示该File目录中的所有子文件或目录

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历

boolean accept() File的过滤器，使用方法：匿名内部类，

listFiles((new FileFilter(){
    @Override
    public boolean accept(){
            return true;
    }
}));
//如果返回false，则被过滤掉，如果返回true，则被留下

FileOutputStream 字节输出流

构造方法：

FileOutputStream(File file)
FileOutputStream (String path)

关联文件过程：
    1.创建流对象 
    2.判断文件是否存在  
    3. 没有，就创建，有，就清空，并和文件关联
 前提条件是，父路径必须存在，否则会抛出异常
FileOutputStream(File file,boolean append)
声明是否继续续写文件 true表示追加数据，false表示清空原有数据

void write(int b)写出字节，每次只能写出一个字节数据写的是ASCII码表中的整数
void write (byte[] b)写出字节数组
void write(byte[] b,int off,int len) 从off开始，写入len个字节

FileInputStream 字节输入流（若文件不存在，则会报错）

int read() 每次可以读取一个字节数据，提升为int类型，取到末尾返回-1
read(byte[] b) 每次读取b个长度的字节到数组中，返回读取的有效字节个数，取到末尾返回-1
read(byte[] b,int off,int len) 从off开始，每次读取len个有效字节数

FileReader 字符输入流（若文件不存在，则会报错）

构造方法：

FileReader(File file)
FileReader(String name)

int read()从输入流读取一个字符
int read(char[] ch) 从输入流中读取一些字符，并存储到ch字符数组中

FileWriter 字符输出流

构造方法：

FileWriter(File file)
FileWriter(String name)

void flush()刷新此输出流，并强制任何缓冲的输出字符被写出，缓冲区满了会自动刷新
void write(int c)
void write(char[] chs)
void write(String str)

FileWriter必须关闭流才会写入文件，否则数据只是保存在缓冲区，并未保存到文件

字符流，只能操作文本文件，不能操作图片，视频等非文本文件
当我们单纯读或者写文本的时候，使用字符流，其他情况使用字节流

缓冲流

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组[8192]，通过缓冲区读写，减少系统IO 次数，从而提高读写的效率。（想要读写更快，就使用byte[] 来接收和传递）

BufferedInputStream 字节缓冲输入流

构造方法：BufferedInputStream(InputStream in)

BufferedOutputStream 字节缓冲输出流

构造方法BufferedOutputStream(OutputStream out)

BufferedReader 字符缓冲输入流

构造方法：BufferedReader(Reader in)

特有方法：String readLine() 读取一行文字

BufferedWriter 字符缓冲输出流

构造方法：BufferedWriter(Writer out)

特有方法：void newLine 写一行行分隔符，由系统属性定义符号，如 \r\n 、\r、 \n

转换流

【编码转换流】把字节流转换成字符流

InputStreamReader

构造方法：

InputStreamReader(InputStream in)
InputStreamReader (InputStream in, String charset)
字节数据读取出来，读到程序中，按照你指定的编码格式，进行转换，把固定数量的字节转换成对应的字符
字节数据转换成字符数据的一个桥梁

OutputStreamWriter

构造方法：

OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out, String charset)
转出转换流，本身是一个字符流，输出的数据是字符，但是先把字符按照指定的编码，把字符转成对应的字节
字符数据通向字节的桥梁

序列化流

【序列化/反序列化】Serializable就是一个标记接口，想要序列化，就必须实现这个接口
【瞬态关键字】【transient】修饰的属性不会被序列化
serialVersionUID 固定序列化ID，可以保证反序列化的成功

ObjectOutputStream

构造方法： ObjectOutputStream(OutputStream out)

void writeObject(Object obj) 将指定对象写出

ObjectInputStream

构造方法：ObjectInputStream(InputStream in)

Object readObject() 读取一个对象

打印流

PrintStream

构造方法：PrintStream(String path) 设置打印流的文件位置
System.setOut(ps) 设置系统打印System.out.println()的流向，–>流向PrintStream创建的文本位置