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 方法名(){//没有返回值，不能有形参
调用要测试的方法
}
扫一扫
272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
