编程语言
首页 > 编程语言> > javaEE(Stream流、日志、IO流、File）

javaEE(Stream流、日志、IO流、File）

作者：互联网

Stream流

简化集合和数组操作的API

List<String> list =new ArrayList<>();
Collection.addAll(list,"张1"，"张2"，"王");
 List<String> list2 -new ArrayList<>();
 for(String name:list){
	if(name.startsWith("张“)){
        list.add(name);
	}
}


list.Stream().filter(s->s.startsWith("张").filter(s->slength()==2)).forEach(s->System.out.print(s));

技术思想：

Stream的获取

default Stream stream() 获得当前集合对象的Stream

日志技术

logback日志框架

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false" scan="true" scanPeriod="1 seconds">
 
    <contextName>logback</contextName>
 
    <property name="log.path" value="F:\\logback.log" />
 
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- <filter class="com.example.logback.filter.MyFilter" /> -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
              <level>ERROR</level>
        </filter>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n
            </pattern>
        </encoder>
    </appender>
 
    <appender name="file"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
        </rollingPolicy>
 
        <encoder>
            <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
            </pattern>
        </encoder>
    </appender>
 
    <root level="debug">
        <appender-ref ref="console" />
        <appender-ref ref="file" />
    </root>
 
    <logger name="com.example.logback" level="warn" />
 
</configuration>

创建logback的日志对象

public static Looger LOGGER=LoggerFactory.getLogger("Test.class");

LOGGER.debug("main方法开始")；
LOGGER.info("我记录的日志第二行")；
LOGGER.trace("a="+a);
LOGGER.error("有错误")；

配置

输出到控制台：

..

日志级别

trace<debug<info<warn<error

File、方法递归、IO流

File类

java.io.File 代表操作系统的文件对象（文件、文件夹）

常用方法：

main(){
    //创建File对象
    //路径写法：D:\\hjz\\a.jpg
    //		   D:/hjz/a.jpg
    //File.separator 分隔符
    //相对路径 相对到工程下 "sprngboot/src/data.txt"
    File f = new File("D:\\hjz\\a.jpg");
    Long a =f.length();//文件的字节大小
    f.exists()//判断文件夹是否存在
}

方法：

File f = new File("D:\hjz\a.jpg");

方法：

删除非空文件夹要写算法

遍历：

File f =new File("D://")
File[] names=f.listFiles();
for(File url:names){
    syso(url.getAbsolutePath);
}

方法递归

1.递归公式

2.递归的终结点

3.递归的方向

1-n的阶乘

public static int f(int n){
    if(n==1){
        return 1;
    }else{
        return f(n-1)*n;
    }
}

1-n的和

public static int f(int n){
    if(n==1){
        return 1;
    }else{
        return f(n-1)+n;
    }
}

猴子吃桃子

/**
		f(x)-f(x)/2-1=f(x+1)
	等价变化：
		f(x)=2f(x+1)+2
	终点 
	f(10)=1
*/
public static int f(int n){
    if(n==10){
        return 1;
    }else{
        return 2*f(n+1)+2;
    }
    
}

文件搜索

1.先定位一级文件对象

2.遍历一遍一级文件对象，判断是否文件

3.如果是文件，判断是否是自己想要的

4.如果是文件夹，需要继续递归进去重复上面的过程

public static void searchFile(File dir,String name){
    if(dir!=null&&dir.isDirectory){
        //可以找了
        //获得一级文件对象
        File[] files=dir.ListFiles();
        //判断一级文件夹的对象
        if(files!=null&&files.length>0){
            for(File f:files){
                //判断当前遍历的一级文件对象是文件还是目录
                if(file.isFile()){
                    //是不是要找的文件
                    if(file.getName().contains(name)){
                        System.out.print("找到了文件是"+file.getAbsolutePath())；
                            //启动它
                            Runtime r =Runtime.getRuntime();
                        r.exe(file.getAbsolutePath());
                    }else{
                        //是文件夹继续递归调用
                        searchFile(file,fileName);
                    }
                }
            }
        }
    }else{
        System.out.print("当前搜索的不是文件夹")；
    }
}

啤酒问题

盖子换酒，瓶子换酒（套娃）

//买的一共酒
public static int totalNumber;
//记录瓶子的数量
public static int lastBottleNumber;
//记录剩余的盖子数目
public static int lastCoverNumber;
public static void buy(int money){
    int buyNumber = money/2;
    totalNumber+=buyNumber;
    //换成钱
    int coverNumber = lastCoverNumber+ buyNumber;
    int bottleNumber=lastBottleNumber+buyNumber;
    //统计一共多少钱
    int allNumber=0;
    if(coverNumber>=4){
        allNumber+=coverNumber/4*2;  
    }
    lastCoverNumber=coverNumber%4;
    if(lastBottleNumber>=2){
        allNumber+=(bottleNumber/2)*2
    }
    lastBottleNumber = bottleNumber%2;
    if(allNumber>=2){
        buy(allNumber);
    }
}

IO流

字符集

ASCII字符集

GBK字符集

Unicode码表

编码前的字符集和编码好的字符集要相同，不然会应为不同的字符位数错误

String编码

String解码

String s ="abc我爱你中国"；
byte[] bytes = s.getBytes();//默认编码
byte[] bytes = s.getBytes("GBK");
String ss=new String(bytes);//默认编码
String ss=new String(bytes，"GBK");

IO流：输入输出流读写数据

读入到内存输入流

写入到磁盘输出流

字节流：

字符流：

字节流

FileInputStream

//1.创建一个输入流管道
//InputStream is =new FileInputStream(new File("D://..."));
//简化
InputStream is =new FileInputStream("D://...");
int b =is.read();//读取一个字节，读完返回-1

Byte[] buffer = new byte[1024];//1kb
InputStream is =new FileInputStream("D://...");
int len =is.read(buffer);
String rs= new String(butter);

常用方法：

Byte[] buffer = new byte[1024];//1kb
InputStream is =new FileInputStream("D://...");
int len=0;
while((len=is.read(butter)!=-1)){
    System.out.print(new String(butter,0,len));
}

中文乱码无法解决

//自己暴力实现
Byte[] buffer = new byte[(int)file.length()];//1kb
File file =new File("D://...");
InputStream is =new FileInputStream(file);
int len=0;
while((len=is.read(butter)!=-1)){
    System.out.print(new String(butter,0,len));
}

Byte[] buffer = is.readAllBytes();//JDK9出现
File file =new File("D://...");
InputStream is =new FileInputStream(file);
int len=0;
while((len=is.read(butter)!=-1)){
    System.out.print(new String(butter,0,len));
}

FileOutPutStream

//写会自动生成
OutputStream os =new FileOutPutStream("D://a.txt");
//OutputStream os =new FileOutPutStream("D://a.txt",true);  追加数据
os.write('a');
os.writ(98);
//写数据必须刷新数据
os.flush();
os.close();//关闭资源
byte[] buffer ={'a',97,98,90};
os.write(buffer);
byte[] buffer ="我是中国人".getBytes("GBK");
os.writer(buffer);
//注意是没有换行的
os.write("\r\n".getBytes());//换行

文件拷贝

学会字节流完成文件的复制--支持一切

try{
   //创建一个字节输入流
   InputStream is =new FileInputStream("D://img.jpg");
    //创建一个字节输出流和目标文件接通
    OutputStream os =new FileOutPutStream("D://a.txt");
   //定义一个字节数组
    byte[] buffer = new byte[1024];
    int len ;记录读取数据的字节数
        while(len=is.read(buffer)!=-1){
            os.write(buffer,0,len);
        }
    //关闭流
    os.close();
    is.close();
}catch (Exception ex){
    e.printStackTrace();
}

资源释放的方式

   InputStream is=null；
   OutputStream os=null；
   
try{
   //创建一个字节输入流
 is =new FileInputStream("D://img.jpg");
    //创建一个字节输出流和目标文件接通
  os =new FileOutPutStream("D://a.txt");
   //定义一个字节数组
    byte[] buffer = new byte[1024];
    int len ;记录读取数据的字节数
        while(len=is.read(buffer)!=-1){
            os.write(buffer,0,len);
        }

}catch (Exception ex){
    e.printStackTrace();
}finally{
        //关闭流
    //下面都要try ---catch---try{..}catch{...}
    //非空校验 if(os!=null){os.close()}
    os.close();
    is.close();
}

JDK7:

try(
	   //创建一个字节输入流
   InputStream is =new FileInputStream("D://img.jpg");
    //创建一个字节输出流和目标文件接通
    OutputStream os =new FileOutPutStream("D://a.txt");
){
   //定义一个字节数组
    byte[] buffer = new byte[1024];
    int len ;记录读取数据的字节数
        while(len=is.read(buffer)!=-1){
            os.write(buffer,0,len);
        }
    //关闭流
    os.close();
    is.close();
}catch (Exception ex){
    e.printStackTrace();
}

JDK9:

不好

字符流

Reader fr=new FileReader("D://img.txt");
Writer fw=new FileWriter("D://a.txt");
int code = fr.read();//每次读取一个字符 没有返回-1

FileReader

常用方法：

问题：

Filewrite

常用方法：

Write fw =new FileWrite("D://img.jpg")；
fw.write('s');

缓冲流

自带缓冲区，提高原始流的性能

自带了8kb的缓冲池

字节缓冲流

构造器：

try(
	   //创建一个字节输入流
   InputStream is =new FileInputStream("D://img.jpg");
    BufferedInputStream bis =new BufferedInputStream(is);
    //创建一个字节输出流和目标文件接通
    OutputStream os =new FileOutPutStream("D://a.txt");
    BufferedOutputStream ois=new BufferedOutputStream(os);
){
   //定义一个字节数组
    byte[] buffer = new byte[1024];
    int len ;记录读取数据的字节数
        while(len=bis.read(buffer)!=-1){
            bos.write(buffer,0,len);
        }
}catch (Exception ex){
    e.printStackTrace();
}

字符缓冲流：

新增输入流方法：

输出流：

转换流

不同编码读取会乱码

转换流：

构造器：

字符输出转换流：

序列化对象

对象字节输出流

ObjectOutputStream

对象字节输入流

ObjectInputStream

构造器：

//对象系列化
//实体类要实现接口
Serialiazble

Student st =new Student (...);
ObjectOutputStream  oos = new ObjectOutputStream (new FileOutputStream("D://a.txt"));
//调用序列化方法
oos.writeObject(st);
oos.close();

//对象反序列化
 ObjectInputStream  ois = new  ObjectInputStream(new FileOutputStream("D://a.txt"));
//调用序列化方法
  Student st=(  Student)ois.readObject(st);
  ois.close();

不想序列化

//实体类属性字段加
private transient String password；

打印流

字节输出流;

PrintStream

字符输出流

PrintWriter

PrintStream

构造器：

方法：

PrintWriter

构造器：

方法：

 PrintStream ps =new  PrintStream("D://s。text");

Propreties

存放键值对的信息

Propreties ps =new Propreties();
ps.setPropreties("admin","123456");
ps.put("password","123456");
ps.store(new FileWriter("D://a.txt","give me 100"))；
//路径，心得
//加载属性到Propreties对象中
ps.load(new FileReader("D://a.txt"));
ps.get("admin");
ps.getPropreties("admin");

IO框架

我醉了经典白学

commonis-io

FileUtils

NIO

Files.copy(Path.of(""),Path.of(""));
Files.deleteIfExists(Path.of(""))

标签：String,int,File,javaEE,IO,new,public,字节
来源： https://www.cnblogs.com/HJZ114152/p/16406709.html