java –IO流

java –IO流

本章内容

1,file类

2,递归

3,IO流

4,字符流,字符缓冲区

5,装饰者模式

6,字节流,字节流缓冲区

7,转换流

8,其他流

9,编码问题

一、file类

  1. 用来将文件或者文件夹封装成对象
  2. 方便对文件与文件夹的属性信息进行操作
  3. FILe能新建,删除,重命名文件与目录,但file不能访问文件内容

      File(String pathname)
      可以把一个存在或者不存在的文件(文件目录)封装成一个对象
    
      File(String parent, String child)

      File(File parent, String child)

 

      判断:
     * exists() 判断文件或者文件夹是否存在
     * isDirectory() 判断文件对象是不是一个文件夹
     * isFile()   判断文件对象是不是一个文件
     * isAbsolute() 判断当前路径是不是绝对路径
     * isHidden() 判断文件是否隐藏

    

       获取类方法
     * getAbsolutePath() 获取文件的绝对路径,返回路径字符串
     * getAbsoluteFile() 获取文件的绝对路径,返回File对象
     * getParentFile() 获取当前路径的父路径,以File对象的形式返回父路径
     * getParent()   获取当前路径的父路径,以字符串形式返回父路径
     * getPath()    获取当前路径
     * getName()    获取当前文件或文件夹名称
     * lastModified()  获取文件最后修改时间
     * length()        获取文件长度
     * getTotalSpace()  获取分区总大小
     * renameTo(File newFile) 给文件改名字

    * list()  以字符串形式返回当前路径下的所有文件和文件夹
     * listFiles() 以File对象的形式返回当前路径下的所有文件和文件夹
     

package Test1;

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.junit.Test;

public class Demo {
	/*
	 * File(String pathname)
	 * 可以把一个存在或者不存在的文件(文件目录)封装成一个对象
	 * 
	 * File(String parent, String child)
	 
	 *File(File parent, String child)
	 */
	@Test
	public  void testConstructor(){
		// /斜杠 \反斜杠
		File f1 = new File("E:/practice/b.txt");//绝对路径
		File f2 = new File("E:/xxxx");
		
		File f3 = new File("E:/practice","b.txt");
		File parent = new File("E:/practice");
		File f4 = new File(parent,"b.txt");
		
	}
	/*
	 * 创建和删除文件:
	 * 
	 * CreateNewFile() 指定的文件不存在,就创建文件返回true,否则false
	 * mkdir() 创建单级文件夹
	 * mkdirs() 创建多级文件夹
	 * 
	 * delete() 删除单个文件或者多个文件夹
	 */
	
	@Test
	public void testCreateAndDelete() throws IOException{
		File f = new File("F:/pp");
		boolean flag = f.createNewFile();
		System.out.println(flag);
//		boolean mkidir = f.mkdirs();
//		System.out.println(mkidir);
//		boolean delete = f.delete();
//		System.out.println(delete);
	}
	/*
	 * 判断
	 * exists() 判断文件或者文件夹是否存在
	 * isDirectoery()判断文件对象是不是文件
	 * isFile() 判断文件对象是不是一个文件
	 * isAbsolute();
	 * isHidden();
	 * 
	 * 
	 */
	@Test
	public void testPanduan(){
		 File f1 = new File("F:/pp");
//		 boolean exists = f1.exists();
//		System.out.println(exists);
//		boolean directory = f1.isDirectory();
//		System.out.println(directory);
//		 boolean file = f1.isFile();
//		 System.out.println(file);
		 boolean file = f1.isAbsolute();
		 boolean hidden = f1.isHidden();
		 System.out.println(file);
	}
	/*
	 * 获取类方法
	 * getAbsoluteFile()   获取文件的绝对路径, 返回Flle对象
	 * getAbsolutePath() 获取文件的绝对路径,返回路径字符串
	 * getParentFile() 获取当前路径的父路径,以File对象的形式返回路径
	 * getPath() 获取当前路径
	 * getName() 获取当前文件夹或文件的名称
	 * lastModified() 获取文件最后修改时间
	 * length() 获取文件的长度
	 * getTotalSpace() 获取文件占用磁盘的大小,分区的大小
	 */
	@Test
	public void  testGet(){
		File f1 = new File("F:/pp");
		File f2 = new File("F:/xcc");
		File absoluteFile = f1.getAbsoluteFile();
		String absolutePath = f1.getAbsolutePath();
		File parentFile = f1.getParentFile();
		String path = f1.getPath();
		String name = f1.getName();
		long lastModified = f2.lastModified();
		long length = f1.length();
		long totalSpace = f2.getTotalSpace();
		boolean renameTo = f1.renameTo(f2);
		System.out.println(renameTo);
		
		Date d = new Date(lastModified);
		System.out.println(d.toLocaleString());
		System.err.println(totalSpace);
		
	}
	
