java基础小总结

@基础知识点总结

   //List转换为Array
    List<String> list=new ArrayList<String>();
    String[] countries=list.toArray(new String[list.size()]);
   //Array转换为List
    String[] countrie={};
    List list1= Arrays.asList(countrie);
   
    //Map转换为List
    List<value> list2=new ArrayList<value>(map.value());
    //Array转换为set
    String[] countri={};
    Set<String> set=new HashSet<String>(Arrays.asList(countri));
 
    //Map转换为set
    Map<Integer,String> sourceMap=createMap();
    Set<String>targetset=new HashSet<>(sourceMap.values());

    //Set转List
    String[] staffs=new String[]{};
    Set<String>staffsset=new HashSet<>(Arrays.asList(staffs));
    List<String>result=new ArrayList<>(staffsset);
  
    //List转换成为数组1
    List list2=new ArrayList();
    final int size=list2.size();
    String[] arr=list.toArray(new String[size]);
 
    //List转换成为数组2
    String[] userid={};
    List<String>userList=new ArrayList<>();
    Collections.addAll(userList,userid);

    //数组转换成为List1
    String[] arr1=new String[]{};
    List list3=Arrays.asList(arr1);
   
    //数组转换成为List2
    ArrayList<String>arrayList=new ArrayList<>(arr1.length);
    Collections.addAll(arrayList,arr1);
    //数组转换Set
    String[] staff=new String[]{};
    Set<String>staffSet=new HashSet<>(Arrays.asList(staff));
   
    //List转Set
    String[] staf=new String[]{};
    List stafList=Arrays.asList(staf);
    Set result1=new HashSet(stafList);
  
    //Calender转换String
    Calendar calendar=Calendar.getInstance();
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
    String datestr=sdf.format(calendar.getTime());

    //String转化Calendar
    String str="2018-12-12";
    SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
    Date date=sdf1.parse(str);
    Calendar calendar1=calendar.getInstance();
    calendar1.setTime(date);

    //Date转化String
    SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd");
    String datestr1=sdf2.format(new Date());
 
    //String转换Date
    String str1="2018-12-13";
    SimpleDateFormat sdf3=new SimpleDateFormat("yyyy-MM-dd");
    Date birthday=sdf3.parse(str1);
 
    //Date转化Calendar
    Calendar calendar2=Calendar.getInstance();
    calendar2.setTime(new Date());

    //Calendar转化Date
    Calendar calendar3=Calendar.getInstance();
    Date date1=calendar3.getTime();

链表：

将每个对象存放在独立的节点中，每个节点还存放着序列中下一个节点的引用，在java中，
 所有链表都是双向链表——————即每个节点还存放着上一个节点的引用

映射表的映射：

 映射表有三个视图，分别是：键集、值集合和键/值对集。
    Set<K> keySet()
    Collection<K> values()
    Set<Map.Entry<K,V>> entrySet()

抽象类与接口：

抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

=与==区别：

=是赋值运算符，用于为变量或常量赋值，而==则表示相等关系的关系运算符

反射机制：
面向接口的程序开发：灵活性高，声明谁就调用谁定义的方法，方法的实现是对应的实现类
在程序的运行期修改代码：
class的作用：可以在代码中不引用某各类，却可以使用这个类
获取class的三种方式：

   1：通过实体类的对象，调用getclass方法
                  2：类名.class
                  3: class.forName("");会抛出异常

反射调用方法：
1.获取构造方法：
1).批量的方法：

  public Constructor[] getConstructors()：所有"公有的"构造方法
  public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)   

                2).获取单个的方法，并调用：

   public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
   public Constructor getDeclaredConstructor(Class...parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
调用构造方法：
     Constructor-->newInstance(Object... initargs)

                2) newInstance是 Constructor类的方法（管理构造函数的类）
                api的解释为：
                newInstance(Object... initargs)
                           使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，
                           并用指定的初始化参数初始化该实例。
                它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用

反射获取成员变量并调用：
1.批量的

   1).Field[] getFields():获取所有的"公有字段"
   2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；

2.获取单个的：

 1).public Field getField(String fieldName):获取某个"公有的"字段；
 2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的) 

   设置字段的值：
        Field --> public void set(Object obj,Object value):
               参数说明：
               1.obj:要设置的字段所在的对象；
               2.value:要为字段设置的值；

反射获取成员方法并调用：
1.批量的：

  public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
  public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)

2.获取单个的：

 public Method getMethod(String name,Class<?>... parameterTypes):
               参数：
                   name : 方法名；
                   Class ... : 形参的Class类型对象
   public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 
调用方法：
   Method --> public Object invoke(Object obj,Object... args):
               参数说明：
               obj : 要调用方法的对象；
               args:调用方式时所传递的实参；

反射机制应用的场景：

 1：逆向代码，例如反编译
 2：与注解相结合的框架，例如Retrofit
 3：单纯的反射机制应用框架
 4；动态生成的框架

