javase笔记

                                          




                                                            2016.10.17
1、JDK(java development kit)>JRE(java runtime environment >,JVM(java virtual machine)

2、JVM就是虚拟机相当于java中bin

   jvm会退出的几种情况：
 1）、程序正常执行结束
 2）、使用System.exit(0)方法
 3）、出现异常，没有捕获异常
 4）、平台强制结束jvm进程

                                      2016.10.20
A  a=new  A();
//用new来调用A类的构造器，new 就是在堆中开辟一个新的内存地址，返回一个A的对象或实例，并将实例或对象赋值给变量a，

  可以用a来调用A类中的属性和方法
例如：

Person p=new Person(“瓜码”,120);

-->>person p;

-->>P=new Person(“瓜码”，120);

用new来调用person类中的构造器person（）；并返回person，赋值给p，p可以调用person类里面的方法，属性等。

String str01=p.getMell();

注：因为str01是String类型，所以说明方法getMell()的返回值是String

3、List集合有顺序，Set集合无排列顺序并且不能有重复元素，即不能有相同的。

哈希码值  hashCode  equals来判断值和对象是否相等？

4.数组和字符串比较

基本数据类型：“==”是比较两个对象的值是否相等，引用型数据类型是比较两个对象是否相等

String str01=new String(“李白”);

String str02=new String(“李白”);

System.out.println(str01.equals(str02));

//输出结果为true！


5.String str=scan.next();

 Int i=scan.nextInt()；

String str02=scan.nextLine();//可以识别空格键

6.求多位数中的个位，十位，百位，可以用下面方法

  Int  a,b,c
  d=543;
百位：a=d/100
十位：b=(d-a*100)/10
各位：c=d-a*100-b*10

For(int i=0;i<54;i++){} i如果想把i导入到数组arr[]中是不可以的，i只是索引，但是可以用for循环遍历数组，关键在于i<arr.length;

7、如果第一个类中有含有参数的构造器，想在第二个类中调用，就必须给这构造器赋值，除非再在第一个类中写一个没有参数的构造器。

8、For循环里面可以写多个变量

For(int a,b,c;a<10&&b<3&&c<5;...){}

9、random():[0,1)
10、利用好break,continue,return

   Break:整个循环
Continue:结束当前循环
Return：结束整个方法

11、保留两位小数

Import  java.text.DecimalFormat;
DecimalFormat df=new DecimalFormat(“#.00”);
Double d=25.0256;
System.out.println(df.format(d));
12.冒泡排序：
public static void main(String[] args){
        int[] arr={48, 11, -12, 545, 66, 88, 99, 66, 32};
        for(int i=0; i<arr.length-1; i++){
            for(int j=0; j<arr.length-1; j++){
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
        }
          
        System.out.print("{");
        for(int x=0; x<arr.length; x++){
            if(x!=arr.length-1){
                System.out.print(arr[x]+",");
            }else{
                System.out.print(arr[x]+"}");
           }
    }
}
}
13.Ctrl+鼠标左键见目标文字具体情况

14.This 表示调用类中属性或对象或方法，有static 修饰的不能用this调用

15.成员变量和局部变量名称可以相同

16.数组的长度arr.length;字符串的长度str.length();

17.访问修饰符：由default(缺省)修饰的类，只能被相同包下的类访问，如Person用了default修饰Test类就不能

   访问Person，protected修饰类中的成员变量供子类修改

顶级类只能用Public和缺省

父类 a= new 子类   由父类编译，由子类运行，调用的是子类里面的东西

父类派生子类的条件：1）、保证子类是一个特殊的父类

                   2）、子类需要增加额外的属性

                   3）、子类需要有自己独特的行为方式

 创建子类时，系统会隐式的创建一个父类的对象
 
18、            int i = 5;
        Object o = 5;
        String str04 = o.toString();
        String str01 = i + ""; // 方法一：直接加空字符串
        String str02 = String.valueOf(i);// 方法二：调用valueOf()方法
        String str03 = ((Object) i).toString();// 方法三：强制转换成Object然后调用toString()方法
        System.out.println(str01);
        System.out.println(str02);
        System.out.println(str03);
        // 引用数据类型转换成基本数据类型

//        总共一种方法

        String str = "88";
        int i01 = Integer.parseInt(str);
        double d01 = Double.parseDouble(str);
        System.out.println(i01);
        System.out.println(d01);
19、栈内存：变量（基本、引用） 堆内存：new+构造器

   1).在堆中new了一个新的对象或者数组，在栈中可以定义一个特殊的变量，让这个栈中的变量的取值为这个堆中的首地址，
     栈中的变量就成了数组或者变量的引用变量，以后就可以用引用变量来访问堆中的数组或者对象。
  2）.堆的优点：动态分配内存大小，垃圾回收器来回收垃圾
          缺点：存取速度慢
  3）.栈的优点：存取速度快，可以共享数据
           缺点：数据和生存期必须确定，缺乏灵活性

20.trim 消除空格 System.out.println(str.trim().length())

21.不要把相同的代码书写两次！
 public Test(String name, int age){
          this.name=name;
          this.age=age;
}
    public Test(String name, int age,double weight){
          this(name,age);
}
22.子类继承父类的方法应遵循“两同两小一大”

  1）.两同：方法名相同、形参列表相同；

  2）.两小：子类返回值类型和抛出异常类型要比父类小或者相等；

  3）.一大：子类的访问权限比父类大或者相等

                                          2016.11.1
一、抽象类(模板)
 1、抽象类可以没有抽象方法，但是有抽象方法的类必须定义为抽象类
 2、抽象类中可以定义属性、方法、构造器、内部类、枚举，但是不能使用new调用构造器，抽象类不能被实例化

 3、抽象类中的继承关系：子类必须继承父类中的全部方法；若子类没有完全继承抽象父类的方法，

    则子类需要用abstract来修饰，但是这种方式尽量不要用。

 4、有static修饰的父类或父类方法不能被子类继承（不能被子类重写），但是能够在子类中使用。

二、接口（interface）：接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，

  因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

 1、接口只有抽象方法，没有方法体

 2、修饰符 interface 接口名{

    // 零到多个常量     public static final int a=5;可以直接写成 int a=5;

     //零到多个抽象方法
}    
 3、 可以实现多个接口：修饰符 class 类名 implements 接口1，接口2，......

     接口本身可以继承多个接口

 4、如果不用public修饰interface，该接口在该包下有效，接口里所有成员默认public修饰

 5、接口里面的方法不能用static修饰

 6、接口体现的是一种规范，对于接口的实现而言，接口规定实现者必须向外界提供哪些方法（以方法的形式调用）

    对于接口的调用者而言，接口规定了调用者可以调用哪些方法，以及如何调用这些服务

    抽象类和接口不一样，作为多个子类的父类，体现的是一种模板思想
  7、抽象类和接口的区别：

      相同点：1）、都不能实例化，用于被其他类实现或者继承；

              

              2）、都可以定义抽象方法，其子类都必须重写这些抽象方法。

       区别： 1）、抽象类有构造方法，接口没有构造方法；

                  抽象类中的构造器不能被继承，只能所以不能被重写，可以被调用

              2）、抽象类可包含普通方法和抽象方法，接口只包含抽象方法（在JDK1.8之后可以定义static静态方法）；

              3）、一个类只继承一个直接父类（可能是抽象类），却可以实现多个接口（接口弥补了java的单继承）

              4）、抽象类不是一个完整的类，需要进一步细化，接口是一种行为规范，是更彻底的抽象。

三、1、随机获取验证码：String str=UUID.randomUUID().toString().substring(0, 5);//前5个

    2、String str="abcdefghijklmnopqrstuvwsyz";
        str+=str.toUpperCase();
        //结果：abcdefghijklmnopqrstuvwsyzABCDEFGHIJKLMNOPQRSTUVWSYZ

       StringBuilder sb= new StringBuilder(5);
        for(int i=0;i<5; i++){
       char c=str.charAt(new Random().nextInt(str.length()));
              sb.append(c);
    }
        System.out .println(sb);
    }//随机生成5位随机数
 
    3、toLocalString()显示当前时间
        Date d = new Date();
        System.out.println(d.toLocaleString());
    4、 DateFormat  df= DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
           System.out.println(df.format(d))
                 
                               2016.11.02
  枚举：构造器只能用private修饰
      可以通过类名.values()来的到类中的枚举；
