java集合,多线程,面向对象,枚举类,异常等所有常用的方法总和

extends //继承
Instanceof //多态里面的比较是否new 的对象为他
abstract //抽象类
final // 不可修改,最终的 如果在类前面加那么表示此类不可以被继承
static //静态类

接口:
interface  //生成接口
implements //实现接口

封装等级:
private //局部
pubilc //外包也可以
protected //不适应同一个工程

异常:
Throwable //比下面的这个异常等级更高的异常类
Exception //异常类所继承的是Throwable 

try   catch  finally  //常用的异常处理方式    
throws  //在函数后面加把错误导给调用它的类
throw //使用来抛异常 如  new WoshiyigeYichang("我是个异常"); 但是得重写父类

多线程:
extends Thread  //使用继承的方式调用多线程
implements Runnable //使用多线程需要继承的接口 ,比Thread好用
implements Callable //比Runnable接口强大的接口 支持返回值，泛型类，异常

多线程:线程安全
Synchronized(this) //同步锁 用来防止线程不安全问题  如果使用static那调用的就是 当前对象.class
ReentrantLock  {
类  lock();锁定 
和 unlock();解锁方法 需要try环绕
}

其他东西:
Objgct  //所有的父类
Math.random() //随机数生成
Arrays.sort(b); //快速排序
n.equals( )  //比较方法
Pattern.matches(s2, identityCard) //正则表达式判断,前面有个放正则后面一个放string类型

路径调包:
package //路径
import //调用包

多线程:常用方法
1.xc.start(); //启动该线程
2. xc.setName("线程1:"); //给线程起名字
2.1:    Thread.currentThread()   //当前进程
3. Thread.currentThread().setName("主线程:");//给main主线程命名  
3.1:getNAme(); //获取当前线程名字

  4. xc.join();  //当i为20的时候只有执行完调用线程 xc的线程的时候才会执行    需要try/catch 环绕  让自己堵塞执行xc线程完成之后在执行自己
5.  yield(); //如果满足此条件释放当前执行权力
6.Thread.currentThread().getName() //输出当前线程名称
7.   sleep(500);  //如果满足此条件就让他500秒之后再运行    需要try/catch 环绕
8. this.stop(); //强制性结束进程
9.run()  通常重写好用

多线程:优先级:
Thread.MAX_PRIORITY //设置线程优先级为最高
Thread.NORM_PRIORITY //设置线程优先级为中
Thread.MIN_PRIORITY //设置线程优先级为最低

 setPriority(  )  //输入线程优先级:  xc2.setPriority(  ) 
xc2.getPriority() //输出线程优先级     xc2.getPriority() 

多线程:唤醒
{  //都是在同步代码块里面操作
wait();//睡眠此线程 wait(long timout) //睡眠指i定时间后唤醒此线程 
* 注此类是在Obgect类中调用的 ,slepp是在Thread中调用的 
notify //唤醒优先级高的线程
notifyAll //唤醒所有睡眠线程
}

多线程:线程池
ExecutorService 和 Executors
ExecutorService 真正的接口 常见子类ThreadPoolExecutor
x1.execute(Runnable r1); //执行Runnable接口的线程池
x2.submit(Callable c1);//开启线程3  execute适应于 Callable接口

ExecutorService x1= Executors.newFixedThreadPool(2);//创建一个指定大小的线程池
ExecutorService x3= Executors.newCachedThreadPool();//创建一个可能需要创建的线程池
ExecutorService x4= Executors.newSingleThreadExecutor();//创建一个只有一个线程的线程池
ExecutorService x5= Executors.newScheduledThreadPool(100);//创建一个线程池,它可安排在给定延迟后运行命令或者定期执

String 类:

 s1.length() //比较字符长度
