小笔记-java基础

alt shift r 快速换某块区域的名字，同时更改






1. import java.util.Scanner;
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();nextLine（）；nextDouble（）；
public static void main(string[] args)//主方法
2.int[] arr=new int[length];
int[] arr1=arr//arr==arr1;//共享一段地址
字符串转换为字符数组
char[] arr=s.tochararray();




3.包括基本类和测试类（主方法）
4.static xxx 优先于对象存在，各个对象共享，static成员，赋值一次就可，被所有成员变量共享，共性用static 
可以用 类名.xxx（成员，函数都可以）。能够省内存。static类型函数，只能访问静态成员或者函数。
5.当一个类中的成员函数都是static ，那么就要私有构造函数，目的是防止其他类创建这个类的对象
6.  在类中的前提条件下。构造代码块，是优先于构造函数运行的，，每创建一次都会运行一次。就是一个{}。
7.静态代码块 static{}；随着类的加载而加载， 《》 就  执行一次，而且优先于代码块//
作用：一般用来加载驱动，初始化类的。static 代码块如果在主函数中，那么酒优先于主函数


8.继承extends：子类可以调用父类的方法，父类不可以调用子类的方法
子类只能继承父类的所有的非私有的成员（函数和变量）
子类不能继承父类的构造方法，但是可以通过super关键字取访问父亲的构造方法
子类如果定义了和父类一样的变量，则根据就近原则，采用子类的变量


子类中所有的构造方法默认的都会访问父类的空参的构造方法
子类的构造方法中会默认有个super（）方法，访问父类空参的构造函数
//因此，当你写了一个有参的构造函数的时候你就必须再写一个无参的构造函数，，，系统不会默认给你写出来
如果你没写构造函数，系统会给你默认加一个空参构造函数。
 构造函数是为了初始化类的


继承的时候如果子 父类都有static{} ，，{}，，构造函数，，static和父类，子类一块加载，然后才能运行构造函数，
然后在运行构造代码块，然后才是构造函数。。。
子父类中函数名字重复，采用就近原则，如果要用父类的函数，用super。函数名就可


9.final关键字（最终的）
修饰类，类不能继承 final class 类名。 （（修饰方法，方法不能被修改。 修饰变量就变成了常量，只能被赋值一次。
public（公共的） static final 数据类型 变量 （第4条 有关联）
final 类名 p=new 类名（）；p=new 类名（）这是不可以的。。final 之后不能改变地址值了，，但是可以改变属性值
用 set ，get 方法来改变没问题


10.多态
父类不能访问子类的变量和方法，属性.。多用向上转化，向下转化
要有继承关系。 要有方法重载。要有父类引用子类对象。（09.03）
当father f= new son（）；
f.变量的时候根据，变量在子类对象开辟的空间地址，先访问父类的变量（编译看左边，运行也看左边）
(非静态)当 f.函数（）；根据动态捆绑，在方法区的函数，编译先看父类中是否右这个函数
如果没有，那么这个程序会报错，如果父类中含有这个函数，那么不会报错，
并且执行子类中的函数。函数进入栈区，运行完成，废弃。（编译看左边，运行看右边）
（静态）f。函数（），则执行父类函数。


abstract 抽象类
抽象方法 public abstra void eat（）{}；没有函数体
抽象类不能由自己进行实例化（不能 定义抽象类对象），应该由子类进行实例化 father f=new son（）；
f.函数名字（在抽象类中声明的，如果抽象类中没有，那么报错）
继承的子类要不就写成抽象类，，要么就在子类中重写 父类  中的--所有的抽象函数---
 抽象类中 可以有变量，常量，抽象方法，非抽象方法。。而抽象方法就是父类强制子类干的事情
不能够和 static 共存，被static 修饰的方法可以用类名。方法（）调用，但是在抽象类中这样用了没有意义
不能和 final共存，final修饰的方法，子类不能重写。而abstract修饰的是为了子类的重写
不能和private 共存。。子类不能直接调用了。