如：for(Person p:Person.values()){
   System.out.println(p);
}

一、异常
          ArithmeticException 算术异常

          NullPointerException  空指针异常

          ClassCastException   类型强转异常

          NumberFormatException  数字格式化异常

           IndexOutOfBoundsException    索引越界

          ArrayindexOutOfBoundsException   数组越界

              

  1、try{}catch{}    

     try{}finally{}  没有catch捕获，抛出异常，自己不做处理

     try{}catch{}finally{}自身需要处理资源，但最终还是要关闭资源

  2、throw:使用于方法内部，throw new 异常类（异常信息）；终止方法

    throws
     

二、内部类
  1、类的成员：属性、构造器、方法、内部类，包含内部类的类为外部类（为顶级类的成员）

  2、内部类和外部类的定义一样，并且内部类的类名可以用private，非静态内部类可以调用外部类的

     成员变量（因为寄存了一个外部类的对象），因为内部类为外部类的一部分，可以被同级的方法调用

  3、外部类的静态变量，静态代码块不能访问非静态内部类，包括内部类中的变量，创建实例

     静态和非静态成员可以访问静态成员，静态内部类不能访问外部类非静态成员

   //静态内部类可以调用外部类静态成员变量吗？可以

  4、匿名内部类： 类名 a=new 父类构造器("形参声明")|接口{

               类体部分    
              （对于接口）实现抽象方法

}    和类创建对象很相似，但是new 构造器（）跟了花括号{}形成了匿名内部类
    
 


                                2016.11.03