栈：主要是用于实现堆栈数据结构的存储方式（先进后出）push（）压栈pop（）栈中弹出（弹栈）
队列：主要是为了可以使用LinkedList模拟队列数据结构的存储方式（先进先出）offer（）poll（）
HashMap和Hashtable的6个区别：

  1：线程安全：Hashtable是线程安全的HashMap不是线程安全的
  2：性能优劣：Hashtable性能较差，HashMap性能较好使用更广，因为Hashtable线程安全，每个方法都要阻塞其他线程
  3：Null：Hashtable是不允许键或值为null的，HashMap的键值则都可以为Null
  4：实现方法：Hashtable继承Dictionary类，而HashMap继承的是AbstractMap类
  5：容量扩容：HashMap的初始容量为16，Hashtable的初始容量为11，两者的负载因子默认都是0.75，当现有容量       大于总容量*负载因子时，HashMap扩容规则为当前容量易翻倍，Hashtable扩容规则为当前容量翻倍+1
  6：迭代器：HashMap中的Iterator迭代器是fail-fast的，而Hashtable的Enumerator不是fail-fast的，
             所以当其他线程改变了HashMap的结构；如：增加，删除元素将会抛出ConcurrentMOdificationExceprtion异常，
             而Hashtable则不会

Hashtable性能差那Hashtable的替代品：

 ConcurrentHashMap，用来保证线程安全性，提升Map集合的并发效率
      ConcurrentHashMap使用了Segment的概念，默认为16个Segment，Segment里面依然还是数组+链表的数据结构，
      相当于给HashMap分桶处理，因每次只会锁住其中一个Segment，所以性能非常好
      jdk1.8中：ConcurrentHashMap抛弃了Segment+数组+单向链表的设计，
      改为了和HashMap同样的数组+单向链表+红黑树的数据结构，
      同时ConcurrentHashMap使用了CAS算法+Synchronized来保证集合的线程安全性，
      ConcurrentHashMap相当于一性能安全的HashMap

对象序列化：将对象Object转换为byte序列，反之叫做对象的反序列化
序列化流是过滤流：

 ObjectOutputStream方法writeObject（）对象的序列化
  ObjectInputStream方法readObject（）对象的反序列化
  对象必须实现序列化接口serializable才能进行序列化，否则将出现不能序列化的异常，
  serializable是一个空的接口，没有任何方法，仅作为序列化的一个标识

流的分类：

  字节流：处理字节或二进制对象，输入InputStream，输出OutputStream
  字符流：处理字符或字符串（一个字符占两个字节）输入Reader，输出writer
  字节流操作对象：a.纯文本 b.需要查指定的编码表
  字符流操作对象：a.图像，音频等多媒体文件 b.无需查询指定编码表

字节流与字符流的相互转换：

 a：InputStreamReader是字节流通向字符流当前桥梁
 b：从字符流到字节流：可以从字符流中获取char[]数组，转换为String，然后调用String的API函数getBytes（）
          获取到byte[]然后可以通过ByteArrayInputStream，ByteArrqayInputStream来实现到字节流的转换

session具有的特点：

   1：session中的数据保存在服务器端
   2: session中可以存储任意类型的数据
   3：session默认的生命周期是30分钟，可以手动设置更长或更短的时间

session的生命周期：

session中的数据保存在服务器端，在客服端需要的时候创建session，
       在客户端不需要的时候销毁session使它不再占用服务器内存

String类中支持正则表达式的方法：

matches（）匹配正则表达式replaceFirst
          slipt（）根据正则表达式拆分字符串
          replaceAll（）将满足正则表达式的部分已给定字符串替换       

ArrayList和Vector区别：

ArrayList是非线程安全的，效率高，Vector是基于线程安全的效率低
LinkedList低层链表实现，增删快查询慢

线程：
创建线程的两种方式：

       1：自定义一个类继承Thread，2：实现Runnable接口
                          同步的实现方面有两种，分别是synchronized,wait与notify
两种创建线程的区别：
            继承Thread的好处：可以直接使用Thread类中的方法代码简单
                        弊端：如果已经有了父类，就不能用这种方法
            实现Runnable接口的好处：即使自己定义的线程类有了父类，也没关系，因为父类可以实现接口。接口可多实现
                              弊端：不能直接使用Thread中的方法，需要先获取到线程对象后，才能得到Thread的方法代码复杂

wait和sleep区别：

  1：sleep是Thread中的静态方法，wait是Object中的方法
  2：sleep方法可以在任意地方调用，wait在同步代码块或同步方法中调用
  3：sleep方法必须传参数，时间结束自然醒，wait可传参可不传参，不传参马上等待传承是指定时间结束后进入等待

wait和notify以及notifyAll方法是谁的方法：
他们都是Object的方法，因为调用wait和notity方法要使用锁对象调用，锁对象可以是任意对象，
所以要将这些方法放在Object类中
heap和stack区别：

 栈是一种线形集合，其添加和删除元素的操作应在同一段完成，栈先进后出的方式进行处理
 堆是栈的一个组合元素

Iterator和ListIterator的区别：

   Iterator可用来遍历List和Set集合，ListIterator只能遍历List
        Iterator对集合只能是前向遍历，ListIterator既能前向也可后向
        ListIterator实现了Iterator接口，并包含其他功能

动态加载与静态加载的区别:

  new创建对象的方式称为静态加载，而使用Class.forName（""）称为动态加载，
        区别：
            静态加载的类的程序在编译时期加载（必须存在），而静态加载的类在编译时期可以缺席（源程序不必存在）法知识。