s2.charAt(2)找string类型的第2位 从第0位开始
s3.isEmpty() 判断字符是否为空
s4.toLowerCase() //大写转小写     s41.toUpperCase() //小写转大写
s5.trim() 去掉前面的空格和后面的空格
s6.equalsIgnoreCase(s61) 比较是否相同但是不区分大小写
s7.compareTo(s71) 比较有多少个数不相同  s7所有加起来的ask码值-s71所有加起来的ask码值 返回askll码值
s9.contains(s91);//判断s9中是否包含s91的这个字符串  true
String s81=s8.substring(2);//取出从第2个之后开始的东西 从0开始取出>> 及解决方法
System.out.println(s10.indexOf(s101)); //返回索引到的位置从 下标0开始  找不到返回-1
System.out.println(s10.lastIndexOf("ab")); //返向查找
u1.replace('山','中'); //吧所有的山换成中支持换多个字符
//正则 boolean u1=u2.matches("0512-\\d{7,8}"); //判断是否是0512开头并且有7位 返回true或者flase

String 类:string转char
String u2="abc123";
char[] u21=u2.toCharArray(); //吧所有的值全部复制给u21数组
System.out.println(u21[0]);

String 类:char转string
char[] u31=new char[]{'1','2','a','b','c'};
String u3=new String(u31); //吧char类型所有东西全部放到string类型里面
System.out.println(u3);

//        String转成int类型
int zhuAn=Integer.parseInt(ab); //parseint 类型转换
}

StringBuilder和StringBuider 的函数: 增删改查

     StringBuilder st=new StringBuilder(40); //设置默认初始值字符串长度为40
st.append("niha1o"); //追加在后面添加  增
st.delete(0,2);//删除下标0到2的值  删
st.replace(4,6,"a"); //在4，7位置改成a  改
st.charAt(12); //查询位置为12后面的
st.insert(12,"你好");// 在12位后插入数据 插
st.length(); //返回数组里面存储的值的长度  不是数组的长度
st.setCharAt(4,'a'); // 在4的位置修改一个字符
int a=st.indexOf("iha1o"); //查找这句话在此文章中出现的位置返回下标i所在的位置

StringBuilder和StringBuider 的函数:区别
* String  //一个不可改变的字符序列
* Stringbuffer  //是一个线程安全的线程安全  因为线程安全所以效率低一些   一般用来用存在多线程使用
* StringBuilder   //是一个线程不安全的    所以效率高一点   一般用来写不存在多线程的时候用
*
*如果需要频繁修改就不用string
*
* stringbuffer和stringbuilder 默认数组长度都是16  vait【16】
*
* 如果超过16那么扩容的是原来的2倍+2，并且吧该值赋值给新的数组
*
*
* append()//添加
*
* 如果已知长度推荐使用  StringBuilder(40);以免后面还需要重新赋值给新的数组
*
* 相同的 ：底层都是使用char类型存储
*

System类:
String 系统版本=System.getProperty("oc.name"); //win7
String 电脑现在使用的用户名=System.getProperty("user.name");//Administrator
System.exit(0);  //也可以强制性结束 如果为1就是异常退出

BIginttegr类:
如果数很大比如高精度就使用BigInteger类
BigInteger  b1=new BigInteger("123") //需要计算的数

        add(BigInteger val)   返回当前大整数对象与参数指定的大整数对象的和
subtract(BigInteger val)  返回当前大整数对象与参数指定的大整数对象的差
multiply(BigInteger val)   返回当前大整数对象与参数指定的大整数对象的积
devide(BigInteger val)    返回当前大整数对象与参数指定的大整数对象的商
remainder(BigInteger val)    返回当前大整数对象与参数指定的大整数对象的余
compareTo(BigInteger val)    返回当前大整数对象与参数指定的大整数对象的比较结果，返回值是1、-1、0，分别表示当前大整数对象大于、小于或等于参数指定的大整数。
BigInteger abs()    返回当前大整数对象的绝对值
BigInteger pow(int exponent)   返回当前大整数对象的exponent次幂。
String toString()    返回当前当前大整数对象十进制的字符串表示。
String toString(int p)   返回当前大整数对象p进制的字符串表示。