一、枚举：
    1、枚举类：这个类有若干个固定对象，有自己的方法和属性，可以实现一个或者

       多个接口，也有自己的构造器，经常用switch(){}判断  foreach 循环


    2、enum:继承java.lang.Enum

    3、枚举类可以有构造器，但必须用private修饰

二、集合：通常当做存储对象的容器
   1、数组和集合的区别:数组可以存放基本数据类型和对象，集合只能存储对象

   2、两个根接口：Collection、Map
   3、访问List元素根据元素索引访问，访问Set集合元素根据访问元素本身（Set集合中元素不能重复）

      访问Map元素通过每项元素的key来访问value。

   4、List list= new ArrayList();

      list.add();向集合中添加数据;例如：list.add("大头");list.add("小头");list.add("平头");

      list.size();求集合的长度；    例如：System.out.pritnln(list.size());//3

      list.get(i);得到集合索引为i对应的值 ；  System.out.println(list.get(0));//大头

      list.remove();删除集合的元素；

      list.contains(element);是否包含某一个元素

      list.clear();删除所有元素

   5、 Collection cal= new ArrayList();

       Collection的子类是List和Set，Collection类中没有size()、get()、remove(index)的方法，所以不能用

       cal.get()和cal.remove(index)方法

   6、toArray()方法可以把集合转换成数组

   7、iterator循环迭代器,创建的对象cal和iterator绑定后，不能增加元素

      iterator it= cal.iterator

        while(it.hasNext){

         String str=(String)it.next();

        //如果要移除其中一个元素可以用Iterator中的一个方法remove();

        if(str.equal("某个元素")){

             it.remove();
}
      System.out.prtinln(str);
      }
   8、foreach循环中也不能添加和减少元素。

   9、集合转成数组是哈希码值吗？不是

                                2016.11.04



   
一、 有序集合： List list=new ArrayList();
      形式为：[  ]

 1、如果要改写一个类的方法，只需要继承这个类

 2、list.remove(index); 用索引删除元素，返回的是该删除的值,即：Object o= list.remove(2);

    list.remove(element); 删除元素，返回的是boolean,即：boolean b= list.remove(2);

    list.set(index,element); 添加一个索引值为index的element;

    List l=list.subList(1,list.size()-1); 打印从索引值为1到长度-1的数据

 3、循环遍历中迭代器和foreach过程中不能改变这个集合，但是for、while循环中可以添加，删除元素
 
 4、ArrayList 以数组的形式来保存元素，访问、查询的性能较高
    LinkedList  内部是链表式的，插入数据、删除数据性能较高
 

二、 无序集合： Set set = new HashSet();
     形式为：[  ]

 1、无序集合中元素不能重复

 2、HashSet不能保证元素的排列顺序
 
 3、HashSet线程不安全

 4、集合元素可以为null
 
 5、当向HashSet中存入一个元素时，HashSet首先会调用这个对象的HashCode来得到对应的哈希码值，然后根据哈希码值来决定这个元素的位置

   ，若不存在与之相同的哈希码值，就把这个元素添加到这个无序集合中，如果相同就用equals（）方法进行比较，如果为true则不添加，如果为
     false,则添加。
 
     哈希码值不同，对象必定不同；  hascode是增强查找效率的

     哈希码值相同，但是对象不一定相同，要用equals比较

     重写equals值：对象相等，返回true; 返回类型(obj.getClass==类名.class)相同，强转类型；返回的值相同，返回true,否则返回false

     重写hashcode：return name.hashCode;
     

