JavaSE总结1

JavaSE总结1是从API的角度去总结了几乎所有JavaSE的API
JavaSE总结2是对JavaSE从Day01到Day21的优快云博客全部知识点的提炼

一切皆是API

API的用法都一致，第一步都是用构造方法创建，第二步都是调用普通方法

关于普通方法：我们重点关注它是不是静态方法

就以System为例，它有个方法是：
public static long currentTimeMillis()你可以看到static一词，
那么它的调用方式就是“类名.方法”System.currentTimeMillis()

假如它不是static方法，那么调用方式就是(先构造再使用)：
System st = new System();
st.currentTimeMillis();

基于构造方法、普通方法、静态Static方法的使用方式不同，我们会把一个类的方法按这三种方式划分

一、Scanner

构造方法：

Scanner read = new Scanner(System.in);

普通方法：

int a =read.nextInt();
			String a =read.nextLine();
			double a =read.nextDouble(); 

二、random

构造方法

Random r = new Random(); // 小括号当中留空即可

普通方法：

	int num = r.nextInt()  //得到的可能是-12354662
	int num = r.nextInt(3)  //实际上代表的含义是：[0,3)，也就是0~2
	int result = r.nextInt(n) + 1;本来范围是[0,n)，整体+1之后变成了[1,n+1)，也就是[1,n]

三、String

String的构造方法：

创建字符串的常见3+1种方式。
三种构造方法：
		public String()：创建一个空白字符串，不含有任何内容。String str1 = new String();
		public String(char[] array)：参数char[] array是什么？你那不是废话吗，那就是典型的数组的构造方式啊。
		public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
		String str = "Hello"; // 右边直接用双引号

        // 使用空参构造
        String str1 = new String(); // str1为空

        // 根据字符数组创建字符串
        char[] charArray = { 'A', 'B', 'C' };
        String str2 = new String(charArray);//str2为ABC

        // 根据字节数组创建字符串
        byte[] byteArray = { 97, 98, 99 };
        String str3 = new String(byteArray);//str3为979899

        // 直接创建
        String str4 = "Hello";

普通方法：

判断类型的：
		public boolean equals(Object obj)：
		public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较

获取相关的常用方法有：
		public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
		public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
		public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
		public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1值。

字符串的截取方法：
		public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
		public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。
		备注：[begin,end)，包含左边，不包含右边。

与转换相关的常用方法有：
		public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
		public byte[] getBytes()：获得当前字符串底层的字节数组。
		public String replace(CharSequence oldString, CharSequence newString)：

		String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false，严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写

		int length = "asdasfeutrvauevbueyvb".length();
		String str3 = "Hello".concat("World");
		char ch = "Hello".charAt(1);//e

		int index = "HelloWorldHelloWorld".indexOf("llo"); // 2

		String str2 = "HelloWorld".substring(5);//"World"

		String str3 = "HelloWorld".substring(4, 7);//oWo
		
		char[] chars = "Hello".toCharArray();

		byte[] bytes = "abc".getBytes();//[97,98,99]

		String lang2 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！".replace("你大爷的", "****");
		//会不会玩儿呀！****！****！****！！！

四、Math类

        System.out.println(Math.random()); //产生0-1之间的随机数  0.23605509569800187
        System.out.println(Math.abs(-10)); //10
        System.out.println(Math.max(3,6));//6
        System.out.println(Math.ceil(3.1)); // 向上取整4.0
        System.out.println(Math.floor(8.6)); //向下取整 8.0
        System.out.println(Math.round(8.6)); //求离8.6最近的整数 9
        System.out.println(Math.log(10));//求以e为底的对数，不是以10为底  2.302585092994046
        System.out.println(Math.exp(2));//求e的x次方 7.38905609893065
        System.out.println(Math.pow(2,3));//8.0
        System.out.println(Math.sqrt(4));//2.0
        System.out.println(Math.cos(3.14));//-0.9999987317275395

		int max = a > b ? a : b; // 最大值的变量

