不会有太多解释，直接贴图，我这是复习，以前大学学过Java

1、hello world

开发三步骤
编写程序、编译程序、运行程序

javac 编译Java文件，然后Java 运行

2、基础运算

略

3、三元运算符

a > b ? a : b ;
如果a>b ->true，则结果为a，如果a>b ->false，则结果为b
如下，输出结果为20

三个和尚案例

4、数据输入

import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int weight1 = sc.nextInt();

import java.util.Scanner;
public class sannerTest{
        public static void main(String[] args){
                Scanner sc = new Scanner(System.in);
                System.out.println("shurudi1getizhong");
                int weight1 = sc.nextInt();
                System.out.println("shurudi2getizhong");
                int weight2 = sc.nextInt();
                System.out.println("shurudi3getizhong");
                int weight3 = sc.nextInt();
                int tempweight = weight1 > weight2 ? weight1 : weight2 ;
                int topweight = tempweight > weight3 ? tempweight : weight3 ;
                System.out.println("topweight:" + topweight);
        }
}

5、分支运算

1、流程控制语句分类

顺序结构-就正常从上往下
分支结构 if , switch
循环结构for ，while ，do…while

2、分支结构

1、分支结构-if

import java.util.Scanner;
public class ifdemo05{
        public static void main(String[] args){
                System.out.println("helloworld");
                Scanner sc = new Scanner(System.in);
                int a = sc.nextInt();
                if (a >= 95 && a <= 100) {
                    System.out.println("car");
                }
                else if(a >= 90 && a <= 94) {
                    System.out.println("youlechang");
                }
                else if(a >= 80 && a <= 89) {
                    System.out.println("wangju");
                }
                else if(a <= 79) {
                    System.out.println("shijuan");
                }
                else {
                    System.out.println("yiwai");
                }
        }
}

2、分支结构switch

switch如果在命中case后，没有写break，会执行下一个case执行后break，前提是下一个case有break

import java.util.Scanner;
public class switchdemo02{
        public static void main(String[] args){
                System.out.println("helloworld");
                Scanner sc = new Scanner(System.in);
                int a = sc.nextInt();
                switch (a) {
                        case 1:
                        case 2:
                        case 12:
                        System.out.println("chuntian");
                        break;        
                        case 3:
                        case 4:
                        case 5:
                        System.out.println("xiatian");    
                        break;    
                        case 6:
                        case 7:
                        case 8:
                        System.out.println("qiutian");
                        break;        
                        case 9:
                        case 10:
                        case 11:
                        System.out.println("dongtian");    
                        break;    
                        default:
                            System.out.println("Error");
                            break;
                }
        }
}

3、循环结构

1、循环结构for

水仙花-三位-演示

public class shuixianhua{
        public static void main(String[] args){
                int count = 0;
                for (int i = 100; i < 1000 ; i++ ) {
                    int g = i%10 ;
                    int s = i/10%10;
                    int b = i/10/10%10;
                    if (g*g*g + s*s*s + b*b*b == i) {
                        count++;
                        System.out.println(i);
                    }    
                }
                System.out.println(count);
        }
}

2、while

在不确定上限的情况下可以使用while

public class whiledemo01{
        public static void main(String[] args){
                System.out.println("helloworld");
                double paper = 0.1;
                int zf = 8844430;
                int count = 0;
                while (paper <= zf) {
                    paper *= 2;
                    count++;
                }
                System.out.println(count);
        }
}

3、do…while

public class dowhile{
        public static void main(String[] args){
                System.out.println("helloworld");
                int j = 1;
                do{
                    System.out.println(j);
                    j++;
                }while(j <= 5);
        }
}

4、区别

4、跳转控制语句

continue和break使用在循环体中，一个是跳转出来继续循环，一个是直接结束

public class tiaozhuandemo{
        public static void main(String[] args){
                System.out.println("helloworld");
                for (int i = 1; i <= 5 ; i++ ) {
                    if (i%2 == 0) {
                        continue;
                        //break;
                    }
                    System.out.println(i);
                }
        }
}

5、循环嵌套