三、Map继承体系   HashMap  Hashtable  属于无序集合,不能添加相同的元素

    功能：存储具有一一映射关系的数据（key,value）  value最好加上引号""
 
    形式为{"","","","",""}

     Map map= new HashMap();
 
  1、添加数据 put();
    map.put("语文",110);
    
    map.put("数学",150);

    map.put("英语",110);
   
    key 不能相等，通过key可以得到value的值

  2、 Set key=map.keySet();返回值为Set

      Set  keySet(): 返回Map中所有key所组成的Set集合
 
    System.out.println(key); 打印出["语文","数学","英语"]

  3、containskey(key);是否被包含某一个key，返回值为boolean类型

  4、Map不能像Collection通过foreach for等方式来循环遍历每个值，但可以通过得到key值，key.get(value);再得到value值
     Map没有iterator()方法，只能将求出key的值再用iterator循环遍历

  5、Set<Map.entry<String,String>> entry= map.entrySet();
   
      Set entrySet():返回Map所有key-value对所组成的Set集合
 
  6、Hashtable  ht = new  Hashtable();

     key值和value值都不能为null，否则在运行时会报错

  7、数组扩容：

        （如果只需要复制数组中一部分元素，我们指定复制的长度，Arrays.copyOf(数组，长度)）

            if(size==arry.length){
          Integer arry=Array.copyOf(arry,arry.length*2);  


     
              int[] arr=new int[3];
        arr[0]=1;
        arr[1]=2;
        arr[2]=3;
        for(int x=0;x<arr.length;x++){
            System.out.println(arr[x]);//1,2,3
        }
    
         arr=Arrays.copyOf(arr, arr.length*2);//原来的长度的2倍
        
         for(int x=0;x<arr.length;x++){
                System.out.println(arr[x]);//1,2,3,0,0,0
            }
     把一个数组装进另外一个数组
     public class Arr_List {

    public static void main(String[] args) {
        int[] arr01={1,2,3,6,5,4,7};
        int[] arr03=new int[2];
        arrcopy(arr01,arr03);
        
        
    }  
     public static void arrcopy(int[]arr01,int[] arr02){

    
      for(int x=0;x<arr01.length;x++){
         if(x<arr02.length){
            
             arr02[x]=arr01[x];
         }else{
            
             arr02=Arrays.copyOf(arr02, arr02.length*2);
              arr02[x]=arr01[x];
            
         }
         System.out.print(arr02[x]+",");
    
        
        
        
    }

    System.out.println("扩大后的数组长度为："+arr02.length);
    
    
     }

}




  8、将数组转化成集合：Arrays.asList()方法
     int[] i={1,2,3,6,5,4,7};
     List list=Arrays.asList(i);
     System.out.println(list.size()+","+list) //打印结果为1,[[I@15db9742]，原因：基本数据类型会被当成个一个变量，而且打印出来的是
                                                  哈希码值
   Integer[] ii={1,2,3,4,5};
   List list=Arrays.asList(ii);
   System.out.println(list.size()+","+list);  //打印结果为5,,[1, 2, 3, 4, 5]，引用类型就是输出里面的元素

    这个方法不能add和remove,因为底层是数组，数组长度是不能变的
 

  9、数组、list、set、Map之间互转
    private static void testMap2List() {  
        
        Map<String, String> map = new HashMap<String, String>();    
        map.put("A", "ABC");    
        map.put("K", "KK");    
        map.put("L", "LV");    
          
        // 将Map Key 转化为List      
        List<String> mapKeyList = new ArrayList<String>(map.keySet());    
        System.out.println("mapKeyList:"+mapKeyList);  
          
        // 将Map value 转化为List      
        List<String> mapValuesList = new ArrayList<String>(map.values());    
        System.out.println("mapValuesList:"+mapValuesList);  
          
    }  
 
    private static void testMap2Set() {  
          
        Map<String, String> map = new HashMap<String, String>();    
        map.put("A", "ABC");    
        map.put("K", "KK");    
        map.put("L", "LV");    
          
        // 将Map 的键转化为Set      
        Set<String> mapKeySet = map.keySet(); 或者
      Set<String> mapValuesSet = new HashSet<String>(map.keySet());      
        System.out.println("mapKeySet:"+mapKeySet);  
          
        // 将Map 的值转化为Set      
        Set<String> mapValuesSet = new HashSet<String>(map.values());    
        System.out.println("mapValuesSet:"+mapValuesSet);  
    }  
 
    private static void testArray2Set() {  
          
        String[] arr = {"AA","BB","DD","CC","BB"};    
          
        //数组-->Set    
        Set<String> set = new HashSet<String>(Arrays.asList(arr));    
        System.out.println(set);    
    }  
 
    private static void testSet2Array() {  
        Set<String> set = new HashSet<String>();  
        set.add("AA");  
        set.add("BB");  
        set.add("CC");  
          
        String[] arr = new String[set.size()];    
        //Set-->数组    
        set.toArray(arr);   
        System.out.println(Arrays.toString(arr));    
    }  
 
    private static void testList2Set() {  
            
        List<String> list = new ArrayList<String>();  
        list.add("ABC");  
        list.add("EFG");  
        list.add("LMN");  
        list.add("LMN");  
          
        //List-->Set  
        Set<String> listSet = new HashSet<String>(list);  
        System.out.println(listSet);  
    }  
 
    private static void testSet2List() {  
           
        Set<String> set = new HashSet<String>();  
        set.add("AA");  
        set.add("BB");  
        set.add("CC");  
          
        //Set --> List  
        List<String> setList = new ArrayList<String>(set);  
        System.out.println(setList);    
    }  
 
    private static void testList2Array() {  
        //List-->数组    
        List<String> list = new ArrayList<String>();    
        list.add("AA");    
        list.add("BB");    
        list.add("CC");    
        Object[] objects = list.toArray();//返回Object数组,需要遍历才能得到里面的值    
        System.out.println("objects:"+Arrays.toString(objects));    
          
        String[] arr = new String[list.size()];    
        list.toArray(arr);//将转化后的数组放入已经创建好的对象中    
        System.out.println("strings1:"+Arrays.toString(arr));    
    }  
      
    private static void testArray2List() {  
        //数组-->List    
        String[] ss = {"JJ","KK"};    
        List<String> list1 = Arrays.asList(ss);    
        List<String> list2 = Arrays.asList("AAA","BBB");    
        System.out.println(list1);    
        System.out.println(list2);    
    }  
         
   Collection用for循环：先把Collection转换成list
       Collection<String> c= new ArrayList();
                  c.add("你妹");
                  c.add("干嘛");
                  c.add("喊你");
                  c.add("你啥");
                  c.add("呵呵");
                  c.add("逗");
 List<String> list= new ArrayList<String>(c);
                 for(int i=0;i<c.size();i++){
                    System.out.println(list.get(i));
                 }




  public class Sort {//可以把set集合排序

    public static void main(String[] args) {
    
        Set<Integer> ll= new HashSet<Integer>();
        
        ll.add(11);
        ll.add(33);
        ll.add(2);
        ll.add(44);
        SortedSet<Integer> st= new TreeSet<Integer>(ll);
        System.out.println(st);
            }  

    }//[2, 11, 33, 44]


                                        2016.11.07
 
一、泛型：<>
     规定向集合里添加什么类型的元素  

二、异常处理：

  1、异常处理可以提高程序的健壮性       

  2、分为两种：Error      Exception  -->RuntimeException    运行时异常
                                    -->IOException         输出流异常（编译异常）
                                    -->SQLException        数据库异常（编译异常）

    1)、Error:这种错指的是系统崩溃、虚拟机出错、动态链接失败，这种错误不可恢复不可以捕获
    2)、Exception: 语法错误或者语义错误，程序员能够处理
  3、try{..}catch(){..}       printStackTrace()              get.message()

  4、捕获后不影响后面程序的执行

  5、Exception对应catch应该放在所有catch块后面，小异常在前面，大异常在后面
 
  6、finally比return的优先级更高，会先执行finally里面的代码再执行return
 
  7、System.exit();关闭虚拟机  在finally前面可以让finally不执行

  8、使用throws一般在方法名后面抛出，但是在main方法中必须解决，否则会直接抛给虚拟机导致程序崩溃
 
  9、手动抛异常throw

                                     2016.11.08
 
                                 }

  一、IO流    input output  

     1）、字节流、字符流

     2）、数据都是存放在文件中，操作数据之前得学习操作文件和文件夹，在java中操作文件和文件夹是类File，

     File是java.io包下的，代表与平台无关的操作文件和文件夹的一个类
   
     3）、通过一个文件或者一个文件夹的真实路径（相对路径和绝对路径）来创建抽象路径File对象，优点是可以调用File的方法
 
     4）、可以用“\\”“/”“separator”

     "E：\\e.text"    "E:/e.text"   "E："+ File.separator+"e.text"(这种方法可以跨平台)

       得到当前路径的方法：getAbsolutePath()
     
        判断这个路径的文件是否存在： exists();返回值为boolean类型
           是文件夹isDirectrory()          是文件isFile()

        创建文件：对象.creatNewFile();

     5)、返回最后一个子目录的父目录   对象.getParent()，对象.getName():得到最后一个目录
 
     6)、对象.delete()，删除的文件下面没有子文件可以删除，如果有就无法删除

     7)、对象1.renameTo(对象2)；        用对象2中的路径替代对象1的路径

     8)、list()返回值类型为String[]类型的数组
           
         listFiles()  返回抽象路径名数组，这些路径名全是这个抽象路径中的文件和目录
        
         listFiles(FilenameFilter filter)  满足指定过滤器要求的文件和目录
                                    
              
                                   2016.11.09