	/*
	 * List() 以字符串形式返回当前路径下的所有 文件和文件夹
	 *  ListFiles 以File对象的形式返回当前路径下的所有文件和文件夹
	 *  
	 * 
	 */
	@Test
	public void testList(){
		File f = new File("F:/K/A");
		String[] list = f.list();
		for(String str : list){
			System.out.println(str);
		}
		System.out.println();
		System.out.println();
		
		File[] listFiles = f.listFiles();
		for(File file : listFiles){
			System.out.println(file.getName());
		}
		System.out.println();
		System.out.println(listFiles.length);
	}
	
	
}

2,递归

为了求一个数值,不断的调用本身。。具体内容前面有,这里就不赘述了

例一:递归

package Digui;

public class Demo {
	public static void main(String[] args) {
		int result = jiecheng(5);
		System.out.println(result);
	}
	public static int jiecheng(int n){
		if(n == 1){
			return 1;
		}
		else{
			return n*jiecheng(n-1);
		}
	}
}

再来一个用递归算法思想来完成文件夹的遍历与批量删除

 

package Digui;

import java.io.File;

public class Demo2 {
	public static void main(String[] args) {
//		//列出一个文件夹下所有子文件夹以及子文件
//		File file = new File("E://Desktop//chapter12//src//com//jp");
//		showList(file);
		//删除一个目录的过程是如何进行的?
		File file = new File("G://a");
		remove(file);
	}
	 private static void remove(File file) {
		 if(file.isDirectory()){
			 File[] listFiles = file.listFiles();
			 for( File f   : listFiles ){
			 if(f.isFile()){
				 f.delete();
			 }else if(f.isDirectory()){
				 remove(f);
			 }
			 }
		 }
		 file.delete();
	}

	//* isDirectory() 判断文件对象是不是一个文件夹
	 // isFile()   判断文件对象是不是一个文件
	/*private static void showList(File file) {
		 if(file.isDirectory()){
			 File[] listFiles = file.listFiles();//以File对象的形式返回当前路径下的所有文件和文件夹
			 for(File f : listFiles){
				 if(f.isFile()){
					 System.err.println("文件: " + f.getName() );
				 }else if(f.isDirectory()){
					 //这里是正在循环的f的文件对象
				showList(f);//这里用的就是递归
				 }
			 }
		 }
		 System.out.println("文件夹: " + file.getName());
	}*/
}

 

3.IO流

  1. IO流用来处理设备之间的数据传输
  2. java对对数据的操作是通过 流(系统资源)的方式
  3. java用于操作流的对象都在java.io包中
  4. 流按操作数据分为两种:字节流,和 字符流
  5. 流按流向分为:输入流(读),输出流(写)

 

java --IO流

带Stream后缀的都是字节

带另一种的就是字符流。下面的图为老师上课讲的图,方便看点

java --IO流

 

 java --IO流

4.字符流-创建文件

创建流对象,建立数据存放文件

–FileWriter fw =new FIleWriter(“a.txt”);

调用流对象的写入方法,将数据写入流

–fw.write(“aafsa”);

-关闭流资源,并将流中的数据清空到文件中。

–fw.close();

package Writer;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
	public static void main(String[] args) throws IOException {
		File file = new File("a.txt");
		FileWriter fw = new FileWriter(file);
//		fw.write(97);
//		fw.flush();//刷新
//		fw.close();//关闭流,自带刷新功能
		int i = 100;
		System.out.println((char)i);
	}
}

写入异常的处理

package Writer;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo2 {
	public static void main(String[] args) {
		FileWriter fw = null;
		try {
			File file = new File("xx:/a.txt");
			fw = new FileWriter(file,true);
			fw.write(97);
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				//保存到日志
				throw new RuntimeException("流关闭出门啦!!赶紧来处理");
			}
		}
	}
}

 

字符流-读取文件

  • 建立一个流对象,和指定的文件数据关联
  • –FileReader fr = new FileReader(“01.txt”);
  • 创建一个临时存放数据的数组。
  • –char[] ch = new char[1024];
  • 调用流对象的读取方法将流中的数据读入到数组。
  • –fr.read(ch);