五、instaceof

instance就是for instance的那个instance

    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
    }

六、Object类

没有构造方法

普通方法：

public String toString()`：返回该对象的字符串表示。
public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。
public boolean Objects.equals(s1,s2)比上一个更安全，避免空指针异常
int hashCode() 返回该对象的哈希码值。

Alt+Insert 或 鼠标右击 便可以自动生成这些重写过的方法

任何东西都继承了Object，所以Object类的方法请随便的使用，谢谢。
Person p = new Person("张三",18);
String s = p.toString();//出来的如果不是地址值那就说明被重写了

Person p1 = new Person("迪丽热巴",18);
Person p2 = new Person("古力娜扎",19);
boolean b = p1.equals(p2);

String s1 = "abc";
String s1 = null;
boolean b = s1.equals(s2); //会抛出空指针异常
boolean b2 = Objects.equals(s1, s2);//这就没有异常了

Person p1 = new Person();
int h1 = p1.hashCode();//1967205423

七、System类

没有构造方法

静态Static方法：

public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组
						参数依次是：源数组  元素组起始索引  目标数组  目标数组起始位置  要复制的长度

System.out.println(System.currentTimeMillis());//获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒


int[] src = {1,2,3,4,5};
int[] dest = {6,7,8,9,10};
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后:"+ Arrays.toString(dest));//[1,2,3,9,10]

八、时间类

Date类

构造方法：

    //Date类的空参数构造方法，Date() 获取当前系统的日期和时间
        Date date = new Date();//Sun Aug 08 12:23:03 CST 2088

    //Date类的带参数构造方法，Date(long date) :传递毫秒值,把毫秒值转换为Date日期
        Date date = new Date(3742767540068L);// Sun Aug 08 09:39:00 CST 2088

普通方法：

    //date.getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)，返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
        Date date = new Date();
        long time = date.getTime();//3742777636267

DateFormat类和SimepleDateFormat类

    java.text.DateFormat:是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类，
    SimpleDateFormat extends DateFormat即SimpleDateFormat是实现了该抽象方法

SimpleDateFormat的构造方法:

SimpleDateFormat(String pattern)
参数:
     String pattern:传递指定的模式（月食--月M和时H是大写，其余都是小写）
     "yyyy-MM-dd HH:mm:ss" 或 "yyyy年MM月dd日 HH时mm分ss秒"

SimpleDateFormat的成员方法:

    String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
    Date parse(String source)  把符合模式的字符串,解析为Date日期

两大功能:
    格式化（也就是日期 -> 文本）、解析（文本-> 日期）

//格式化（也就是日期 -> 文本）
        Date date = new Date();
        System.out.println(date);//Sun Aug 08 15:51:54 CST 2088
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String d = sdf.format(date);
        System.out.println(d);//2088年08月08日 15时51分54秒

//解析（文本-> 日期）
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2088年08月08日 15时51分54秒");
        System.out.println(date);//Sun Aug 08 15:51:54 CST 2088

Calendar类

构造方法：

    java.util.Calendar类:是一个抽象类，Calendar类无法直接创建对象使用,
    但它里边有一个**静态**方法叫getInstance(),该方法返回了Calendar类的子类对象

	Calendar c = Calendar.getInstance();//多态

普通方法：

    Calendar类的常用成员方法:
        public int get(int field)：返回给定日历字段的值。(int field就是Calendar.YEAR年  Calendar.MONTH月....)
        public void set(int field, int value)：将给定的日历字段设置为给定值。
        public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
        public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
    成员方法的参数:
		Calendar.YEAR年  Calendar.MONTH月  Calendar.DATE日  Calendar.HOUR时  Calendar.MINUTE分  Calendar.SECOND秒

        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR);//2088
        int month = c.get(Calendar.MONTH);//7{西方的月份0-11 东方:1-12（东方的8月相当于西方的7月）}
        int date = c.get(Calendar.DATE);


        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR,9999);//设置年为9999
        c.set(Calendar.MONTH,9);//设置月为9月
        c.set(Calendar.DATE,9);//设置日9日
        c.set(8888,8,8);//同时设置年月日,可以使用set的重载方法

  
        Calendar c = Calendar.getInstance();
        c.add(Calendar.YEAR,2);//把年增加2年
        c.add(Calendar.MONTH,-3);//把月份减少3个月


        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);//Sun Mar 23 15:51:54 CST 2021

九、StringBuilder类

构造方法：

    java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率
    
    构造方法:
        StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
        StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

StringBuilder bu1 = new StringBuilder();//构造了一个空的字符串缓冲区""
StringBuilder bu2 = new StringBuilder("abc");//abc

普通方法

 public StringBuilder append(...)
 StringBuilder reverse() 将此字符序列用其反转形式取代。（返回值还是一个StringBuilder型的）

StringBuilder bu = new StringBuilder();
bu.append("abc").append(1).append(true).append(8.8).append('中');//abc1true8.8中

String reName = new StringBuffer("Redhur").reverse().toString();//ruhdeR

StringBuilder和String可以相互转换:

String->StringBuilder:可以使用StringBuilder的构造方法
      StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder->String:可以使用StringBuilder中的toString方法
      public String toString()：将当前StringBuilder对象转换为String对象。

        //String->StringBuilder
        String str = "hello";
        StringBuilder bu = new StringBuilder(str);
        
        //StringBuilder->String
        String s = bu.toString();
        System.out.println("s:"+s);//hello

十、Integer装箱和拆箱

没有构造方法：

静态Static方法：

    装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        静态方法:
            static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
            static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。

普通方法：

    拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        普通方法:
            int intValue() 以 int 类型返回该 Integer 的值。

        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3);//1

        //Integer in4 = Integer.valueOf("a");//错误，Integer是int的箱子
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);//1

        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in3.intValue();
        System.out.println(i);//1

2.自动装箱与自动拆箱
基本类型的数据和包装类之间可以自动的相互转换

3.基本类型与字符串类型之间的相互转换
静态Static方法：

    基本类型与字符串类型之间的相互转换
    基本类型->字符串(String)的方法：
        基本类型的值+""  最简单的方法(工作中常用)
    字符串(String)->基本类型
        使用包装类的静态方法parseXXX("字符串");
            Integer类: static int parseInt(String s)
            Double类: static double parseDouble(String s)

        //基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1+"";
        System.out.println(s1+200);//100200

        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i-10);

十一、遍历输出

①增强for用来遍历数Array数组 和 Collection集合（set集合、list集合）
②itertor用来遍历集合（set集合、list集合）
③当然，你只需要记住数组的遍历方法一般就是for (int i = 0; i < array.length; i++) 和增强for ；集合的遍历方法一般就是itertor 和增强for；
④尽量不要用for (int i = 0; i < array.length; i++)遍历集合。集合可以转为数组toArray()然后使用for (int i = 0; i < array.length; i++)遍历，但是这么做是吃上屎了吗

Iterator

构造方法：

Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊

Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
			这样就很好啊，凡是Collection的子类都可以用itrator来遍历（什么List拉、什么set拉都可以用itrator来遍历）

Collection<String> coll = new ArrayList<>();
//往集合中添加元素后coll=["姚明","科比","麦迪","詹姆斯","艾弗森",]

//  接口               实现类对象
Iterator<String> it = coll.iterator();//多态  

普通的方法：

boolean hasNext() 判断集合中还有没有下一个元素,有就返回true,没有就返回false
E next() 返回迭代的下一个元素。

        Collection<String> coll = new ArrayList<>();
        //往集合中添加元素后coll=["姚明","科比","麦迪","詹姆斯","艾弗森",]

        //  接口               实现类对象
        Iterator<String> it = coll.iterator();//多态  
        //Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型

        while(it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }

for each循环

        int[] arr = {1,2,3,4,5};
        for(int i:arr){
            System.out.println(i);
        }

        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        for(String s : list){
            System.out.println(s);
        }

十二、of方法

适用于List接口,Set接口,Map接口的of方法

    JDK9的新特性:
        List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素
        static <E> List<E> of​(E... elements)
        使用前提:
            当集合中存储的元素的个数已经确定了,不在改变时使用
     注意:
        1.of方法只适用于List接口,Set接口,Map接口,不适用于这些接口的实现类
        2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
        3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常

构造方法：

List<String> list = List.of("a", "b", "a", "c", "d");

Set<String> set = Set.of("a", "b", "c", "d");

Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);

具体使用：

public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "a", "c", "d");
        System.out.println(list);//[a, b, a, c, d]
        //list.add("w");//会抛出异常，of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常

        //Set<String> set = Set.of("a", "b", "a", "c", "d");//IllegalArgumentException:非法参数异常,有重复的元素
        Set<String> set = Set.of("a", "b", "c", "d");
        System.out.println(set);//[a,b,c,d]
        //set.add("w");//UnsupportedOperationException:不支持操作异常

        //Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三",19);////IllegalArgumentException:非法参数异常,有重复的元素
        Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);
        System.out.println(map);//{王五=20, 李四=19, 张三=18}
        //map.put("赵四",30);//UnsupportedOperationException:不支持操作异常
    }
}

十三、多线程

回看JavaSE总结2

十四、Lambda表达式

这个无话可说，只要你有一丁点不理解就请回看 Day26_Lambda表达式的终极使用

十五、File类

    java.io.File类
    路径：C:\\Users\itcast\\IdeaProjects在windows要用两个反斜杠

三个构造方法:

//File的三个构造方法
File(String pathname) 
//File f1 = new File("C:\\Users\\a.txt");创了一个文件
//File f2 = new File("C:\\Users\\shungyuan");创了一个目录
File(String parent, String child)
//File file = new File("c:\\","a.txt");闯了一个"C:\\Users\\a.txt"的文件
File(File parent, String child)
/*File parent = new File("c:\\"); 
File file = new File(parent,"hello.java"); */

普通方法：

File类获取功能的方法
    - public String getAbsolutePath() ：返回此File的绝对路径名字符串。
    - public String getPath() ：你写的绝对路径就返回绝对路径，你写相对路径就返回相对路径。
    - public String getName()  ：返回由此File表示的文件或目录的名称。
    - public long length()  ：返回由此File表示的文件的长度。

File f2 = new File("a.txt");
String absolutePath2 = f2.getAbsolutePath();//C:\Users\itcast\IdeaProjects\shungyuan\a.txt


File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
File f2 = new File("a.txt");
String path1 = f1.getPath();//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
String path2 = f2.getPath();//a.txt
System.out.println(f1.toString());//C:\Users\itcast\IdeaProjects\shungyuan\a.txt
//这说明调用f.toString()和f.getpah()是等效的


File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\a.txt");
String name1 = f1.getName();//a.txt
File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
String name2 = f2.getName();//shungyuan


File f1 = new File("C:\\develop\\a\\1.jpg");
System.out.println(l1);//780831字节
File f3 = new File("C:\\develop\\a");
System.out.println(f3.length());//0 文件夹没有大小概念的

File类判断功能的方法
    - public boolean exists() ：此File表示的文件或目录是否实际存在。
    - public boolean isDirectory() ：此File表示的是否为目录。
    - public boolean isFile() ：此File表示的是否为文件。

File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
System.out.println(f1.exists());//true

File f4 = new File("a.txt");
System.out.println(f4.exists());//false


File f2 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan");
if(f2.exists()){
    System.out.println(f2.isDirectory());//true
    System.out.println(f2.isFile());//false
}

File类创建删除功能的方法
    - public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
    - public boolean delete() ：删除由此File表示的文件或目录。
    - public boolean mkdir() ：创建由此File表示的目录。
    - public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

File f1 = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion\\1.txt");
boolean b1 = f1.createNewFile();


File f1 = new File("08_FileAndRecursion\\aaa");
boolean b1 = f1.mkdir();


File f1 = new File("08_FileAndRecursion\\新建文件夹");
boolean b1 = f1.delete();

File类遍历(文件夹)目录功能
    - public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
    - public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。

//File file = new File("C:\\Users\\itcast");//路径不存在，有异常NullPointerException
File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion");
String[] arr = file.list();
for (String fileName : arr) {
    System.out.println(fileName);
   }
}

File file = new File("C:\\Users\\itcast\\IdeaProjects\\shungyuan\\08_FileAndRecursion");
File[] files = file.listFiles();
for (File f : files) {
    System.out.println(f);
    }
}

十六、FileFilter文件过滤器

    在File类中有两个和ListFiles重载的方法,方法的参数传递的就是过滤器
    
    File[] listFiles(FileFilter filter)
    java.io.FileFilter接口:用于抽象路径名(File对象)的过滤器。
            boolean accept(File pathname) 参数:File pathname:是使用ListFiles方法遍历目录,得到的每一个文件对象

    File[] listFiles(FilenameFilter filter)
    java.io.FilenameFilter接口:实现此接口的类实例可用于过滤器文件名。
            boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中。
            参数:File dir:构造方法中传递的被遍历的目录  String name:使用ListFiles方法遍历目录,获取的每一个文件/文件夹的名称
                    
    注意:
        两个过滤器接口是没有实现类的,需要我们自己写实现类,重写过滤的方法accept,在方法中自己定义过滤的规则

使用方法：

File file = new File("c:\\abc");
File[] files = file.listFiles(new FileFilterImpl());
//也就是说你还得写一个实现类FileFilterImpl

练习：

    练习:
        递归打印多级目录
    需求:
        遍历c:\\abc文件夹,及abc文件夹的子文件夹，只要.java结尾的文件
        c:\\abc
        c:\\abc\\abc.txt
        c:\\abc\\abc.java
        c:\\abc\\a
        c:\\abc\\a\\a.jpg
        c:\\abc\\a\\a.java
        c:\\abc\\b
        c:\\abc\\b\\b.java
        c:\\abc\\b\\b.txt

File[] listFiles(FileFilter filter)

/*
    创建过滤器FileFilter的实现类,重写过滤方法accept,定义过滤规则
    过滤规则定义为：
    先判断该pathname是否为一个文件夹,如果是文件夹就直接返回true,
    如果不是文件夹那么它就是文件，判断该文件是否是以.java结尾，是就返回true，不是就返回false
 */
public class FileFilterImpl implements FileFilter{
    @Override
    public boolean accept(File pathname) {
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".java");
    }
}

public class Demo01Filter {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        getAllFile(file);
    }

    public static void getAllFile(File dir){
        File[] files = dir.listFiles(new FileFilterImpl());
        for (File f : files) {
            if(f.isDirectory()){
                getAllFile(f);
            }else{
                System.out.println(f);
            }
        }
    }
}

File[] listFiles(FilenameFilter filter)

class Demo02Filter {
    public static void main(String[] args) {
        File file = new File("c:\\abc");
        getAllFile(file);
    }

    public static void getAllFile(File dir){
        File[] files = dir.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return new File(dir,name).isDirectory() || name.toLowerCase().endsWith(".java");
            }
        });

        for (File f : files) {
            if(f.isDirectory()){
                getAllFile(f);
            }else{
                System.out.println(f);
            }
        }
    }
}

十七、IO流

字节流

• 字节输入流就是从硬盘输入到内存（读取文件内容到显示台）
• 字节输出流就是从内存写入到硬盘（写入到文件）
• 遵循“读入写出”（read方法用的是输入流，write方法用的是输出流）

字节输出流OutputStream

字节输入流

字符流

字符输入流

字符输出流

十八、属性集Properties

属性集那些方法的使用顺序：
第一步，要么.setProperty()先自己设置那些键值对，要么.load()从文件里加载那些键值对
第二步，调用.SringPropertyName()把那些价值对加载到set集合里面
第三步，遍历输出，用到.getProperty

十九、IO缓冲流

读入写出：输入流就是read，输出流就是write

1.字节缓冲输出流

    java.io.BufferedOutputStream extends OutputStream
    BufferedOutputStream:字节缓冲输出流

    继承自父类OutputStream的共性成员方法:
        - public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
        - public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
        - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
        - public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
        - public abstract void write(int b) ：将指定的字节输出流。

构造方法：

        BufferedOutputStream(OutputStream out)  创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream(OutputStream out, int size)  创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
        参数:
           OutputStream out:字节输出流
                我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区,提高FileOutputStream的写入效率
           int size:指定缓冲流内部缓冲区的大小,不指定默认

使用：

        FileOutputStream fos = new FileOutputStream("C:\\abc\\abc.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("我把数据写入到内部缓冲区中".getBytes());
        bos.flush();
        bos.close();

2.字节缓冲输入流

java.io.BufferedInputStream extends InputStream
BufferedInputStream:字节缓冲输入流

继承自父类的成员方法:
    int read()从输入流中读取数据的下一个字节。
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    void close() 关闭此输入流并释放与该流关联的所有系统资源。

构造方法:

    BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
    参数:
        InputStream in:字节输入流
            我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高FileInputStream的读取效率
        int size:指定缓冲流内部缓冲区的大小,不指定默认

使用：

        FileInputStream fis = new FileInputStream("10_IO\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);


        //这是一个字节一个字节读的
        int len = 0;//记录每次读取到的字节
        while((len = bis.read())!=-1){
            System.out.println(len);
        }

        //一次读取很多字节的方式
        byte[] bytes =new byte[1024];//存储每次读取的数据
        int len = 0; //记录每次读取的有效字节个数
        while((len = bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }


        bis.close();

3.字符缓冲输出流

java.io.BufferedWriter extends Writer
BufferedWriter:字符缓冲输出流

继承自父类的共性成员方法:
    - void write(int c) 写入单个字符。
    - void write(char[] cbuf)写入字符数组。
    - abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
    - void write(String str)写入字符串。
    - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
    - void flush()刷新该流的缓冲。
    - void close() 关闭此流，但要先刷新它。

构造方法:
    BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
    BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
    参数:
        Writer out:字符输出流
            我们可以传递FileWriter,缓冲流会给FileWriter增加一个缓冲区,提高FileWriter的写入效率
        int sz:指定缓冲区的大小,不写默认大小

特有的成员方法:
    void newLine() 写入一个行分隔符。会根据不同的操作系统,获取不同的行分隔符
    
    你以前的换行符号：windows:\r\n   linux:/n

使用：

        BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\abc\\abc.txt"));
 
        for (int i = 0; i <10 ; i++) {
            bw.write("传智播客");
            //不用再写bw.write("\r\n");
            bw.newLine();
        }

        bw.flush();
        bw.close();

4.字符缓冲输入流

java.io.BufferedReader extends Reader
BufferedReader:字符缓冲输入流

继承自父类的共性成员方法:
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。

 构造方法:
    BufferedReader(Reader in)  创建一个使用默认大小输入缓冲区的缓冲字符输入流。
    BufferedReader(Reader in, int sz)     创建一个使用指定大小输入缓冲区的缓冲字符输入流。
    参数:
        Reader in:字符输入流
            我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区,提高FileReader的读取效率
 特有的成员方法:
    String readLine() 读取一个文本行。读取一行数据
        行的终止符号:通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行(\r\n)。
    返回值:
        包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

使用：

        BufferedReader br = new BufferedReader(new FileReader("10_IO\\c.txt"));

        //2.使用字符缓冲输入流对象中的方法read/readLine读取文本
        /*String line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);*/


        //发现以上读取是一个重复的过程,所以可以使用while循环优化
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

        br.close();

二十、转换流

为什么要学这个？
你之前学的字符流FileReader可以读取IDE默认编码格式(UTF-8)的文件，但它读取系统默认编码(中文GBK)会产生乱码���
所以我们必须学一个能读取GBK的编码

1.OutputStreamWriter

普通方法：

java.io.OutputStreamWriter extends Writer
OutputStreamWriter: 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。(编码:把能看懂的变成看不懂)

继续自父类的共性成员方法:
    - void write(int c) 写入单个字符。
    - void write(char[] cbuf)写入字符数组。
    - abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
    - void write(String str)写入字符串。
    - void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
    - void flush()刷新该流的缓冲。
    - void close() 关闭此流，但要先刷新它。

构造方法:

    OutputStreamWriter(OutputStream out)创建使用默认字符编码的 OutputStreamWriter。
    OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。
    参数:
        OutputStream out:字节输出流,可以用来写转换之后的字节到文件中
        String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,...不指定默认使用UTF-8

使用:

    /*
       使用转换流OutputStreamWriter写GBK格式的文件
    */
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\gbk.txt"),"GBK");
        osw.write("你好");
        osw.flush();
        osw.close();


    /*
        使用转换流OutputStreamWriter写UTF-8格式的文件
     */
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        osw.write("你好");
        osw.flush();
        osw.close();

2.InputStreamReader

普通方法：

java.io.InputStreamReader extends Reader
InputStreamReader:是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。(解码:把看不懂的变成能看懂的)

继承自父类的共性成员方法:
    int read() 读取单个字符并返回。
    int read(char[] cbuf)一次读取多个字符,将字符读入数组。
    void close() 关闭该流并释放与之关联的所有资源。

构造方法:

    InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
    InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。
    参数:
        InputStream in:字节输入流,用来读取文件中保存的字节
        String charsetName:指定的编码表名称,不区分大小写,可以是utf-8/UTF-8,gbk/GBK,...不指定默认使用UTF-8
        
     注意事项:
    构造方法中指定的编码表名称要和文件的编码相同,否则会发生乱码

使用:

    /*
        使用InputStreamReader读取GBK格式的文件
     */
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\gbk.txt"),"GBK");//你好
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);//必须强转为char类型，因为你读到的是字节byte是数字，必须转为字符你才能看到里面的汉字
        }
        
        isr.close();


    /*
        使用InputStreamReader读取UTF-8格式的文件
     */
        InputStreamReader isr = new InputStreamReader(new FileInputStream("10_IO\\utf_8.txt"));//不指定默认使用UTF-8
        int len = 0;
        while((len = isr.read())!=-1){
            System.out.println((char)len);//必须强转为char类型，因为你读到的是字节byte是数字，必须转为字符你才能看到里面的汉字
        }

        isr.close();

二十一、序列化流

1.ObjectOutputStream序列化流

构造方法

java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream:对象的序列化流
作用:把对象以流的方式写入到文件中保存

构造方法:
    ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
    参数:
        OutputStream out:字节输出流
特有的成员方法:
    void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("10_IO\\person.txt"));

        oos.writeObject(new Person("小美女",18));

        oos.close();

2.ObjectInputStream反序列化流

java.io.ObjectInputStream extends InputStream
ObjectInputStream:对象的反序列化流
作用:把文件中保存的对象,以流的方式读取出来使用

构造方法:
    ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
    参数:
        InputStream in:字节输入流
特有的成员方法:
    Object readObject() 从 ObjectInputStream 读取对象。

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("10_IO\\person.txt"));
        
        Object o = ois.readObject();//此时读取到的o是Object类型

        ois.close();

        System.out.println(o);//Person{name="小美女",age=18}

        Person p = (Person)o;//o是Object类型，我们强制转换为person类型，这就可以调用person的方法了
        
        System.out.println(p.getName()+p.getAge());//小美女18

二十二、打印流

普通方法：

    java.io.PrintStream:打印流
    PrintStream extends OutputStream
    
    继承自父类的成员方法:
        - public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
        - public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
        - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
        - public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
        - public abstract void write(int b) ：将指定的字节输出流。
    特有的方法：
            void print(任意类型的值)
            void println(任意类型的值并换行)        
        
    注意:
        如果使用继承自父类的write方法写数据,那么查看数据的时候会查询编码表 97->a
        如果使用自己特有的方法print/println方法写数据,写的数据原样输出 97->97

构造方法:

        PrintStream(File file):输出的目的地是一个文件
        PrintStream(OutputStream out):输出的目的地是一个字节输出流
        PrintStream(String fileName) :输出的目的地是一个文件路径

        PrintStream ps = new PrintStream("10_IO\\print.txt");
        ps.write(97);//如果使用继承自父类的write方法写数据,你写的97，打开看就是a
        ps.println(97);//如果使用自己特有的方法print/println方法写数据,写的数据是97，看到的也是97
        
        //释放资源
        ps.close();

System.out.println();一般是打印在控制台的，但使用System.setOut方法可以改变打印的位置
static void setOut(PrintStream out)：参数的目的地在哪里就把文字打印在哪里

        PrintStream ps = new PrintStream("C:\\abc\\abc.txt");
        System.setOut(ps);
        System.out.println("我在打印流的目的地中输出");//控制台不再输出这句话，而是在"C:\\abc\\abc.txt"里面

        ps.close();

二十三、网络编程

Socket类之客户端

TCP通信的客户端:向服务器发送连接请求,给服务器发送数据,读取服务器回写的数据
表示客户端的类:
    java.net.Socket:此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
    套接字:包含了IP地址和端口号的网络单位

构造方法:

    Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。
    参数:
        String host:服务器主机的名称/服务器的IP地址
        int port:服务器的端口号

举例：Socket client = new Socket("127.0.0.1", 6666);

成员方法:

    public InputStream getInputStream() 返回此套接字的输出流。
    public OutputStream getOutputStream() 返回此套接字的输入流。
    public void close() 关闭此套接字。
    public void shutdownOutput() ： 禁用此套接字的输出流。 （先前写出的数据都将被发送，shutdown以后的将被终止）  

实现:

public class TCPClient {
    public static void main(String[] args) throws IOException {
        
        Socket socket = new Socket("127.0.0.1",8888);
        
        OutputStream os = socket.getOutputStream();
        os.write("你好服务器".getBytes());

        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));

        socket.close();
    }
}

Socket类之服务器端

TCP通信的服务器端:接收客户端的请求,读取客户端发送的数据,给客户端回写数据
表示服务器的类:
    java.net.ServerSocket:此类实现服务器套接字。

构造方法:

ServerSocket(int port) 创建绑定到特定端口的服务器套接字。

成员方法:

服务器端必须明确一件事情,必须的知道是哪个客户端请求的服务器
所以可以使用accept方法获取到请求的客户端对象Socket
    Socket accept() 侦听并接受到此套接字的连接。

实现:

public class TCPServer {
    public static void main(String[] args) throws IOException {
        
        ServerSocket server = new ServerSocket(8888);
        Socket socket = server.accept();
        
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes,0,len));
        
        OutputStream os = socket.getOutputStream();
        os.write("收到谢谢".getBytes());
        
        socket.close();
        server.close();
    }
}

二十四、反射

1.获取class对象的方式

获取Class对象的方式：
    1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
    2. 类名.class：通过类名的属性class获取
    3. 对象.getClass()：getClass()方法在Object类中定义着。

//1.Class.forName("全类名")
Class cls1 = Class.forName("cn.itcast.domain.Person");

//2.类名.class
Class cls2 = Person.class;

//3.对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();

//得到的结果都是Class cn.itcast.domain.Person

2.class对象的功能

成员变量的操作：

构造方法的操作：

成员方法的操作

Class获取全类名

* Class对象功能：
	* 获取功能：
		4. 获取全类名	
			* String getName()  

        Class personClass = Person.class;
        System.out.println(personClass); //Class cn.itcast.domain.Person

        String className = personClass.getName();
        System.out.println(className);//cn.itcast.domain.Person