11.接口（interface） 里面全都是抽象方法，方法前不用加abstract修饰了。抽象类里面可以不全都是抽象方法
接口（抽象类）不能实例化，调用抽象方法没有意义
类实现接口  class 类名 implements 接口名{}
接口的实例化，和抽象类的实例化一样。都是一种多态的实例化。父类（接口）引用指向子类对象。
接口种可以定义变量，但是都是常量，如果不加final ， jvm默认加上public static final，因此不能被子类修改。（接口名.变量）
接口中没有构造方法。。。接口是干爹。。。默认继承object 类。子类对接口内的方法重写都要加上权限。但是接口种方法
前面jvm会默认加上public 和abstract。
类与类之间是单继承，可以多层集成。
 类与接口之间可以单实现，也可以多实现。class a implements 接口1，接口2，。。。。{}
接口与接口，可以单继承，也可以多继承。（不能实现implements）（可以extends）


12.内部类（10.11 &&12）
public out.inner oi=new out().new inner();
static内部类 out.inner oi=new out.inner();


13.eclipse 11.06
如果直接打印对象，，默认调用toString（）方法
equal 当两个对象直接时 比较的是地址值。一般需要重写，比较对象中的属性值。不管冲写什么方法，用哪个对象调用的在那个类中重写。
equal 可以进行两个字符串比较
== 地址值


14.String StringBuffer
String 为不可更改的类型。。。一旦被初始化就不会不改变
StringBuffer 在缓冲区进行更改 13.23
String s=""是个对象，能调用函数，是空的
String s=null  是空常量 不能调用函数，但是可以给任意引用赋值
String 中的equals 是重写的


15.正则 、d代表转义字符 \\d表示
[]代表单个字符
\\. 代表正则种的. 要进行转义
split 分割
regex="(.)\\1(.)\\2" // \\1代表第一组又出现了一次\\2代表第二组又出现了一次
s.spilt("(.)\\1+","$1") //+代表出现了一次或者多次,$1党代表替换是的是（.） $1还和 （.）一样
regex= "1[357]\\d{9}"  //手机号码的正则表达式，含义问第一位是1，第二位为357中的一个就行，后面的任意数字出现9次
{9}，出现9次。


Pattern p=Pattern.compile(a*b); a*b=regex;
Matcher m=p.matcher("aaaaan");  "aaaaab"=字符串
有 find group,等方法
一个源文件中不允许出现两个public 修饰的类


16.集合
collection list arraylist linkedlist
一般都自动转换为object 对象了 15-04
基本数据类型存储的是值，引用数据类型存储的是地址值。
集合只能存储引用数据类型（对象），如果存入了值，那么会进行自动装箱。
ArrayList()  add  remove  clear  contain   is.Empty  size
addall() removeall(删除的是交集，多余的不删除) removeall（）  retainall(取交集)
迭代器 Iterator it=c.iterator（）；hasnext()，判断是否还有元素，next（）读取。。在开始在迭代器第一个元素之前.
hasnext next  previous(必须和hasnext（）一起使用，否则指针就会在开头，向前没有了） previous；
遍历的同时在添加元素，会出现并发异常
在list集合中 遍历的同时再添加元素。。一般用list集合特有的ListIterator迭代器，用法和Iterator差不多，用lit.add()添加
在删除重复元素的时候要重写equals 方法。（16-02）


HashSet 必须重写hashcode equals方法
不能添加重复的元素，无索引，存取不一致
只有在存引用数据类型的时候，hashcode值是一样的时候才会调用equals方法，如果是一样的那么就不会再存了。（17.03）桶结构
重写哈希code equals 方法alt shift s v
linkedhastset 是唯一一个能保证怎么存的就怎么取得，hashset的子类，基本一样


TrssSet 集合是对元素进行排序的。他也同样保证元素的唯一性。存储数据之前都回想进行compareto方法。字符串中compareto已经重写了
自定义类型的数据类型要姐接口 implement compareble 重写compareTo方法（当返回一个0，只存一个；当存一个整数，怎么存怎么输出；负数，倒取倒叙输出）
比较器 17-18）））））））））


Map集合<k,v> 不能直接遍历，游泳keyset getkay getvalue 来做
put《k,v》 添加 k是唯一的，如果再往里面添加相同的value的值会被覆盖，并且返回以前的value值
remove<k> 返回value值
containKey containValue
isempty 
map 中没有iterator 方法 
迭代方法 ：
keyset
get(k)会获取value；
Map.value<k,v>看成是一个数据对象。接口.接口1  说明接口1在接口的内部


linkedhashmap




hashset hashmap 都要重写hashcode equals 方法


collections sort max min binary shuffle(随机)


17.泛型
<>之间必须是引用数据类型，前后泛型必须一致，，，，后面的<>可以不写（1.7）新特性，和前面的引用数据类型一样了
迭代器 Iterater<泛型> it=集合.iterator;而且用getname，不用强制类型转换了.
非静态方法，可以加上泛型（16-10）public<>方法(Q q){}
静态方法随着类的加载而加载，必须自己声明自己的泛型 public static<Q> void print(Q q){}


泛型通配符 <?>  不同类型的类，在整合为一起的时候必须是继承关系。才能addall一个集合中。
泛型固定上边界 ？extend E   //两个类是继承关系 18-15
泛型固定下边界 ？super E    //运用比较器的时候，比较的湿父类的，子类也能比较。






三种遍历方式的删除 for Iterator foreach（16-15）
可变参数（数据类型 ...变量（其实还是要给数组））{很吊，比数组强大，0————无穷大}（16-17，，18）
数组转成集合Arrays.asList(数组名);但是不能添加和删除元素，但是可以用集合的其他方法。
基本数据类型转换成集合会将整个数组作为一个对象转换（String 类型不算)