4、random

获取随机数

random-猜数字

import java.util.Random;
import java.util.Scanner;
public class caishuzi{
        public static void main(String[] args){
                System.out.println("helloworld");
                Random r = new Random();
                int num = r.nextInt(100)+1;
                while(true){
                    Scanner sc = new Scanner(System.in);
                    System.out.println("plzinput:");
                    int guessNum = sc.nextInt();
                    if (guessNum > num) {
                        System.out.println("morethan");
                    }else if (guessNum < num) {
                        System.out.println("lessthan");
                    }else {
                        System.out.println("right");
                        break;
                    }
                }
        }
}

n、比较器 Comparator

package l;
import java.util.Comparator;
import java.util.TreeSet;
public class chengjipaiming {
    public static void main(String[] args) {
        TreeSet<student> ts = new TreeSet<student>(new Comparator<student>() {
            @Override
            public int compare(student s1, student s2) {
                //int num = (s2.getChinese() + s2.getMath()) - (s1.getChinese() + s1.getMath());
                //上面这种求和的方法有些麻烦，可以在学生类里面提供一个求和的方法
                //传入的两个值进行比较，如果返回的是一个正数，说明前值比后值大
                //compare 方法  如果大于零，则把前一个数和后一个数交换 升序
                //此处，首先不用在意具体传入的，根据s1.getSum()代表的是前一个数，s2.getSum()的是后一个数
                // 因此这是在判断升序，可以使用后一个减前一个进行查看测试是否降序
                int num = s1.getSum()-s2.getSum();
//                int num = s1.getSum()-s2.getSum();
//                int num = 1;
                return num;
            }
        });
        student s1 = new student("lww",18,98,88);
        student s2 = new student("kww",18,100,100);
        student s3 = new student("jww",18,66,66);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        for (student s : ts){
            System.out.println(s.getName()+" "+s.getSum());
        }
    }
}

n map-HashMap

/**
 * 键是学生对象student,值是居住地String
 * 存储多个键值对对象
 * 遍历
 * 要求：保证键的唯一性：如果学生对象的成员变量值相同，就认为是同一个对象
 * hashmap底层是hash表，是保证键的唯一性，需要在学生类里面重写以下两个方法
 * hashCode()
 * equals()
 *
 * **/
package mapjihe;
import java.util.HashMap;
import java.util.Set;
public class hashmapdemo {
    public static void main(String[] args) {
        HashMap<student,String> hm = new HashMap<student,String>();
        student s1 = new student("周旋久",18);
        System.out.println(s1);
        student s2 = new student("林青霞",16);
        student s3 = new student("刘亦菲",16);
        //和上面的相同,按要求要保持唯一性,在student类里面重写方法保证,下面往集合对象中添加的时候,则会覆盖,杭州覆盖上海
        student s4 = new student("刘亦菲",16);
        hm.put(s1,"北京");
        hm.put(s2,"天津");
        hm.put(s3,"上海");
        hm.put(s4,"杭州");
        //这里注意,keySet()是返回所有键的集合,我们前面设置的是student是键
        Set<student> ks = hm.keySet();
        for (student k : ks){
            String value = hm.get(k);
            //这里因为键是学生对象,所以这里会打印这个学生对象的地址
            System.out.println(k);
            System.out.println("---------------1");
            //输出对象集合ks里面的值
            System.out.println(k.getName());
            System.out.println(k.getAge());
            System.out.println("---------------2");
            //value是根据键找到的值,所以会打印出前面的学生的地址,即北京等
            System.out.println(value);
            System.out.println("---------------3");
            //完整输出
            System.out.println(k.getName()+","+k.getAge()+","+value);
            System.out.println("---------------循环一轮");
        }
    }
}

n+2 ArrayList嵌套HashMap

/**
 * 创建一个ArrayList集合,存储三个元素,每一个元素都是HashMap,每一个HashMap的键值都是String,
 * 遍历集合
 * <p>
 * 思路:
 * 1 创建ArrayList集合
 * 2 创建HashMap集合,并添加键值对元素
 * 3 把HashMap作为元素添加到ArrayList集合
 * 4 遍历
 **/
