java properties 大括号_javaSE高级知识总结

1.Object类

1.Object是所有类的父类，所有类都可以用其中的方法

2.常用方法

toString()转换为对象的地址

equals() 比较地址与==相同

hashCode()返回对象的哈希值

3.常用方法使用场景

1.自定义类型

1.toString():要重写toSting方法，因为print()方法调用时Object中的toString方法，会打印对象的地址

2.equals():要重写equals方法，equals只能判断地址，我们要让它能判断内容是否相同

public boolean equals(Object o){

//第一步判断比较的两个地址是否相同,相同直接返回true;

if(this==o){

return true;

}

//第二步，地址不同后，判断参数是否为null,为空就是没有对象，返回false；

两个类的信息是否相同，信息不同内容肯定不同

if(o!=null||getClass()!=o.getClass()){

return false;

}

//第三步内容判断

//类型转换为该类的类型

A a = (A)o;

//基本数据类型直接比较值是否相等；引用数据类型，进行Objects类中的equals()进行比较，

两个参数有一个为空返回false,两个参数都为null返回true;否则进行第一个参数中的equals()进行比较；

如果时字符串的话，进行的就是"".equals(),比较的是内容，相同返回true

return .....&&Object.equals( , ).......;

}

2.Date类

1.Date类是时间类，表示一个瞬时的时间

2.构造方法

new Date();创建一个包含当前时间的对象

new Date();创建一个从1970年1月1日 0:0:0的参照物指定毫秒数

3.常用方法

long getTime();返回当前时刻的毫秒值

3.SimpDateFormat类

1.SimpDateFormat是一个转换日期格式的类

2.构造方法

new SimpDateFormat("日期格式");

3.常用方法

String format(Date date);把日期转换为指定字符串

Date parse(String source);根据指定字符串解析为日期对象

4.Calendar类

1.Calendar类是一个日历类，可以获取日期中的每一个属性

2.没有构造方法，只能通过Calendar.getInstance()获取对象

3.常用方法

int get(int 字段值);

void set(int 字段值,int 设置的值);

void add(int 字段值,int 添加/减去的值);

Date getTime();

5.System类

1.System类中有大量的静态方法

long currentTimeMillis();获取当前的毫秒值

void arrayCopy(原数组,开始索引,目标数组,开始索引,复制长度);

6.StringBuilder类

1.是一个字符串缓冲区，可以高效的拼接字符串，不用每次都要创建对象

2.构造方法

new StringBuilder();创建一个空的容器

new StringBuilder(String str);创建一个容器，并放入字符串

3.常用方法

StringBuilder append(String str);

String toString();把对象中的内容转换为字符串

7.包装类

1.主要作用就是为了让基本数据类型也有一定的功能

2.自动拆箱与装箱

3.每个包装类中共有的方法

xxx parseXxx(String); 把字符串转换为基本数据类型

8.Collection类

1.Collection是单列集合抽象类

2.常用方法(在子类中有些方法会被重写)

boolean add(E e);

void clear();

boolean remove(E e);

boolean contains(E e);

boolean isEmpty();

int size();

Object[] toArray();

9.迭代器

1.Iterator类是一个遍历集合的类

2.使用步骤

Itertor iter = list.Itertor();

while(iter.hasNext()){

Object o = iter.next();

}

10.增强for

1.遍历集合，数组

for(Object o:list){

sout(o);

}

11.泛型

1.泛型的主要作用就是把运行期的异常提升到编译器，我们也可以用泛型使用一些设计模式

2.类泛型

1.修饰符 类名{},这里的泛型是未知的，在创建对象的时候确认泛型的类型；

2.方法想要使用类中的泛型，可以直接使用

3.方法泛型

1.修饰符 返回类型(E e);

2.调用方法是确认泛型

4.接口泛型

1.修饰符 接口名{}

2.实现接口的时候确认泛型

5.泛型的通配符?,可以接收任意类型的泛型

6.泛型的上限与下限

1.上限

extends 类> 只能使用此类和此类的子类

2.下限

super 类> 只能使用此类和此类的父类

12.List

1.List是一个单列集合接口，有索引，有序，可以重复

2常用方法

void add(int index,E e);

E get(int index);

E set(int index, E e);

E remove(int index);

3.List实现类

1.ArrayList

1.底层是数组结构，查询快，增删慢

2.常用方法，与List接口方法相同

2.LinkedList

1.底层是双向链表，查询慢，增删快

2.常用方法

public void addFirst(E e) :将指定元素插入此列表的开头。