定义的时候，直接定义基本数据类型的包装类。Integer Double ...将数组转化为集合，数组必须是引用类型。引用数据类型 默认值是NULL。
集合转华为数组  数据类型 变量=集合.toArray(new 数据类型[length]);//当转换数组时候，如果数组的长度小于集合的size，转换的数组的长度就等于size，如果大于size就和制定的长度一样
如同 String[] arr=new String[length];




18.异常 alt shift + z 快捷键{运行异常（运行的时候出现的错误） ，，，，编译异常（在写的时候就提示了，不让你好好的编译）




try 检测异常 
catch 用来捕获异常
        finally 释放资源
try 如果检测异常，就进行catch（异常类的 对象的创建）jvm要将对象的创建new Exception赋予了Exceptiom e;
catch 捕获到了try 运行完了一个catch 就结束try 运行除了try catch之后的语句。
如果有多个异常，大的异常在下，小的异常在上。。根据多态的原理，如果大的在上那么，父类引用子类对象，小的异常没有意义，便会报错。
编译时的异常地抛出，必须对其进行处理，在方法上加上throws Exception
运行时的异常的抛出，可以处理也可以不处理，就是在方法上加不加throws RuntimeException；
在方法中的用throw 没加s。throws在方法上throws Exception,throws ...{ throw new Exception("出错了");但是throw只能根一个异常}
finally  纵然执行了cacth或者没有执行，都是要执行的，即使catch 中有return ； 也要执行，反正必须要执行的，很强，在return 后。用来释放资源，在io流，数据库中执行。
自定义异常，只要在自定义的类中添加父类 Exception or runtimeexception的空参有参的构造函数就可。


19.File。




file 的三个构造
                /*1.File file=new File("D:\\新建文件夹\\java测试.txt");
System.out.println(file.exists());
2.File file1=new File("xxx.txt");
System.out.println(file1.exists());
3.String parent="d:\\新建文件夹";
String child="java测试.txt";
File file2=new File(parent,child);
System.out.println(file2.exists());*/
/*4.*/File parent=new File("d:\\新建文件夹");
String child="java测试.txt";
File file = new File(parent, child);
System.out.println(file.exists());
System.out.println(parent.exists());
文件的创作
File file =new File("yyy.txt");
System.out.println(file.createNewFile());如果有就创建返回true 没有返回false


文件夹的创作
File dir1=new File("aaa");
System.out.println(dir1.mkdirs());//make dir。


文件夹多级目录的创建//创建出来的都是文件夹
File dir1=new File("ccc\\ddd");
System.out.println(dir1.mkdirs());


file的重命名和删除功能
  removeto
相同路径下
File file=new File("yyy.txt");存在的
File file2=new File("fff.txt");必须是不存在的
file.removeto(file2);在相同路径下，removeto只是简单的改名字 将yyy改成fff，其实就是将yyy中的东西剪切掉，赋予fff，并删除yyy
不同路径下


File file=new File("yyy.txt");存在的
File file3=new File("d:\\新建文件夹\\vvv.txt");//不存在的
file.removeto(file3);//路径不同，即改名字，并且将自己剪切到 file3路径下。
  delete


File file=new File("zzz.txt");
System.out.println(file.delete());//删除txt


File file1=new File("aaa");
System.out.println(file1.delete());//删除文件夹。但是文件夹中不能有任何东西，必须是空的


file 的判断功能
   可以说文件夹是装文件的仓库.
isDirectory()判断是否是一个文件夹
isFile()判断是否是一个文件（txt等）
exists()判断是否存在
canRead()判断是否可读
canWrite()判断是否可写
isHidden()判断是否隐藏

File dir1=new File("ccc");
System.out.println(dir1.isDirectory());//判断是否是一个文件夹


File dir2=new File("zzz.txt");
System.out.println(dir2.isDirectory());
System.out.println(dir1.isFile());//判断是否是一个文件（txt等）
System.out.println(dir2.isFile());


File file=new File("zzz");
file.setReadable(false);//设置文件不可读。
System.out.println(file.canRead());//但是在windows平台上，系统认为所有的文件都是可读的，zaiwindows尚没有意义
file.setWritable(false);//设置文件不可写
System.out.println(file.canWrite());//windows系统可以设置为不可写

File file2=new File("aaa.txt");
System.out.println(file2.isHidden());//判断文件是否隐藏
file的获取功能
getAbsolutePath()//获取绝对路径
getPath()//获取传入的路径
File file=new File("bbb.txt");
File file2=new File("d:\\新建文件夹\\java测试.txt");
System.out.println(file.getAbsolutePath());//D:\JAVA1\Day19\bbb.txt
System.out.println(file2.getAbsoluteFile());//d:\新建文件夹\java测试.txt


System.out.println(file.getPath());//bbb.txt
System.out.println(file2.getPath());//d:\新建文件夹\java测试.txt


ystem.out.println(file.getName());//bbb.txt
System.out.println(file2.getName());//java测试.txt


System.out.println(file.length());//获取字节个数


System.out.println(file.lastModified());//最后一次修改的时间
Date d=new Date(file.lastModified());
System.out.println(d);
SimpleDateFormat adf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
System.out.println(adf.format(d));


File file=new File("d:\\新建文件夹");//获取该文件下的目录，文件夹，文件名称
String[] arr=file.list();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
java测试.txt
vvv.txt
安装包



File[] subfile=file.listFiles();//获取文件对象
for (File file2 : subfile) {
System.out.println(file2);
}
d:\新建文件夹\java测试.txt
d:\新建文件夹\vvv.txt
d:\新建文件夹\安装包


File dir=new File("e:\\");
String[] arr=dir.list();//获取e下所文件或者文件夹
for (String string : arr) {
if(string.endsWith(".jpg"));//判断后缀是否存在
System.out.println(string);
}
File[] subFiles=dir.listFiles();
for (File file : subFiles) {
if(file.isFile()&&file.getName().endsWith(".jpg"));
System.out.println(file);
}
过滤器，将符合规定的放进去
File dir=new File("E:\\");
String[] arr=dir.list(new FilenameFilter() {//过滤器

@Override
public boolean accept(File dir, String name) {
File file=new File(dir,name);
return file.isFile()&&file.getName().endsWith(".jpg");
}
});
for (String string : arr) {
System.out.println(string);
}
}