package mapjihe;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class hashmapdemo01 {
    public static void main(String[] args) {
        ArrayList<HashMap<String, String>> arrayList = new ArrayList<HashMap<String, String>>();
        HashMap<String, String> hm1 = new HashMap<String, String>();
        hm1.put("刘亦菲", "胡歌");
        hm1.put("唐嫣", "霍建华");
        hm1.put("lyh", "lww");
        HashMap<String, String> hm2 = new HashMap<String, String>();
        hm1.put("刘亦菲1", "胡歌1");
        hm1.put("唐嫣1", "霍建华1");
        hm1.put("lyh1", "lww1");
        HashMap<String, String> hm3 = new HashMap<String, String>();
        hm1.put("刘亦菲2", "胡歌2");
        hm1.put("唐嫣2", "霍建华2");
        hm1.put("lyh2", "lww2");
        arrayList.add(hm1);
        arrayList.add(hm2);
        arrayList.add(hm3);
        //这里hm本身就是一个hashmao集合,不能直接输出hm
        for (HashMap<String, String> hm : arrayList) {
            //先获取hashmap集合的键的集合
            Set<String> keyset = hm.keySet();
            for (String ky : keyset) {
                //这里需要注意,keyset中是键的集合,所以需要通过hm获取hashmap集合中的值
                String value = hm.get(ky);
                System.out.println(ky + ":" + value);
            }
        }
    }
}

n+3 HashMap嵌套ArrayList

/**
 * 创建一个Hashmap集合,存储三个键值对元素,每一个元素的键是String,值是ArrayList,每一个ArrayList的元素都是String,
 * 遍历集合
 *
 * **/
package mapjihe;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class hashmapdemo02 {
    public static void main(String[] args) {
        HashMap<String,ArrayList<String>> hm = new HashMap<String,ArrayList<String>>();
        ArrayList<String> array1 = new ArrayList<String>();
        array1.add("可口可乐");
        array1.add("百世可乐");
        ArrayList<String> array2 = new ArrayList<String>();
        array2.add("kfc");
        array2.add("麦当劳");
        ArrayList<String> array3 = new ArrayList<String>();
        array3.add("雪花");
        array3.add("青岛");
        hm.put("饮料",array1);
        hm.put("食品",array2);
        hm.put("酒",array3);
        Set<String> ky = hm.keySet();
        for (String k : ky){
            ArrayList<String> value = hm.get(k);
            System.out.println(k);
            for (String s : value){
                System.out.println("\t"+s);
            }
            System.out.print("\n");
        }
    }
}

n+4 HashMap计算字符串内某一字符出现次数

/**
 * 统计字符串中每个字符出现的次数
 * 思路
 * 键盘录入一个字符
 * 创建hashmap集合 键是chaarater 值是integer
 * 遍历字符串，得到每一个字符
 * 拿到的每一个字符 作为 键 到 hashmap集合中去找对应的值，看其返回值
 *      如果返回值是null,说明该字符在hashmap集合中不存在，就把该字符作为键，1作为值存储
 *      如果返回值不是null,说明该字符在hashmap集合中存在，把该值加1，然后重新存储该字符和对应的值
 *  遍历hashmap集合，得到键和值，按照要求进行拼接
 * **/
package mapjihe;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class hashmapdemo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();
        HashMap<Character,Integer> hm = new HashMap<Character,Integer>();
        //TreeMap和HashMap用法一样，不过它默认会自动排序结果，不是无序