\r\n代表回车键

读的第一个例子:

package Reader;

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("a.txt");
//		int read1 = fr.read();
//		System.out.println(read1);
//		int read2 = fr.read();
//		System.out.println(read2);
//		int read3 = fr.read();
//		System.out.println(read3);
		int len = 0;
		while((len = fr.read()) != -1){
			//   \r\n代表回车键
			System.out.println(len);
		}
		fr.close();
	}
}

自定义缓冲区:

package Reader;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {
		public static void main(String[] args) throws IOException {
			FileReader fr = new FileReader(new File("a.txt"));
			//临时缓冲区
			char[] c = new char[10];
//			int len1 = fr.read(c);//将数据读取到一个字符数组中
//			System.out.println("长度:" + len1 + "---读取的内容是:" + new String(c));
//			int len2 = fr.read(c);
//			System.out.println("长度:" + len2 + "---读取的内容是:" + new String(c));
//			int len3 = fr.read(c);
//			System.out.println("长度:" + len3 + "---读取的内容是:" + new String(c));
		
			int len = 0;
			while((len= fr.read(c)) != -1){
				System.out.println(new  String(c, 0, len));
			}
	}
}

 

 

字符流练习:比较正规的

package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDoc1 {
	public static void main(String[] args){
		FileReader fr = null;
		FileWriter fw = null;
		try {
			//源文件
			File sourceFile = new File("F://a.txt");
			
			//目标文件
			File targetFile = new File("D://copy.doxc");
			
			//建立读取流的通道
			fr = new FileReader(sourceFile);
			
			//建立写入流通道
			fw = new FileWriter(targetFile);
			//建立临时缓冲区,以提高效率
			char[] c = new char[1024];
			//记录读取的字符个数
			int len = 0;
			
			while((len = fr.read(c)) != -1){
				fw.write(c, 0, len);
				fw.flush();//刷新
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr != null){
					fr.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取流关闭出问题啦");
			}
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入流关闭出问题啦");
			}
		}
	}
}

 

  • 字符流–缓冲区
  • 缓冲区提高了对数据的读写效率
  • 对应类:
  •   —BufferedWriter
  •   —BufferedReader
  • 缓冲区要结合流才可以使用。
  • 在流的基础上对流的功能进行了增强
package Buffer;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferDemo2 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = null;
		BufferedWriter  bw = null;
		try {
			br = new BufferedReader(new FileReader(new File("F://a.txt")));
			bw = new BufferedWriter(new FileWriter(new File("D://nihao.txt")));
			String line = null;
			while((line = br.readLine()) != null){
				bw.write(line);
				bw.newLine();//换行
				bw.flush();//刷新
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(br != null){
				br.close();
			}
			if(bw != null){
				bw.close();
			}
		}
		
	}
}

 

5,装饰者设计模式

  • 对原有类进行了功能增强
  • 它与继承有什么不同?
  •  继承:被增强的对象固定
  •           被增强的内容也是固定的
  • 装饰者模式;被增强的对象是可以切换的
  •                    被增强的内容是固定的
  • 动态代理(AOP) :被增强的对象可以切换
  •                              被增强的内容也是可以切换的

 

6,字节流

FileInputStream

FileOutputStream

复制一个mv到别的盘

package FileInputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis =null;
		FileOutputStream fos = null;
		try {
			File sourceFile = new File("D://123.mp4");
			File targetFile = new File("G://xcc.mp4");
			fis = new FileInputStream(sourceFile);
			fos = new FileOutputStream(targetFile);
			byte[] b = new byte[1024];
			int len = 0;
			while((len = fis.read(b)) != -1){
				fos.write(b, 0, len);
				fos.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fis != null){
				try{
					fis.close();
				}catch(IOException e){
					throw new RuntimeException("关闭读取流出问题");
				}
			}
			if(fos != null){
				try{
					fos.close();
				}catch(IOException e){
					throw new RuntimeException("关闭写入流出问题");
				}
			}
			
		}
		
	}

}

字节流—-缓冲区 

  • BufferedInputStream
  • BufferedOutputStream

 