枚举类：
enum  //定义枚举类 可以实现接口但是不可以继承父类
{
枚举类_1(1,2),
枚举类_2(10,20)； //逗号继续，分号结束 都是  public static final 类型的 
}
枚举类使用 mei=枚举类使用.枚举类_1; //调用枚举类
枚举类使用[] a=枚举类使用.values(); //使用values类枚举类
枚举类使用 a1=枚举类使用.valueOf("枚举类_1"); //通过名字查找对象

x1.shutdown(); //关闭线程池的连接

集合：Collection接口
Collection c1=new ArrayList(); //创建一个可变数组
List和set都属于Collection接口里面的        *Map属于另一个接口
Collection有一个工具类叫Collections 比他多一个s 里面有提供很多方法如吧线程改成安全的

集合:ArrayList可变数组:
List  list1=new ArrayList();  //    Arraylist 初始化长度为10  后面长度不够 默认为扩容1.5倍 同时将数组复制到新的数组中 介意开发中使用带参的构造器确认数组长度
//    8.0版本之后刚刚创建开始是 空{}  在add操作之后才开始创建 长度为10的操作 这样子可以节约内存
list1.add(a); //添加
list.add(1,"我好"); //在指定下标插入  
list.addAll(list1);  //吧另一个可变数组添加到此数组后面

  list1.remove(2);//移除指定下标
list1.remove("你好");//移除指定元素
list1.removeAll(coll); //查找2个重复的如果相同就不输入相同的 

  list1.set(1, "你好"); //修改  指定坐标的值
list1.get(1) //查询  下标为1的值

  int a= list1.indexOf("你好") //查询"你好"对于的下标  如果不存在返回-1
int a=list.lastIndexOf("123"); //查找"123"最后一次出现的位置  如果不存在返回-1
List l1=list.subList(0,3);//查找获取下标0到3位置下的值

  list1.retainAll(c2); //查找相同的,输出出来 并且修改完成之后list1就为相同的了
list1.removeAll(c1); //查找2个重复的如果相同就不输入相同的  [你好, 4]  并且修改完成之后list1就为重复的了

  Object[] objects = list1.toArray(); //集合转换成数组
List list= Arrays.asList(new Integer[]{123,123}); //吧数组转换成集合

iterator()//便利操作 每次调他都会返回迭代器开头  -> Iterator 迭代器，再次调用他将会吧指针返回到初始化位置0      
{
-> Iterator iterator = list.iterator(); //集合的便利迭代器为0
while(iterator.hasNext()) //判断hasNext元素指针下一个是否有元素
{
//iterator = list1.iterator(); //返回到指针开始
System.out.println(iterator.next()); //输出元素   next 是指针下移
iterator.remove();//删除元素
}
}

集合:增加for循环
{
list1.forEach(System.out::println); //新的遍历方法
for(Object O:list1)
{
System.out.println(O);    
}
}

集合:LinkedList 无序可变数组 //底层采用的是双向链表结构 频繁的插入和删除调用它最好  因为下面需要频繁的操作指针所以只需要添加不需要频繁修改 的话使用ArrayList比较快
List list=new LinkedList();
for (Object e:list)  //增强for循环 前面是类型后面是需要循环的值

Set接口:三类
Set s1=new HashSet();   //按照类型来排序
Set s1=new LinkedHashSet(); //按照输入顺序排序
Set s1=new TreeSet(); //按照输入顺序排序 ,根据第一个类型判别后面所有类型
不可重复:是指地址值不可重复  如果有重复只输出一次
无序性不等于随机性  存储的数据在地址也中并非按照索引顺序添加的
底层采用链表加数组 通过哈希表  先通过计算哈希值判断位置然后找到数组位置 位置上如果没有值就直接放进去
如果有值哈希值相同就比较equas值， 如果值也相同就残忍抛弃，如果不相同就添加上用链表连接，下一个值进来的时候有会判断上一个和本值是否不一样如果不一样也放进来