//        TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
        //遍历字符串，得到每一个字符
        //输入字符aac
        for (int i = 0; i<line.length();i++){
            //a  a c  会依次提取出来
            char key = line.charAt(i);
            //拿到的每一个字符作为键到hashmap集合中去找对应的值，看其返回值
            //这里面有一个自动装箱动作，暂时不理他，具体原理记不清了
            //注意这个地方，实际上是已经在查hashmap集合中是否存在这个key了
            //比如，第一个a 这里就是Integer value = hm.get(a),查找key a的值
            //很明显，之前没有存储，这里查找key a 是没有对应的值的，是null  打印查看确实是null
            Integer value = hm.get(key);
            System.out.println(value);
            if (value == null){
                //注意，这里1就是value
                //因为当第一个key a查值后，就进入了if语句，key 就是 a ,这里实际是hm.put(a,1);
                //因此，这个1，就是value
                //所有else部分的value,在第二个a进入的时候，发现key a 是存在值value的，值是1，所以可以value++
                hm.put(key,1);
            }else {
                //如果返回值不是null,说明该字符在hashmap集合中存在，把该值加1，然后重新存储该字符和对应的值
                //自动拆箱
                value++;
                System.out.println("wy"+value);
                hm.put(key,value);
                System.out.println(hm.get(key));
            }
        }
        //遍历hashmap集合，得到键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet){
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String res = sb.toString();
        System.out.println(res);
    }
}

n+5 ArrayList存储学生对象，使用Collections对ArrayList进行排序

/**
 * 需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
 * 按照年龄从小到大进行排序，年龄相同时，按照姓名的首字母顺序排序
 *
 * 思路：
 *1、定义学生类
 * 2、创建arraylist集合对象
 * 3、创建学生对象
 * 4、把学生添加到集合
 * 5、使用Collections对ArrayList集合排序
 * 遍历集合
 *
 * **/