20 I/O流


inpustream outstream  字节流的最顶层抽象父类。
reader writer 字符流的最顶层抽象父类


IO流 使用前要导包，使用时要抛出异常，最后要释放资源。
文件的结束标记是-1.
fileinputstream
FileInputStream fis=new FileInputStream("xxx.txt");
int b;
while((b=fis.read())!=-1){
System.out.println(b);
}
fis.close();
FileOutStream //FileOutputStream fos=new FileOutputStream("yyy.txt");在创建对象的时候，没有这个文件，会创建，如果有了，那么就会将那个文件清空。
FileOutputStream fos=new FileOutputStream("yyy.txt");//创建字节输出流对象，没有自己创建
fos.write(97);//写出的是int 数但是在文件上是一个字节
fos.write(98);
fos.write(99);
fos.close();
FileOutputStream fos=new FileOutputStream("yyy.txt",true);//续写文件，在第二个参数加个true
fos.write（int）；

拷贝
第一种拷贝方法效率低，一般也不用
FileInputStream fis=new FileInputStream("t3.jpg");
FileOutputStream fos=new FileOutputStream("copy.jpg");

int b;
while((b=fis.read())!=-1){
fos.write(b);
}
fis.close();
fos.close();

第二种快速拷贝方法，大的，效率高，，但是开发中不推荐，数组开不了那么大的
FileInputStream fis=new FileInputStream("t3.jpg");
FileOutputStream fos=new FileOutputStream("copy.jpg");
byte[] arr=new byte[fis.available()];//创建与文件一样大小的字节数组