一、java IO流
  1）、输入流（进入内存）、输出流（出内存）
 
  2）、InputStream (基类，字节输入流)   Reader(基类，字符输入流)
       OutputStream(基类，字节输出流)   Writer(基类，字符输出流)
       注：记忆方法，想象成大脑，    Reader就是在读取，进入大脑，即输入；
                                Writer就是写出来，从大脑出来，即输出。

  3）、图片、音频、视频通过字节流操作，文本通过字符流操作

  4）、FileWriter(String fileName)          FileWriter(File file)
       FileWriter   节点流，低级流
                 1、如果路径下没有操作文件可以自动创建文件
                 2、文件字符输出流

   5）、FileWriter file = new FileWrite("E:\\works");
 
        file.write("在文本中写东西")  
       // file.flush();  因为流关闭之前会刷新，所以flush可以不要
        file.close();关闭流，关闭之前会刷新。如果要关闭两个以上的流要分开关闭

   6）、用FileWriter ,必须保证父目录存在
 
   7）、字符转换成字符串的方法：
        char[] c = {'1','2','3','4','5','6'};
        for(int i=0;i<c.length;i++){
            //System.out.print(c[i]+"");
        }
        //String str= new String(c);

   8)、fa.write(aa);
 
   
   总结:如果要创建文件夹和文件，创建的方法需要两个形参;例如:test("E:\\work02\\test","a.txt");
        
        一定要记得关闭资源close(),这样才能写入或者输出

                           2016.11.10