Map接口：实现类
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。
HashMap 是无序的，即不会记录插入的顺序。
HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

             Map map1=new HashMap(); //主要实现类，线程不安全 效率高 可以存储null的key和value   底层采用数组加链表（jdk7）  jdk8之后采用数组+链表+红黑树
Map map2=new LinkedHashMap();//保证遍历map元素时key 按照顺序执行遍历， 底层有《双向链表》   对于频繁的遍历操作 效率高于HashMap
Map map3=new TreeMap();//保证按照添加发的key——value 对于进行排序 实现排序遍历  底层使用红黑树
Map map3=new Hashtable();//废弃方法    //Properties 子类  常用来处理配置文件 底层key value都是string类型的   //古老实现类线程不安全  不可以存储null的key和value

Map接口：方法
map1.put("AA",111);//添加
map1.put("AA",444); //如果key一样那么修改后面对于的值为444

map1.remove("AA");  //移除所对应的key和value
Object var=map1.remove("BB");  //接收到BB所对应的value, 不存在放回null

System.out.println(map1.get("AA")); //返回key“AA”所对应的value 查不到返回null  //查询
System.out.println(map1.size()); //返回key“AA”所对应的value   

 //遍历
Set set = map1.keySet(); //对于的所有key值
Collection values = map1.values(); //对应所有的value值
Set set2 = map1.entrySet();//对应的所有的set和对应的vlue值

容器:Collections工具类
Collections.reverse(li); //反转数组
Collections.sort(li);//对集合进行自然排序
System.out.println(Collections.max(li));//返回元素中最大的值
System.out.println(Collections.frequency(li,21)); //返回元素中21出现的次数

        // Collections.synchronizedXXXX(li)  返回一个线程安全的对象;
List list = Collections.synchronizedList(li);  //返回一个List安全对象
Set set=Collections.synchronizedSet(l2); //返回一个Set安全对象
Map map=Collections.synchronizedMap(l3); //返回一个Map安全对象

泛型:
java 中泛型标记符：
•    E - Element (在集合中使用，因为集合中存放的是元素)
•    T - Type（Java 类）
•    K - Key（键）
•    V - Value（值）
•    N - Number（数值类型）
•    ？ - 表示不确定的 java 类型
Fanxing<Integer> fx=new  Fanxing<>(); //如果前面声明了类型后面可以不需要写
List<?> list=new ArrayList<>(); //使用通配符的话就不能向其内部添加数据,只可以直接赋值进去
<E> void 泛型方法 (E next) {  }//泛型方法,不太确认的类型就可以使用泛型方法
T t1[]= (T[]) new Object[10];   //定义泛型数组 

     List<? extends l1父 > b1=null;   //  不可以比此类型大 但是可以等于此类型  <=
List<? super l1父 > b2=null;      //  不可以比此类小 ,但是可以比此类范围大 >=

Json: 
JSONObject js=new JSONObject();  //json格式
js.fluentPut("账号","123"); //读取进去值,前面是名字后面是存储的值

       JSONObject js=new JSONObject().parseObject(js1); //吧JSon格式放进去
String a=js.getString("账号");//读取string类型的
int a1=js.getIntValue("密码");//读取int类型的

IO流:文件操作:三种路径存储方式
File f1=new File("hello.txt");//区域路径
File f2=new File("C:\\Users\\Desktop\\IO","hello.txt"); //绝对路径
File f3=new File(f1,"hello.txt");//带前面值的路径

文件操作:常用函数
f1.getAbsolutePath();//获取绝对路径
f1.getPath();//获取相对路径
f1.getName();//获取名称
f1.getParent();//获取上层目录路径 无返回null
f1.length();获取文件长度(字节数)
f1.lastModified();//获取最后修改时间,毫秒值

    获取路径:
