java大括号代码块 java大括号的使用

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();