一、1、bufferedReader(Reader in);创建一个使用默认大小输入缓存区字符输入流
      bufferedReader(Reader in，int size);创建一个使用指定大小输入缓存区字符输入流
      BufferedWriter(Writer out);创建一个使用默认大小输出缓存区字符输出流
      BufferedWriter(Writer out，int size);创建一个使用指定大小输出缓存区字符输出流

   2、把一个路径下的文件复制到另外一个路径下：
     1）、判断原文件是否存在，如果不存在，直接终止程序  
     2）、判断新路径下的文件的父目录是否存在，如果不存在新建文件夹
     3）、新路径下的文件后缀名是否满足要求，不满足要求不能复制
     
   3、OutputStreamWriter           FileOutputStream
 
   4、GBK 、UTF-8、  NASI(字节、字符串默认)
     GBK一个汉字两个字节、UTF-8一个汉字3个字节
     
     GB2312 默认的是ANSI
 
  5 、ASCII码是美国的自己弄得，一个一节对应一个字符（针对英语）；
      ANSI代表两个字节表示一个字符，是不同国家自行弄得编码的统称，如GB2312是中国的，JIS是日本人的，但是都统称ANSI，但是不同编码之间不能通用。
    
   
 
                          2016.11.11
 
  一、1、字节流：FileInputStream  FileOutputStream

             FileOutputStream   fo= new FileOutputStream (String path,String content);
              
             方法：fo.write(content.getByte("UTF-8"));得到字节编码转换的方法
      2、available() 返回可读字节数数目，返回值为int，如果available（）>0,说明里面还有字节,用于读剩余字节
 
      3、PrintStream ps= new PrintStream(new FileOutputStream(path));
         ps.println(...);
        
         PrintStream和PrintWriter分别属于字节打印流和字符打印流


                         2016.11.14
 一、IO

 1、RandomAccessFile读写文件任意位置
    用法：RandomAccessFile raf= new RandomAccessFile（路径名,模式）
    模式：r:只读  rw,读和写
   
   ；创建其对象raf，然后调用其方法

   getFilePointer();读取字节数
   seek(0);设置文件指针为0
   SkipBytes(12);跳过12个字节，来到12个字节后面
   setLength(long newlength);拿来做文件的断点下载
   RandomAccessFile经常拿来做文件的多线程断点下载

2、管道流：实现两个线程之间的数据交互
   PipeInputStream
   PipeOutputStream
   PipeReader
   PipeWriter
3、复制文件及里面的内容，快捷的方法（Files类）：
        （直接在main里面用就行了）
        String path1 = "E:\\work07\\test\\1.java";
        String path2 = "E:\\work07\\1.java";
  (1)、Files.copy(source,out)；//先有原文件，再写到一个新的路径
       Files.copy(Paths.get(path1), new FileOutputStream(path2));
  (2)、Files.copy(in,target)；//先读原文件，再到一个新的路径
        Files.copy( new FileInputStream(path1),Paths.get(path2));
    
 IO流的总结：
     文件流(重点)：FileInputStream   FileOutputStream    
           FileReader        FileWriter
     缓冲流（重点）：BufferedInputStream   BufferedOutputStream
           BufferedReader      BufferedWriter
     转换流：把字节转换成字符
           InputStreamReader    OutputStreamWriter   
     内存流、顺序流（合并流）
     对象流：（序列化和反序列化Serializable）
           ObjectInputStream
           ObjectFileOutputStream    
     打印流：
            PrintStream
            PrintWriter
     数据流：
            DataInputStream;
            DataOutputStream;
     管道流：实现两个线程之间的数据交互
            PipeInputStream
            PipeOutputStream
            PipeReader
            PipeWriter

 二、网络编程
     计算机网路：地理位置不同、多台计算机、用通信线路连接，实现资源共享和信息传递的计算机系统
     
     网络分层：减少网络设计的复杂性，不同机器上的同等功能层之间采用相同的协议
     
     OSI参考模型（7层）： 1、物理层
                         2、数据链路层
                         3、网络层
                         4、传输层
                         5、会话层
                         6、表示层
                         7、应用层
     TCP/IP分层模型（4层）：
                         1、网络接口
                         2、网络层
                         3、传输层
                         4、应用层

     2、网络编程全部在java.net包里面
     3、网络编程三要素：
       （1）、IP地址
            用InetAddress来表示IP地址：Inet4Address   Inet6Address
         1）、得到IP的方法getByname(IP地址)
            InetAddress ip=InetAddress.getByName("stusd026");
            System.out.println(ip);//stusd026/172.31.83.39
         
               System.out.println(ia.getHostName());//stusd026
           System.out.println(ia.getHostAddress());//172.31.83.39
       （2）、端口(port):物理端口、协议端口
     
        （3）、URI：统一资源标识符
               URL:统一资源定位符
               都表示资源路径，URL范围比URI小

     (4)、encode是编码，decoder是解码
          String str="编码";
 //       使用UTF-8编码
      String urle=URLEncoder.encode(str, "UTF-8");
      System.out.println(urle);