String[] list = f1.list(); //获取该目录下的所有文件
File[] file=f1.listFiles();//获取指定目录下的所有文件目录

       FileSystemView fsv = FileSystemView.getFileSystemView();
File com=fsv.getHomeDirectory();    //获取桌面路径

    bool类型的:
f1.isDirectory();//判断是否为文件目录(就是里面还有值)
f1.isFile() ;// 判断是否是文件
f1.exists(); //判断文件是否存在
f1.canRead(); //判断是否可读
f1.canWrite(); //判断是否可写
f1.isHidden(); //判断是否隐藏

文件的创建:
f1.mkdir();//创建文件夹如果文件夹存在就不创建
f2.mkdirs();//创建文件夹如果文件夹不存在就不创建 如果路径不存在就创造路径

IO流:字符流读取操作
FileReader f1=new FileReader("C:\\Users\\hbl\\Desktop\\lo流\\tt1.txt");//类名
char[] ch=new char[5];
int in;
while((in=f1.read(ch))!=-1)//字符读取并且给ch数组
String a=new String(ch,0,in); //输出

                 写入:
FileWriter f1=new FileWriter("C:\\Users\\hbl\\Desktop\\lo流\\tt1.txt",true); 
//第2个如果为true那么就是往后追加 如果为flase就覆盖着写 写出的时候不存在会自动创建
f1.write("你好啊!\n");//写入

IO流:字符缓冲流读取操作
FileReader cin=new FileReader("C:\\Users\\hbl\\Desktop\\lo流\\tt1.txt");
FileWriter cot=new FileWriter("C:\\Users\\hbl\\Desktop\\lo流\\ff2.txt");

        BufferedReader b1=new BufferedReader(cin);
BufferedWriter b2=new BufferedWriter(cot);

int a;
String a1;
while ((a1=b1.readLine())!=null) //一下获取一行
{b2.write(a1);}//吧b1的一行给b2存储进去

IO流:字节流读取操作
FileInputStream fl1=new FileInputStream(f1); //字节输入
FileOutputStream fl2=new FileOutputStream(f2); //字节输出

     byte[] b1=new byte[5];//用来存储的数组
int a;//用来查找第几位的数
while ((a=fl1.read(b1))!=-1)//复制f1中的给f2
{fl2.write(b1,0,a);} //复制过去值

     for(int i=0;i<a;i++)//加一个密码操作 ,再次运行就可以解密
{ b[i]= (byte) (b[i]^5);}

IO流:字节流的缓冲流
FileInputStream cin=new FileInputStream(f1);
FileOutputStream cout=new FileOutputStream(f2,true);
BufferedInputStream cin1=new BufferedInputStream(cin); //需要输出的缓冲流
BufferedOutputStream cout1=new BufferedOutputStream(cout);//需要被读取的缓冲流

IO流:[>字节流转字符流
FileInputStream f1=new FileInputStream("C:\\Users\\hbl\\Desktop\\lo流\\ff2.txt");
InputStreamReader n1=new InputStreamReader(f1,"UTF-8"); // 默认字符为系统自己设置的    字节转字符流

      int a;
char[] c1=new char[1024]; //用字节存储
while ((a=n1.read(c1))!=-1    )
{ String a1=new String(c1,0,a);}

IO流:[>字符流转字节流
FileInputStream f1=new FileInputStream("C:\\Users\\hbl\\Desktop\\lo流\\ff2.txt");
FileOutputStream f2=new FileOutputStream("C:\\Users\\hbl\\Desktop\\lo流\\ff2_xg.txt");

        InputStreamReader cin=new InputStreamReader(f1,"utf-8"); //以utf-8的方式读入
OutputStreamWriter cout=new OutputStreamWriter(f2,"gbk"); //以gbk的方式复制
char[] c1=new char[1024];
int a;
while ((a=cin.read(c1))!=-1)
{
cout.write(c1,0,a);//读取给选择的文件
}

IO流关闭:  b1.close(); //使用完成之后必须得关闭