package Test1;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo3 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = null;
		FileOutputStream fos  =null;
		BufferedInputStream bis  = null;
		BufferedOutputStream  bos = null;
		try {
			fis = new FileInputStream("E://Desktop//大二  上学期//123.mp4");
			fos = new FileOutputStream("d://copy1.mp4");
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			
			byte[] b = new byte[1024];
			
			int len = 0;
			
			while((len = bis.read(b)) != -1) {
				bos.write(b, 0, len);
				bos.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e){
			e.printStackTrace();
		}finally {
			try {
				if(fis != null){
					fis.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			
			try {
				if(fos != null){
					fos.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			try {
				if(bis != null){
					bis.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			try {
				if(bos != null){
					bos.close();
				}
			} catch  (IOException e) {
					throw new RuntimeException("出问题啦");
			}
		}
		
	}
}

 

7,转换流

  • InputStreamReader , OutputStreamWriter
  • 转换流的由来
  1. –字符流与字节流之间的桥梁
  2. –方便了字符流与字节流之间的操作
  • 转换流的应用
  • -字节流中的数据都是字符时,转换字符流的操作更高效
  • GBK读中文的码表
package Trans;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class TransDemo {
	public static void main(String[] args) throws IOException {

		//FileInputStream fis = new FileInputStream("E://xx.txt");

		// 需要转换吗?
		//InputStreamReader isr = new InputStreamReader(fis, "gbk");
		
		FileReader fr = new FileReader("G://xx.txt");
		// 需要提高效率吗?
		BufferedReader br = new BufferedReader(fr);

		FileOutputStream fos = new FileOutputStream("F://yy.txt");

		OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");

		BufferedWriter bw = new BufferedWriter(osw);

		String line = null;

		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.flush();
		}

		fr.close();
		br.close();
		fos.close();
		osw.close();
		bw.close();
	}
}

 

8,标准输入输出流

  • System.in 和 System.out分别代表了系统标准的输入和输出设备
  • 默认输入设备是键盘,输出设备是显示器
  • System.in 的类型是 InputStream
  • System.out 的类型是 PrintStream,其实OutoutStream 的子类
  • 通过System 类的seth,setOut方法对默认设备进行改变。
  • Public static void setln(InputStream in)
  • public static void setOut(PrintStream out)
package SYs;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class SystemDemo {
	public static void main(String[] args) throws IOException {
		InputStream in = System.in;
//		int read = in.read();
//		System.out.println(read);
//		int read1 = in.read();
//		System.out.println(read1);//  13 \r
//		int read2 = in.read();
//		System.out.println(read2);//   10\n
//		int len = 0;
//		while((len = in.read()) != -1){
//			System.out.println(len);
//		}
		InputStreamReader isr = new InputStreamReader(in);
		BufferedReader br = new BufferedReader(isr);
		
		PrintStream out = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(out);
		
		BufferedWriter bw = new BufferedWriter(osw);
		
		String line = null;
		while((line = br.readLine())  != null ){
			//System.out.println(line);
			if("over".equals(line)){
				break;
			}
			bw.write(line.toUpperCase());//大写
			bw.newLine();//换行
			bw.flush();//刷新
		}
		in.close();
		isr.close();
		br.close();
		out.close();
		osw.close();
		bw.close();
		
		
	}
}

 

8、其他流

  • 打印流 
  •     —printWriter 与 printStream
  •         可以直接操作输入流文件
  • 序列流
  •    —SequenceInputStream
  •       对多个流进行合并
  • 对象流
  •    — ObjectInputStream与ObjectOutputStream
  •        被操作的对象需要Serializable(标记接口)

 打印流

package Pint;

import java.io.IOException;
import java.io.PrintStream;

import org.junit.Test;

public class PrintDemo {
	@Test
	public void testPrintDemo()  throws IOException{
	PrintStream ps = new PrintStream("preawer.txt");
	ps.print(91);
	ps.println();
	ps.flush();
	ps.close();
	}
	@Test
	public void testPrintWriter(){
		//字节流   ctrl + t  查看代码的结构
		PrintStream out = System.out;
//		PrintWriter pw = new PrintWriter(out);
//		pw.print('a');
//		pw.flush();
//		pw.close();
		out.print("aaa");
	}
}

对象流

package com.jp.obj;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.junit.Test;

public class ObjDemo {
	
	@Test
	public void testObjectInputStream() throws IOException, ClassNotFoundException{
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("zs.txt"));
		//对象的反序列化
		Object readObject = in.readObject();
		Person p = (Person)readObject;
		System.out.println(p.getName());
		in.close();
	}
	
	@Test
	public void testObjectOutputStream() throws IOException{
		//对象的写出流,写入到磁盘上
		ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream("zs.txt"));
		
		//对象序列化过程
		out.writeObject(new Person("zs", 20));
		out.flush();
		out.close();
	}
}	

 

9、常见码表

 

编码变的由来:

计算机智能识别二进制数据,早期由来是电信号,为了方便应用计算机,让它可以识别各个国家的文字,就将各个国家的文字用数学来表示,并一一对应,形成一张表,这就是编码表

常见的编码表如下

java --IO流

  • 编码: 字符串—–字节数组
  • 解码:字节数组—字符串
  • 转换流的编码应用
  • 可以将字符按指定编码格式存储
  • 可以对文本数据按指定编码格式来解读
  • 指定编码表的动作由构造器来完成
package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDoc1 {
	public static void main(String[] args){
		FileReader fr = null;
		FileWriter fw = null;
		try {
			//源文件
			File sourceFile = new File("F://a.txt");
			
			//目标文件
			File targetFile = new File("D://copy.doxc");
			
			//建立读取流的通道
			fr = new FileReader(sourceFile);
			
			//建立写入流通道
			fw = new FileWriter(targetFile);
			//建立临时缓冲区,以提高效率
			char[] c = new char[1024];
			//记录读取的字符个数
			int len = 0;
			
			while((len = fr.read(c)) != -1){
				fw.write(c, 0, len);
				fw.flush();//刷新
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr != null){
					fr.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取流关闭出问题啦");
			}
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入流关闭出问题啦");
			}
		}
	}
}

 

 

 

 

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/114802.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • WPF数据采集与监控系统实战开发全记录【附源码 典藏版】[通俗易懂]

    WPF数据采集与监控系统实战开发全记录【附源码 典藏版】[通俗易懂]作为B站学习区非知名Up主,本人酷爱沉迷上位机无法自拔!人称”上位机大王“(滑稽)长期为大家提供各类WPF/上位机学习干货是我的信条!元旦在即,我又连肝一周,录制了一批WPF数据采集与监控系统项目开发实战!!录制内容,从上位机应用基础架构出发,全程代码实战,涉及内容包括串口通信、基础组件开发、用户控件动画、全局静态数据绑定等等。从无到有,完整实操,项目整体以MVVM思想模式设计开发,代码功能使用分层结构,逻辑与View解耦。认真看完全部视频,你可以了解到基本的串口通信方式,以及如何利用WPF的特性开发

  • 第一个C# Winform实例

    第一个C# Winform实例前面我们准备好了相关的库,现在开始搭建环境,本人自动化行业,就用Windorm开发吧,例子仅仅做引导,希望大家能深入。VS版本VS20171:打开VS建立一个WInform项目。拉入两个控件,gr

  • 爬了1000张清纯妹子私房照,我流鼻血了…[通俗易懂]

    爬了1000张清纯妹子私房照,我流鼻血了…[通俗易懂]想看漂亮小姐姐照片?不如试试爬虫批量下载,自己一个人在被窝里慢慢看

  • python常用库安装

    python常用库安装python常用库安装

  • 数据挖掘算法与现实生活中的应用案例[通俗易懂]

    数据挖掘算法与现实生活中的应用案例[通俗易懂]如何分辨出垃圾邮件”、“如何判断一笔交易是否属于欺诈”、“如何判断红酒的品质和档次”、“扫描王是如何做到文字识别的”、“如何判断佚名的著作是否出自某位名家之手”、“如何判断一个细胞是否属于肿瘤细胞”等等,这些问题似乎都很专业,都不太好回答。但是,如果了解一点点数据挖掘的知识,你,或许会有柳暗花明的感觉。本文,主要想简单介绍下数据挖掘中的算法,以及它包含的类型。然后,通过现实中触手可及的、活生生的案例

  • 使用knn算法对鸢尾花数据集进行分类(数据挖掘apriori算法)

    KNN算法实现鸢尾花数据集分类一、knn算法描述1.基本概述knn算法,又叫k-近邻算法。属于一个分类算法,主要思想如下:一个样本在特征空间中的k个最近邻的样本中的大多数都属于某一个类别,则该样本也属于这个类别。其中k表示最近邻居的个数。用二维的图例,说明knn算法,如下:二维空间下数据之间的距离计算:在n维空间两个数据之间:2.具体步骤:(1)计算待测试数据与各训练数据的距…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号