//      使用UTF-8解码
      String urld=URLDecoder.decode(urle, "UTF-8");
      System.out.println(urld);
            
     （5）、传输层协议：TCP UDP
          TCP:面向连接（经历3次握手），传输可靠（保证数据的正确性和先后顺序），用于传输大量数据，速度慢，建立连接需要更多的时间和资源
          UDP：面向非连接，传输不可靠（数据丢失），用于传输少量数据，速度快。
 
      （6）、ServerSocket服务端   Socket客服端

三、反射

 
      Class：类的反射类
      Filed:属性的反射类
      Constructor:构造器的反射类
      Method:方法的反射类


  1、 获得java.util.Date类对象的方法
   1）、使用class属性
            Class<java.util.Date>  claz=java.util.Date.class

   2)、通过对象的getClass的方法来获取，getClass是Object中的方法
            java.util.Date   date=new java.util.Date（）；
            Class<?> claz2=date.getClass();  

  3)、通过Class类中的静态方法forName(String className)
            Class<?> claz3=Class.forName("java.util.Date");
  注：反射中一般用第三种方法





  2、获得构造器和对象的方法
   
        Person p= new Person();  //其中属性有name,age  构造器有无形参和有形参两种，方法有setName(String name);getName();
                                                                                        setAge(int age);getAge();
                                   
        
    Class<Person>    clz=Person.class;//获得类对象字节码
        Constructor<Person> cp=clz.getConstructor();//获得构造器字节码
        cp.newInstance();//获得对象

        Constructor<Person> cp=clz.getConstructor(String.class,int.class);//获得构造器字节码/有参数
        cp.newInstance("黄圣依",23); //获得对象/有参数



   3、获得方法的方法
    
    Method[] md=clz.getMethods();   //获得所有的方法、包括父类
    System.out.println(md.length);    //获得方法的长度
    for(Method mm:md){
        System.out.println(mm);
    }


         Method[] md=clz.getDeclaredMethods();//获得自己的方法，不包括父类
    System.out.println(md.length);
         for(Method mm:md){
        System.out.println(mm);
    }
        
        Method md1=clz.getDeclaredMethod("getAge"); //获得其中一个方法
      System.out.println(md1);

        Method md2=clz.getDeclaredMethod("setName",String.class); //获得由一个String类型的形参的方法
    System.out.println(md2);

        Object pp=md1.invoke(clz.newInstance());//得到方法里面的内容，getAge//对象无形参
    System.out.println(pp);
        Object  pp2=md2.invoke(clz.newInstance(),"黄圣依");////得到setName()方法里面的内容，setName//对象有形参
    System.out.println(pp2);


        Method md3=clz.getDeclaredMethod("test",String.class,int.class);//得到test(String name,int age)方法里面的内容

    md3.setAccessible(true);//若test()方法是private修饰的就用这个方法判断，设置为可访问！
        
          这个setAccessible()很变态的，不管用任何权限修饰符或者用什么方式封装的，只要通过反射机制，调用这个方法，可以访问
           类里面的属性、构造器、方法，但是这个方法确实是需要的，有时需要内部的是怎么样来实现的，总之利大于弊

    Object  pp3=md3.invoke(clz.newInstance(),"黄圣依",22);<= =>Object  pp3=md3.invoke(clz.newInstance(),new  Object{"黄圣依",22)};

        注意：如果方法为静态，需要把clz.newInstance()改为null


    4、获得数组方法里面的内容：

           public void arr(String[] arr){
        System.out.println("这是数组"+Arrays.toString(arr));//Arrays.toString(arr)可以打印出数组
    }
   
 
         1)、基本数据类型的数组：
          Class<Recfectaa>  claz=Recfectaa.class;//Recfectaa为创建的一个类，里面创建的是一个arr的方法，形参为(int[] arr){}
          Method md=claz.getMethod("arr", int[].class);
      System.out.println(md);
      md.invoke(claz.newInstance(),new int[]{22,33,44});

         2）、引用数据类型的数组：new Object{形参}，对应所有类型的形参都可以用
          Method md=claz.getMethod("arr", String[].class);
      System.out.println(md);
      md.invoke(claz.newInstance(),new Object[] {new String[]{"a","b","c"}});//调用方法把实际参数作为Object数组的元素即可