fis.read(arr);//将文件上的字节读取到数组中
fos.write(arr);//字节数组中的字节数组拷贝到文件上
fis.close();
fos.close();


I/O流小数组读取拷贝，while循环，以后基本上用这个
FileInputStream fis=new FileInputStream("xxx.txt");
FileOutputStream fos=new FileOutputStream("yyy.txt");
byte[] arr=new byte[1024*N];//N为整数。
int len;
while((len=fis.read(arr))!=-1){
//如果读取不到数据了，那么返回-1;
fos.write(arr,0,len);
}


I/O流（bufferedinputstream bufferedoutputstream)缓冲区的拷贝
       FileInputStream fis=new FileInputStream("xxx.txt");
FileOutputStream fos=new FileOutputStream("zzz.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
BufferedOutputStream bos=new BufferedOutputStream(fos);
int b;
while((b=bis.read())!=-1){在缓冲区中已经创建了byte【8192】 数组，先读取一个【8192】个字节之后再将值，一个个的给b，当读取完了之后，在读取，然后再给b，
bos.write(b);////然后直到缓冲区out中的byte【8192】数组满了之后在一次性的的给硬盘
}//内存中的读取速度比硬盘的要快
bis.close();//只需要将包装后的关闭就行。
bos.close();

flush 和 close 的区别（20-12）
close()具备刷新的功能,在关闭流之前，会先刷新一次缓冲区，将缓冲区的字节先刷新到文件上，在关闭。
flush()具备刷新功能，刷完之后还可以继续写，而close 刷完之后就不能再写了 


字节流读取中文（可能会出现乱码）


字节流写出中文，将字符串转换成字符数组 getbytes();
FileOutputStream fos=new FileOutputStream("zzz.txt");
fos.write("我读书少，\n\r我很牛逼！".getBytes());//字符串转化为字符数组
fos.close();

图片加密，将写出的字节异或一个数，一个数被相同的两个数异或，仍是本身。
·
字符流不能拷贝非纯文本的文件，字节流读取纯文本文件的时候可能会读取半个字符


I/O字符流 
filereader,读取
FileReader fr=new FileReader("xxx.txt");
int c;
while((c=fr.read())!=-1){
System.out.println((char)c);
}
fr.close();
filewrite 写入，没有就创建
FileWriter fw=new FileWriter("ccc.txt");
fw.write("再坚持几天.");
fw.write('a');
fw.close();
copy
FileReader fr=new FileReader("ccc.txt");
FileWriter fw=new FileWriter("zzz.txt");
int c;
while((c=fr.read())!=-1){
fw.write(c);
}
fr.close();
fw.close();//如果不关掉，那么拷贝的东西可能在缓冲区内，未写入指定文件中


buffered
BufferedReader br=new BufferedReader(new FileReader("zzz.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("aaa.txt"));
/*String line;
while((line=br.readLine())!=null){//read.line是以\n\r为结束标志的
System.out.println(line);
}*/
String line;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();//写出回车换行符//是跨平台的方法
//bw.write("\r\n");结果是一样的，支支持的是windows系统
  }
setline getline 获取行数和设置行数。
printStream ps这个方法能直接写出换行，就不用bufferedWrite的new.lin();换行了
ps。println();


装饰编码不同的情况下如何进行拷贝，java 默认读取文件是一gbk进行读取
第一种方法
InputStreamReader isr=new InputStreamReader(new FileInputStream("utf_8.txt"),"utf-8");
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");
int b;
while((b=isr.read())!=-1){
osw.write(b);
}
isr.close();
osw.close();*/
bufferedreader 方法二
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("utf_8.txt"), "utf-8"));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk1.txt"),"gbk"));
int b;
while((b=br.read())!=-1){
bw.write(b);
}
br.close();
bw.close();