public void addLast(E e) :将指定元素添加到此列表的结尾。

public E getFirst() :返回此列表的第一个元素。

public E getLast() :返回此列表的最后一个元素。

public E removeFirst() :移除并返回此列表的第一个元素。

public E removeLast() :移除并返回此列表的最后一个元素。

public E pop() :从此列表所表示的堆栈处弹出一个元素。

public void push(E e) :将元素推入此列表所表示的堆栈。

public boolean isEmpty() ：如果列表不包含元素，则返回true。

13.Set

1.Set是一个单列集合，无索引，无序，不能重复

2.常用方法

与Collection接口中的方法相同

3.Set实现类

1.hashSet

1.底层为哈希表(数组+链表/数组+红黑树)结构，都很快

2.常用方法，与Collection接口方法相同

3.注意

1.因为hashSet底层为哈希表，可以去重，但是自定义类型去重，需要重写hashCode()方法，方法中

调用Objects中的hash(,,);里面参数可以写多个，如果hash()判断后不为true,进行内容比较，调用equals()方法

2.LinkedHashSet

1.底层为双向链表+哈希表，有序

2.常用方法，相同

3.TreeSet

1.这个集合可以定义排序规则，

需要实现Compartor();返回0为不添加，返回负数，按照添加顺序，倒叙排列；返回正数，按照添加顺序排序

14.Collections

1.Collections类是一个工具类里面有一些静态方法

2.常用方法

void shuffle(List list);打乱集合

void sort(List list);升序排序

void sort(List list ,Compartor com);定义排序规则

15.Map

1.Map接口是一个双列集合，

2.常用方法

v put(k key,v value);

v remove(k key);

v get(k key);

Set keySet();

Set>entrySet();

3.Map实现类

1.HashMap

1.底层为哈希表，无序

2.方法与接口方法相同

2.LinkedHashMap

1.底层为双向链表+哈希表，有序

2.方法与接口方法相同

16.异常

1.Throwable是异常和错误的父类

2.Error

无法处理，致命的错误

3.Exception

1.可以处理

2.编译时异常，必须处理

1.处理方法，可以使用关键字throw抛出，抛出之后调用该方法的对象也要抛出，最后交给JVM处理，中断程序执行

2.捕获异常并处理

try{

//可能出现异常的代码

}catch(Exception e){

//出现异常后运行的代码

}finally{

//必须执行的代码，就算上面代码有return，这里面的return也会覆盖上面的return;

}

3.运行时异常，可以不进行处理，JVM自己处理，JVM处理永远都是中断程序执行

4.自定义异常

1.需要继承Exception类

1.只需要创建无参构造方法与有参构造方法

2.有参构造方法可以传一个异常的名字，调用父类的有参构造传递这个字符串名字

17.多线程

1.多线程就是开了多个任务

2.并发与并行

并发就是多个进程在同一时间段进行

并行就是多个进程同一时刻一起进行

3.进程与线程

每个程序都会在内存中开辟一个进程，进程中必须有一个线程，可以有多个线程

线程时进程的一个执行单元

4.创建线程类

1.继承Treader

重写run()方法

2.实现Runnable接口

重写run()方法

5.线程安全，线程同步

1.多个线程访问共享资源的时候，会造成结果与单线程结果不同，这就是线程不安全，

2.通过设置线程锁代码块解决synchronized

synchronized(随便一个对象，但多个线程必须使用的的对象相同){

//这里面的程序每次只能有一个进程执行

}

3.线程同步执行流程

1.当一个进程获取到锁对象的时候进入代码块中状态为Runnable,其他线程进入Blocked状态

2.当进程执行的最后一个大括号时释放锁对象，进入Blocked状态，其他对象拿到锁对象，从Blocked状态进入Runnable状态

4.同步方法解决

public synchronized void 方法名()

5.Lock锁

Lock lock = new ReentrantLock()

void lock()加锁

void unlock()释放锁

6.线程状态

NEW 新创建一个线程，并没有调用start()方法

Runnable 运行时状态，获取到锁

Blocked  阻塞状态，没有获取到锁

Waiting  无限等待状态，进入这个状态，要释放锁，并在该位置等待其他线程调用notify()方法

TimedWaiting 限时等待，进入这个状态后，不会释放锁，时间到了之后自动运行

Teminated    死亡状态

18.线程池

提升了性能，不用我们在频繁的创建线程，只需要从线程池中拿去就可以了

1.使用

Executors.newFixedThreadPool(int 线程数量);

创建Runnable接口的实列化对象