四、多线程
 1）、main方法就是主线程的执行体
 2）、Runable的线程类是Thread；Runable可以让线程实现共享变量，可以让多个线程共享一个数据，只有run方法才能成为线程执行体
 3）、进程：就是正在运行的程序，特点：
                    a.独立性，不允许其他进程进入
                    b.动态性，是活动的指令集合
                    c.并发性,可以和多个进程在单个处理器上并发运行
 4）、线程：每个进程里面有很多执行流，每个执行流都是一条线程，线程是进程的组成部分

                                            2016.12.5
 补充：
1、Random random=new Random();
   int ra=random.nextInt(20);
   System.out.println(ra);
//每次生成的随机数都不一样
                                   
2、Random random=new Random(47);//一个特定的种子，已某个元素为参照
   int ra=random.nextInt(20);
   System.out.println(ra);
//每次生成的随机数都是18，但是再调用一次nextInt（），生成的随机数又不一样

3、四舍五入：Math.round(变量);
    double d=5.8923;
    d=Math.round(d);
    System.out.println(d);




                                       2016.12.09
 



1、Hashtable 不含任何的final方法
  现代java容器库HashMap替代了Hashtable

2、继承和组合都能从现有类型生成新类型，组合一般是将现有类型作为新类型底层实现的一部分加以复用，而继承复用的是接口

3、数组运行速度比集合快

4、abstrac不能和static final private共同存在


5、Dothis ds= new Dothis();   Dothis是外部类 Inner是内部类
        //创建内部类对象的两种方式
  Dothis.Inner in=ds.inner();  //inner 是Dothis的一个方法  public Inner inner(){
                                                         return new Inner();
                                                                   }
        
  Dothis.Inner in2=ds.new Inner();
 
6、String常用的方法：

                     charAt(index):找到指定索引对应的元素
                     toCharArray():将字符串转换成字符数组


                    subString(startIndex,endIndex);截取一段字符串
                    split(String regex):拆分字符串
                    concat(String str):把str字符串连接到指定字符串的尾部

                    endsWith(String suffix):检查字符串是否已指定后缀结束
                    startWith(String suffix):检查字符串是否已指定后缀开始

                    hascode():返回此字符串的哈希码值
                    equals(Object anobject):比较两对象是否相等

                    
                    toLowerCase():把字符串转成小写
                    toUpperCase():将字符串转成大写
                    

                    isEmpty():length为0是返回true
                    length():字符串长度
                    replace(old,new):字符串替换
                    trim():消除空格
                    format():格式化字符串
                   

                    

                   

                    


                                           2016.12.10
  
1、内部类隐式的创建了一个指向外部类的对象，所以我们可以直接调用外部类的对象（重要）。但是有static修饰的内部类就不能调用外部类的对象了

2、如果不需要内部类对象和外部类对象有联系，就把内部类声明为static，这通常称为嵌套类，
  创建嵌套类后的特点（即用static修饰的）：
   1）、要创建嵌套类对象不需要外围类的对象
   2）、不能从嵌套类中访问外部类中非静态对象（即静态不能访问非静态）
3、 如果是普通内部类，那么它里面不能有静态方法和对象

4、为什么要创建内部类？
   因为可以通过内部类来实现多继承，每个内部类都是独立的，不管外围类是否已经继承了某个接口或者实现，对内部类都没有影响
   内部类的特性：
   1）、内部类可以有多个实例，每个实例都有自己的信息，并且其外围类对象的信息相互独立；
   2）、在单个外围类中，内部类可以以不同的方式实现同一个接口，或者继承同一个类；
   3）、创建内部类的对象并不依赖外部类的对象的创建；
   4）外部类是一个独立的个体。
5、Anny$1.class匿名内部类
  A$B.class 内部类

6、queue是按排队顺序来确定对象产生的顺序


7、正则表达式： api文档查找Pattern

                                                       2016.12.12
       
debug调试：
1、设置断点
2、debug as
3、点中要看到的数据，点击右键的wathch
4、f5、f6测试，调试完成之后，按f8，若断点后面没有断点，会跳到下一个断点

JUnit测试：
JUnit称为单元测试，测试对象是项目中类的 方法，用来为程序写测试用例的，
JUnit是一个专业的测试工具（架包），不是javase的一部分，若需要使用，需要导入架包，MyEclipse自带
 
 
@注解--test after     
 public void 方法名(){//没有返回值，不能有形参
 
     调用要测试的方法
    }