（22.02 ）SequenceInputStream /关流的时候也会将构造的流关闭。将两个流连接在一起。序列流的整合。想将歌曲，音频整合为一个，可以用这个，vector 里面的枚举功能


//可用于音频视频整合
public static void main(String[] args) throws IOException {
FileInputStream fis1=new FileInputStream("xxx.txt");
FileInputStream fis2=new FileInputStream("zzz.txt");
FileInputStream fis3=new FileInputStream("sss.txt");
Vector<FileInputStream> v=new Vector<>();//创建一个集合对象，将输入流保存进来
v.add(fis1);
v.add(fis2);
v.add(fis3);
Enumeration<FileInputStream> en=v.elements();//获取枚举引用
SequenceInputStream sis=new SequenceInputStream(en);//传递给 构造
FileOutputStream fos=new FileOutputStream("d.txt");
int b;
while((b=sis.read())!=-1){
fos.write(b);
}
sis.close();//这个流关闭了，那么输入流也就全部关闭了
fos.close();




将文件中的数据一次性都去出来，用字节流读取可能会出现乱码，除了用字符流之外的方法ByteArrayOutputStream
出现乱码的情况少，字符流适用于纯文本，有字符就可能出现乱码，字节对有中文的会出现乱码。
FileInputStream fis=new FileInputStream("xxx.txt");
ByteArrayOutputStream baos=new ByteArrayOutputStream();//在内存中创建了可以增长的内存数组
int b;
while((b=fis.read())!=-1){
baos.write(b); //将读取到的数据逐个写到内存中去
}
/*方法一
byte[] arr=baos.toByteArray();     //将缓存中的数据全部获取出来，并赋值给arr数组
System.out.println(new String(arr));*/   //string的构造方法，输出
//方法二
System.out.println(baos.toString()); //将缓存中的内容转换为字符串
fis.close();




对象流
ObjectOutputstream  （out是序列化，将记录保存在文件中，input是反序列化，将记录读取出来）


public class Demo3_ObjectOutputStream {


public static void main(String[] args) throws IOException, IOException {
Perpon p1=new Perpon("3",26);//////自定义的类一定要implements Serializable 接口，这是一个规则
Perpon p2=new Perpon("4",27);
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("q.txt"));
oos.writeObject(p1);
oos.writeObject(p2);
oos.close();
}


}
ObjectInputstream 反序列化
public class ObjectInputstream {


public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("q.txt"));
Perpon p1=(Perpon) ois.readObject();//强转。
Perpon p2=(Perpon) ois.readObject();
System.out.println(p1);
System.out.println(p2);
}


}


优化，用集合来储存和遍历


public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
Perpon p1=new Perpon("3",26);
Perpon p2=new Perpon("4",27);
Perpon p3=new Perpon("5",28);
Perpon p4=new Perpon("6",29);
ArrayList<Perpon> list=new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("o.txt"));
oos.writeObject(list);
oos.close();
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("o.txt"));
ArrayList<Perpon> li=(ArrayList<Perpon>)ois.readObject();
for (Perpon perpon : li) {
System.out.println(perpon);
}
}






printstream 打印流
properties 是一个集合。




线程 
并行线程 得用多个cpu多核
并发线程 是jvm一个个的运行，但是运行的很快感觉就行同时进行

开启线程 start（），并且在开启的时候需要一点时间，可能会执行主线程的方法。


Synchronized //同步代码块,synchronized(锁对象) ..当运用代码块的时候，用相同的对象。
同步方法的时候 是非静态的的方法，那么另外的synchronized（this）
如果是静态的，那么另外的synchronized（类名.class)




lock unlock condition监听器 


网络编程
socket 码头










反射


对于.java 源文件 用Class clazz（object 类得啦）=class.forName("包名.类名")//读取配置文件
类名 对象=(强转)clazz.newInstance();




.class 用Class clazz=类名.class//可当作锁对象

Person p=new Person（）；  用Class clazz=p.getClass();//用于判断