sumbit(Runnable run);

19.lambda

1.可以节省代码量

2.使用

1.只能用于函数式接口，类中或者接口中只能有一个抽象方法，否则无法使用，因为要根据上下文判断 参数

2.参数的类型可以不写，

(a,b)->{};

3.如果方法体中只有一行语句，可以不用写大括号分号return

(a,b)->.....;

4.参数只有一个小括号也可以省略

a->......;

a->{};

20.File类

1.把文件抽象为一个对象，

2.构造方法

new File(String pathName);

new File(String parent,String pathName);

new File(File file,String pathName);

3.常用方法

String getAbsolutePath();后去绝对路径

String getPath();写的路径是什么就是什么

String getName();最后一个文件名或文件夹名

long length();文件的长度，不能查看文件夹

boolean exists()File表示的文件是否存在

boolean isFile()查看是否为文件

boolean isDirectory()查看是否为文件夹

boolean createNewFile()文件不存在时创建一个新文件

boolean delete()删除一个文件，只能删除一个，文件夹为空时才能删除

boolean mkdir()创建目录

boolean mkdirs()创建多层目录

String[] list();

File[] listFiles();

21.递归

1.递归主要找f(x)与f(x-1)的关系

2.必须要有出口，否则堆内存会溢出

3.递归次数不能太多，堆内存会溢出

22.过滤器

File[] FileLists(FileFilter);把过滤后的对象存在数组中

要重写FileFilter中的accept()方法，返回true为符合条件，添加进去

23.IO流

1.一切皆为字节

2.字节流

1.输出流OutputStream(抽象类)

1.常用方法

void write(int b);

void write(byte[] bytes);

void write(byte[] bytes,int off,int len);

void close();

vlid flush();

2.子类FileOutputStream

1.构造方法

new FileOutputStream(File file);

new FileOutputStream(String str);

2.常用方法与父类相同

2.输入流InputStream(抽象类)

1.常用方法

void read();

void read(byte[] bytes);

void close();

2.子类FileInputStream

1.构造方法

new FileInputStream(File file);

new FileInputStream(String str);

2.常用方法与父类相同

3.字符流

1.输出流Writer

1.常用方法

void write(int c);

void write(char[] c);

void write(char[] c ,int off,int len);

void write(String str);

void write(String str, int off,int len);

void flush();

void close();

2.子类FileWriter

1.构造方法

new FileWriter(File file);

new FileWriter(String str);

2.常用方法与父类相同

2.输入流Reader

1.常用方法

void read();

void read(char[] c);

void close();

2.子类FileReader

1.构造方法

new FileReader(File file);

new FileReader(String str);

2.常用方法与父类相同

4.IO异常的处理

1.开发中使用捕获异常并处理，比较繁琐，资源都需要手动关闭

2.JDK7的处理不需要手动关闭资源

try(创建的流对象语句用;号分开){

//读写操作

}catch(){

}

5.属性集

1.Properties类

是一个和IO相关的双列集合

2.常用方法

Object setProperty(String key,String value);

String getProperty(String key);

Set stringPropertyNames();

void load(InputStream is); 读取信息

void store(OutputStream os ,String str);写入文件

24.缓冲流

1.字节缓冲流 BufferedInputStream ; BufferedOutputStream

1.是对字节流的加强，使其高效

2.字节输入缓冲流BufferedInputStream

1.构造方法

new BufferedInputStream(InputStream is);

3.字节输出缓冲流BufferedOutputStream

1.构造方法

new BufferedOutputStream(OutputStream os);

2.字符缓冲流

1.字符输入缓冲流

1.构造方法

new BufferedReader(Reader r);

2.特有方法

String readLine();

2.字符输出缓冲流

1.构造方法

new BufferedWriter(Writer w);

2.特有方法

void newLine();

25.转换流

1.编码的转换，是字节流与字符流的桥梁

2.InputStreadReader(InputStream in,"字符集,码表"); 不指定字符集默认为urf-8

OutputStreamWriter(OutputStream os,"字符集");

26.序列化

1.把对象保存到文件中

2.ObjectOutputStream(OutputStream os);

1.常用方法

writeObject(对象);该对象的类必须序列化，也就是继承java.io.Serializable

3.ObjectInputStream(InputStream is);

1.常用方法

readObject();读取的内容不能更改，会报异常，可以定义一个序列版本号 static final long serialVersionUID = ;

27.打印流

1.PrintStream

1.构造方法

new PrintStream(String str);

2.常用方法

void print();

void println();