package collectionsdemo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class collectionsdemo2 {
    public static void main(String[] args) {
        ArrayList<student> arrayList = new ArrayList<student>();
        student s1 = new student("liuyifei",18);
        student s2 = new student("linqingxia",30);
        student s3 = new student("nazha",18);
        student s4 = new student("luoyihua",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        //使用collections对ArrayList集合进排序
        //会报错，因为这个是自然排序的，列表中的所有元素都必须实现Comparable接口。我们需要到类中重写。 不用这个方法
//        Collections.sort(arrayList);
        //public static <T> void sort(List<T> list, Comparator<? super T> c)
        //根据指定比较器引发的顺序对指定列表进行排序。
        //使用内部类的形式进行比较
        Collections.sort(arrayList, new Comparator<student>() {
            @Override
            public int compare(student s1, student s2) {
                //按照年龄从小到大进行排序，年龄相同时，按照姓名的首字母顺序排序
                int num = s1.getAge()-s2.getAge();
                int num2 = (num==0)?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        //遍历集合
        for (student s : arrayList){
            System.out.println(s.getAge()+","+s.getName());
        }
    }
}

n+6 斗地主简单案例发牌洗牌看牌

/**
 * 使用一个hashmap进行牌的存储（编号：牌值），使用一个arraylist进行牌的编号存储，使用treemap进行用户拿到的牌的有序排序
 * 这样对编号进行treemap排序，那么读取出来的就是按照编号顺序去hashmap里面读取
 * **/
package doudizhu;
import java.util.*;
public class pokerdemo1 {
    public static void main(String[] args) {
        //创建HashMap 键是编号，值是牌
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        //创建ArrayList 存储编号
        ArrayList<Integer> array = new ArrayList<Integer>();
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A","2"};
        //从0开始往HashMap里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号
        int index =0;
        for (String number :numbers){
            for (String color:colors){
                hm.put(index,color+number);
                array.add(index);
                index++;
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index,"大王");
        array.add(index);
        //洗牌，洗的是编号
        Collections.shuffle(array);
        //发牌（发的也是编号，为了保证排序，创建TreeSet集合）
        TreeSet<Integer> lqxSet = new TreeSet<Integer>();
        TreeSet<Integer> lySet = new TreeSet<Integer>();
        TreeSet<Integer> fqySet = new TreeSet<Integer>();
        TreeSet<Integer> dpSet = new TreeSet<Integer>();
        //注意，以下是对索引进行操作
        // 这里也可以直接使用i，但是会让代码可读性变低，因此多写一行x,x获取的就是array集合里面存放的索引
        for (int i =0;i<array.size();i++){
            int x = array.get(i);
            if (i>=array.size()-3){
                dpSet.add(array.get(x));
            }else if (i%3==0){
                lqxSet.add(x);
            }else if (i%3==1){
                lySet.add(x);
            }else if (i%3==2){
                fqySet.add(x);
            }
        }
        //看牌
        lookpoker("lqx",lqxSet,hm);
        lookpoker("ly",lySet,hm);
        lookpoker("fqy",fqySet,hm);
        lookpoker("dp",dpSet,hm);
    }
    //定义方法看牌
    public static void lookpoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.println(name + "的牌是：");
        for (Integer key :ts){
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

n+7 递归求阶乘

/**
 * 递归求5的阶乘
 * 分析：
 * 阶乘：5！=5*4*3*2*1
 * 递归出口：1！=1
 * 递归规则：n!=n*(n-1)!  即 5!=5*4!=5*4*3!=5*4*3*2!=5*4*3*2*1
 * 当1!=1的时候，会结束递归
 * **/
package diguidemo;
public class diguidemo01 {
    public static void main(String[] args) {
        int res = jc(3);
        System.out.println("5的阶乘是：" + res);
    }
    //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    /**
     * 分析：
     * 假设我们传入一个n=3
     * jc(3)-->3*jc(3-1)
     * 注意，这个时候，jc(3)这个方法是被调用中，因为返回的里面有一个调用了jc(2)
     * 所以，jc(3)是还在被调用中的，它需要等jc(2)计算完，返回值后，jc(3)使用了该返回值后，方法才调用完毕，从栈内存中结束
     * jc(2)-->2*jc(2-1)
     * 同理上面的
     * jc(1)-->n=1-->1
     *
     * 返回
     * jc(3)等待jc(2)的结果
     * jc(2)等待jc(1)的结果
     * jc(1)返回1给jc(2)
     * jc(2)得到jc(1)的值，完成了jc(2)的计算，得到一个值，返回给jc(3)
     * jc(3)得到jc(2)返回的值，完成jc(3)的计算，得到一个值，这个值就是3的阶乘
     *
     * jc(1)=1  1返回给jc(2)
     * jc(2)=2*jc(2-1)=2*1=2  2返回给jc(3)
     * jc(3)=3*jc(3-1)=3*2=6
     *
     * **/
    public static int jc(int n){
        //在方法内部判断该变量的值是否是1
        if (n==1){
            //是 返回1
            return 1;
        }else {
            //不是 返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}

n+8 递归遍历目录

/**
 * 递归输出目录
 * D:\burp
 * 步骤：
 * 1、根据给定的路径创建一个File对象
 * 2、定义一个方法，用于获取给定目录下的所有内容，参数为第一步的File对象
 * 3、获取给的目录下面的所有文件或者目录的File数组
 * 4、遍历该数组，得到每一个File对象
 * 5、判断File对象是否是目录
 *      是，递归调用
 *      不是，获取绝对路径输出
 * 6、
 * **/
package diguidemo;
import java.io.File;
public class diguidemo02 {
    public static void main(String[] args) {
        File srcFile = new File("D:\\burp");
        //调用写好的递归查询目录文件方法,该方法写了传参对象是File对象
        getAllFilePath(srcFile);
    }
    //定义一个方法，用于获取给定目录下的所有内容，参数为第一步的File对象
    public static void getAllFilePath(File srcaFile){
        //获取给的目录下面的所有文件或者目录的File数组
        File[] fileArray = srcaFile.listFiles();
        //遍历该数组，得到每一个File对象
        if (fileArray != null){
            for (File file : fileArray){
                //判断是File对象是否是目录
                if (file.isDirectory()){
                    //是目录则递归调用方法
                    getAllFilePath(file);
                }else {
                    //不是目录，则获取绝对路径进行输出
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

IO流

IO-字节流readme

IO流分类：
按数据流方向
    1、输入流：读数据
    2、输出流：写数据
按照数据类型来分
    1、字节流：
        字节输入流，字节输出流
    2、字符流：
        字符输入流，字符输出流
一般情况，我们说的IO流的分类是按照数据类型来分的
如何判断什么情况使用什么流：
    如果使用windows自带的记事本软件打开，可以读懂，就是用字符流
    否则使用字节流
    如果不知道该使用哪种类型的流，就是用字节流
一、字节流
1、输入流
public abstract class InputStream
extends Object
implements Closeable
此抽象类是表示输入字节流的所有类的超类。
已知直接子类：
AudioInputStream ， ByteArrayInputStream ， FileInputStream ， FilterInputStream ， ObjectInputStream ，
PipedInputStream ， SequenceInputStream ， StringBufferInputStream
文件输入流
FileInputStream用于读取诸如图像数据的原始字节流
FileInputStream(String name)
通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的路径名 name命名。
2、输出流
public abstract class OutputStream
extends Object
implements Closeable, Flushable
此抽象类是表示输出字节流的所有类的超类。 输出流接受输出字节并将它们发送到某个接收器。
已知直接子类：
ByteArrayOutputStream ， FileOutputStream ， FilterOutputStream ， ObjectOutputStream ， PipedOutputStream
文件输出流
FileOutputStream用于写入诸如图像数据的原始字节流
3、字节缓冲流
提高读写效率
缓冲输出流
Class BufferedOutputStream
java.lang.Object
    java.io.OutputStream
        java.io.FilterOutputStream
            java.io.BufferedOutputStream
实现的所有接口
Closeable ， Flushable ， AutoCloseable
public class BufferedOutputStream
extends FilterOutputStream
该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以将字节写入基础输出流，而不必为写入的每个字节调用底层系统。
缓冲输入流
Class BufferedInputStream
    java.lang.Object
        java.io.InputStream
        java.io.FilterInputStream
            java.io.BufferedInputStream
public class BufferedInputStream
extends FilterInputStream
BufferedInputStream向另一个输入流添加功能 - 即缓冲输入并支持mark和reset方法的功能。 
创建BufferedInputStream将创建内部缓冲区阵列。 当读取或跳过来自流的字节时，
内部缓冲区根据需要从包含的输入流中重新填充，一次多个字节。 mark操作会记住输入流中的一个点，
并且reset操作会导致在从包含的输入流中获取新字节之前重新读取自最近的mark操作以来读取的所有字节。
缓冲流的构造方法：
BufferedInputStream(InputStream in)    
创建一个 BufferedInputStream并保存其参数，即输入流 in ，供以后使用。
BufferedOutputStream(OutputStream out)    
创建新的缓冲输出流以将数据写入指定的基础输出流。
注意：缓冲流需要的是字节流，而不是具体的文件或者路径
因为字节缓冲流仅仅提高缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

IO-字节流写数据

/**
 * 数据读写操作练习
 *  FileOutputStream用于写入诸如图像数据的原始字节流
 *  FileOutputStream(String name)：创建文件输出流以写入具有指定名称的文件。
 **/
package diguidemo;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
//下面这个是上面FileNotFoundException的父类，所以上面的会变灰色
import java.io.IOException;
public class iodemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //创建着对象，会做三个事情：
        // 1、调用系统功能创建文件
        // 2、创建了字节输出流对象
        // 3、让字节输出流对象指向创建好的文件
        FileOutputStream fos = new FileOutputStream("javaSdemo\\src\\diguidemo\\fos.txt");
        //    write(int b)
        //将指定的字节写入此文件输出流。在文件中看到的是a  a的字节数是97
        fos.write(97);
        //所有io相关的操作，都要释放资源
        fos.close();
    }
}

IO-字节流写数据的三种方法

/**写数据的三种方式**/
package iodemo;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class iodemoh01 {
    public static void main(String[] args) throws IOException {
        //第一种创建文件输出流对象的方法
        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos.txt");
        /**
         * public FileOutputStream(String name) throws FileNotFoundException {
         *         this(name != null ? new File(name) : null, false);
         *     }
         *  **/
        //上面这个等于下面这个
//        FileOutputStream fos = new FileOutputStream(new File("xiayijieduan\src\iodemo\fos.txt"));
        //第二种创建文件输出流对象的方法
//        FileOutputStream(File file): 创建文件输出流以写入由指定的File对象表示的文件
        File file = new File("xiayijieduan\\src\\iodemo\\fos.txt");
        FileOutputStream fos2 = new FileOutputStream(file);
        //上面这两个加起来就是下面着
//        FileOutputStream fos2 = new FileOutputStream(new File("xiayijieduan\src\iodemo\fos.txt"));
        //观察可以发现，这个和第一个是一样的，所以直接用第一个，是最方便的
        //void write(int b)  方式1
//        fos.write(97);
//        fos.write(98);
        //void write(byte[] b)  方式2
//        byte[] bys = {97,98,99,100,101};
//        fos.write(bys);
//        byte[] bys = "abcdef".getBytes(StandardCharsets.UTF_8);
//        fos.write(bys);
        //void write(byte[] b,int off,int len)
        byte[] bys = "abcdef".getBytes(StandardCharsets.UTF_8);
        fos.write(bys,1,3);
        fos.close();
    }
}

IO-字节流写数据：换行 追加

/**
 * 追加
 * 换行
 * **/
package iodemo;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class iodemoh02 {
    public static void main(String[] args) throws IOException {
//        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos1.txt");
        //使用构造方法进行追加操作
        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos1.txt",true);
        for (int i = 0;i<10;i++){
            fos.write("hello".getBytes(StandardCharsets.UTF_8));
            //这种方式，在idea里面看是换行了，但是在windows上面看，是没有换行的
            /**
             * 换行
             * window：\r\n
             * linux:\n
             * mac:\r
             * **/
            fos.write("\r\n".getBytes(StandardCharsets.UTF_8));
        }
        fos.close();
    }
}

IO-字节流写数据-异常处理-finally

package iodemo;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class iodemoh03 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos2.txt", true);
            fos.write("hello".getBytes(StandardCharsets.UTF_8));
            fos.close();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fos != null){
                try {
                    fos.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

IO-读数据

/**
 *
 * 字节流读取数据
 *
 * **/
package iodemo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class iodemoh04 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("xiayijieduan\\src\\iodemo\\fos1.txt");
        //调用字节输入流对象的读数据方法
        //int read() : 从该输入流读取一个字节的数据,如果文件到达末尾，返回值是-1
        //第一次读取数据
//        int by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);
//        //第二次读取数据
//        by = fis.read();
//        System.out.println(by);
//        System.out.println((char)by);
        //循环写 方式1
//        int by = fis.read();
//        while (by != -1){
////            System.out.print(by);
//            System.out.print((char)by);
//            by = fis.read();
//        }
        //循环写 方式2
        int by;
        while ((by=fis.read()) != -1){
            System.out.print((char) by);
        }
        //释放资源
        fis.close();
    }
}

IO-简单复制

/**
 * 复制文件
 *
 *
 * **/
package iodemo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class iodemoh05 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("xiayijieduan\\src\\iodemo\\fos1.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos2.txt");
        //读写数据
        int by;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

IO-字节流读数据，一次读一个字节数组数据

/**
 * 字节流读数据，一次读一个字节数组数据
 *
 * 使用字节输入流读数据的步骤
 *  创建字节输入流对象
 *  调用字节输入流对象的读数据方法
 *  释放资源
 *
 * **/
package iodemo;
import java.io.FileInputStream;
import java.io.IOException;
public class iodemoh06 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("xiayijieduan\\src\\iodemo\\fos1.txt");
        /**
        //调用方法读数据
        //int read(byte[] b)  从该输入流读取最多b.length个字节的数据 到 一个字节数组。  下面的b.length就是被设定成5个字节
        byte[] bys = new byte[5];
        //第一次读取数据
        //这里的len是读取到的数据的字节个数，而不是上面写的字节数组的长度
        int len = fis.read(bys);
        System.out.println(len);  //输出5
        //读取的过来的是字节数组，转换
        System.out.println(bys);
        System.out.println(new String(bys));
        System.out.println("------------");
        //第二次读取数据
        len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys));
        System.out.println("------------");
        //第三次读取数据
        len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys));
//        //读取从0到能读取到的字节个数，上面可以看出，因为源文件中只剩下4个字节没有被读取，所以len是4，只会读4个数据，输出的时候，没有上一个的r
//          上面的都应该变成这种写法
//        System.out.println(new String(bys,0,len));
        System.out.println("------------");
        /**
         * 其实读取的内容是：
         *      hello\r\n
         *      world\r\n
         *
         * 第一次读取：
         *      hello
         * 第二次读取：
         *      \r\nwor
         * 第三次读取：
         *      ld\r\nr
         * 第三次的最后一个r是因为第一次读取的数据，存放了5个字节的的数据 到 字节数组bys中 -->hello
         * 第二次读取，也有5个字节的数据 \r\nwor  覆盖了 hello  这时bys中 -->\r\nwor
         * 第三次读取，源文件就只有 ld\r\n  只有4个数据，不能全部覆盖，就会留下来一个r -->ld\r\nr
         * 使用别的方法可以读了几个就写几个
         *  public String(byte[] bytes,
         *               int offset,
         *               int length)
         *
         *
         * **/
        //循环改进代码
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1){
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

IO-复制图片

/**
 * 复制图片
 * 思路
 * 根据数据源创建字节输入流对象
 * 根据目的地创建字节输出流对象
 * 读写数据，复制图片，一次读取一个字节数组，一次写入一个字节数组
 * 释放资源
 * **/
package iodemo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class iodemoh07 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("C:\\Users\\77239\\Pictures\\Saved Pictures\\11.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\11.jpg");
        //读写数据，复制图片，一次读取一个字节数组，一次写入一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

IO-缓冲字节流.读写数据

package iodemo;
import java.io.*;
import java.nio.charset.StandardCharsets;
public class iodemoh08 {
    public static void main(String[] args) throws IOException {
        //BufferedOutputStream(OutputStream out)
        //先创建一个文件输出流对象
//        FileOutputStream fos = new FileOutputStream("xiayijieduan\\src\\iodemo\\fos1.txt");
//            再创建一个字节缓冲输出流对象
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //上面可以写成下面这个
        //写数据
        /*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("xiayijieduan\\src\\iodemo\\fos3.txt"));
        //写数据
        bos.write("hello\r\n".getBytes(StandardCharsets.UTF_8));
        bos.write("javaworld\r\n".getBytes(StandardCharsets.UTF_8));
        bos.close();
         */
        //读数据,同理写数据
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("xiayijieduan\\src\\iodemo\\fos3.txt"));
        //读取方式1 一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1){
//            System.out.print((char) by);
//        }
        //读取方式2 一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        bis.close();
    }
}

IO-字节流复制视频

package IOdemo;
import java.io.*;
public class CopyAvdemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();
        //复制视频
        method1();//耗时40352毫秒
//        method2();//耗时100毫秒
//        method3();//耗时232毫秒
//        method4();//耗时32毫秒
        //记录结算时间
        long endTime = System.currentTimeMillis();
        System.out.println("耗时"+(endTime-startTime)+"毫秒");
    }
    //方法4 字节缓冲流，一次读写一个字节数组
    public static void method4() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\workspace\\video\\datui01.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\workspace\\video1\\datui04.mp4"));
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }
    //方法3 字节缓冲流，一次读写一个字节
    public static void method3() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\workspace\\video\\datui01.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\workspace\\video1\\datui03.mp4"));
        int by;
        while ((by=bis.read())!=-1){
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
    //方法2 基本字节流，一次读写一个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\workspace\\video\\datui01.mp4");
        FileOutputStream fos = new FileOutputStream("D:\\workspace\\video1\\datui02.mp4");
        byte[] by = new byte[1024];
        int len;
        while ((len=fis.read(by))!=-1){
            fos.write(by,0,len);
        }
        fis.close();
        fos.close();
    }
    //方法1、基本字节流，一次读写一个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\workspace\\video\\datui01.mp4");
        FileOutputStream fos = new FileOutputStream("D:\\workspace\\video1\\datui01.mp4");
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }
}