首页 找课程 找学校 教育新闻 培训问答 课程大全

苏州其然软件开发培训

13013833891 预约试听 在线客服

您的位置： 首页 > 苏州培训 > 苏州其然软件开发培训 > web前端培训 > 张家港找学java可靠吗

张家港找学java可靠吗

班制：

周末班

[ 开班提醒 ]
上课地址：

苏州其然软件开发

活动倒计时
11: 59: 59
马上抢

课程介绍

张家港找学java可靠吗
其然IT 教育师资

吴嘉俊(Stef)高级讲师

拥有多年的Java开发经验，CTO，EasyJF开源团队创始人之一、负责 EasyJWeb项目的开发和维护。曾在国内多家大型软件公司负责公司内部框架的开发和维护，为多个大中型公司做过架构和技术咨询。曾组织开发了蓝源 装饰行业ERP、美国EMR、蓝源服装行业连锁管理系统、蓝源SaaS服务平台、蓝源Eloan互联网金融综合解决方案等系统产品。具有非常丰富项目开发和 管理经验。

擅长技术：主流JavaEE，Android技术，对 Spring、JPA、Hibernate、 MyBatis、Struts2、MongoDB、Redis等技术领域有深入研究。 

吴老师有丰富的Java培训经验和IT培训行业顾问经验；授课激情，有感染力 ，注重对底层原理的剖析和理解；善于培养学生对编程的兴趣； 

张家港找学java可靠吗

Java工程师的工资待遇怎么样?

张家港找学java可靠吗

Java工程师的工资待遇怎么样?

Java软件工程师一般月薪范围在4000-10000元，远远超过了应届毕业生月薪 2500元的平均水平。通常来说，有一年工作经验的Java高级软件工程师的薪酬大致在年薪10—13万左右。

从Java的应用领域来分，Java语言的应用方向主要表现在以下三个方面：首 先是大中型的商业应用;其次是桌面应用，就是常说的C/S应用;再次是移动领域应用。

综上而言JAVA就业方向为：可以从事JSP网站开发、Java编程、Java游戏开 发、Java桌面程序设计，以及其他与Java语言编程相关的工作。可进入电信、银行、保险专业软件开发公司等从事软件设计和开发工作。

流行框架

张家港找学java可靠吗

流行框架

  • 01Struts2

    • 1．Struts2流程

    • 2．值栈与ONGL

    • 3．Struts2标签库

    • 4．Struts2模型驱动原理

    • 5．Struts2声明式异常处理

    • 6．Struts2类型转换&自定义类型转换

    • 7．Struts2拦截器原理&自定义拦截器

    • 8．Struts2源码分析&运行原理

  • 02Hibernate

    • 1．Hibernate环境搭建&配置

    • 2．hibernate.cfg.xml&主键生成策略

    • 3．Session核心方法

    • 4．ORM映射：单向/双向1-n映射

    • 5．ORM映射：基于主/外键映射&n-n

    • 6．检索策略&迫切左外连接

    • 7．Hibernate缓存机制

    • 8．QBC、HQL

    • 9．Session管理

  • 03Spring

    • 1．SpringIOC&DI机制

    • 2．Spring配置式组件管理

    • 3．Spring注解式自动装配

    • 4．Spring表达式语言

    • 5．SpringAOP&动态代理

    • 6．SpringJDBC使用

    • 7．Spring声明式事务

    • 8．Spring单元测试

    • 9．Spring源码分析

    • 10．Spring、Struts2、Hibernate整合

  • 04SpringMVC

    • 1．SpringMVC配置&运行流程

    • 2．SpringMVC数据绑定

    • 3．模型处理&@ModelAttribute

    • 4．RestFulCRUD

    • 5．表单标签&静态资源处理

    • 6．数据转换&格式化&JSR303数据校验

    • 7．HttpMessageConverter

    • 8．Ajax&国际化&文件上传**

    • 9．异常处理

    • 10．整合&父子容器

  • 05MyBatis

    • 1．MyBatis配置&查询数据

    • 2．MyBatis全局配置文件

    • 3．MyBatis映射文件

    • 4．关联查询，动态sql

    • 5．MyBatis缓存机制&整合ehcache

    • 6．MyBatis逆向工程

    • 7．MyBatis、Spring、SpringMVC整合

    • 8．MyBatis运行原理&源码分析

    • 9．MyBatis拦截器&插件开发

    • 10．分页插件&存储过程调用&自定义 TypeHandler

  • 06JPA

    • 1．JPA技术体系

    • 2．JPA注解

    • 3．JPA相关API

    • 4．JPA映射

    • 5．JPQL

    • 6．二级缓存

    • 7．Spring整合JPA

  • 07SpringData

    • 1．SpringData快速入门

    • 2．SpringData_Repository接口

    • 3．Repository查询规范

    • 4．@Query&@Modifying

    • 5．CrudRepository

    • 6．PagingAndSortingRepository

    • 7．JpaRepository

    • 8．JpaSpecificationExecutor

    • 9．自定义Repository

  • 08Maven

    • 1．Maven环境搭建

    • 2．Maven构建&自动化构建

    • 3．本地仓库&中央仓库

    • 4．maven创建web工程

    • 5．pom.xml、依赖管理

    • 6．坐标、依赖、生命周期等

    • 7．eclipse下的maven使用

    • 8．继承&聚合

    • 9．maven构建SSH/SSM应用

    • 10．自动部署&持续集成&持续部署

  • 09SVN

    • 1．SVN简介

    • 2．SVN服务器搭建

    • 3．SVN创建版本库

    • 4．Eclipse整合svn插件

    • 5．使用SVN更新提交

    • 6．SVN仓库分析

    • 7．SVN协同修改&冲突解决

    • 8．SVN权限管理

    • 9．SVN时光机

    • 10．TortoiseSVN

  • 10Shiro

    • 1．Shiro入门

    • 2．Spring集成Shiro

    • 3．Shiro工作流程

    • 4．权限URL配置

    • 5．认证流程&认证Realm

    • 6．密码比对，MD5&盐值加密

    • 7．授权流程

    • 8．标签&权限注解

    • 9．会话管理、SessionDao

    • 10．缓存

    • 11．实现”记住我”

  • 11Activiti5

    • 1．工作流&工作流引擎

    • 2．BPMN2.0规范

    • 3．Activiti5框架表结构

    • 4．Activiti5核心组件&服务接口

    • 5．Activiti5插件安装&整合Spring

    • 6．流程定义

    • 7．流程实例&任务&历史

    • 8．任务领取&流程变量

    • 9．排他网关&并行网关

  • 12WebService

    • 1．WebService简介

    • 2．WebService主流框架

    • 3．cxf的使用

    • 4．SOAP协议

    • 5．WSDL讲解

    • 6．JAX-WS

    • 7．与Spring整合

    • 8．JAXB

    • 9．JAX-RS

    • 10．支付接口原理

  • 13Linux

    • 1．Linux系统-基础

    • 2．Linux网络基础

    • 3．Linux在VMware下的安装

    • 4．Linux下Java环境的搭建

    • 5．Linux下Tomcat安装和配置

    • 6．Linux下 Oracle/MySQL 安装与配置

    • 7．Shell 编程

  • 14Redis

    • 1．NoSQL&Redis入门

    • 2．Redis/memcache/MongDB对比

    • 3．Redis安装&启动

    • 4．分布式数据库CAP原理

    • 5．Redis五大数据类型和基本操作命令

    • 6．Redis总体配置Redis.conf

    • 7．Redis持久化（RDB和AOF）

    • 8．Redis事务控制

    • 9．Redis发布和订阅

    • 10．Redis（Master/Slave）主从复制

    • 11．Jedis

  • 15Git&Git Hub

    • 1．Git安装配置

    • 2．Git本地库搭建

    • 3．Git常用操作命令

    • 4．Github注册与配置

    • 5．Github与Git协同办公

    • 6．TortoiseGit安装配置

    • 7．Egit操作push/pull，

    • 8．Git工作流

    • 9．集中式&GitFlow&Forking

  • 16MySQL高级

    • 1．MySQL架构组成

    • 2．MySQL备份和恢复

    • 3．MySQL查询和慢查询日志分析

    • 4．MySQL索引优化

    • 5．MySQL存储引擎优化

    • 6．MySQL锁机制优化

    • 7．MySQL高可用设计

    • 8．MySQL集群

  • 17JVM原理

    • 1．JVM简析

    • 2．JVM组成结构

    • 3．JVM堆、栈原理

    • 4．JVM-Heap三区原理

    • 5．JVM垃圾收集机制

    • 6．堆内存调优

    • 7．GC回收策略

    • 8．GC三大算法

  • 18Quartz

    • 1.Quartz作业调度简介

    • 2.Quartz作业调度执行以及持久性

    • 3.Quartz基本使用

    • 4.Quartz核心类讲解

    • 5.Quartz Trigger 触发器

    • 6.Quartz Job&JobDetail

    • 7.Quartz Calendars日历讲解

    • 8.JobListener监听器和TriggerListener监听器

    • 9.Spring整合Quartz

  • 19Nginx

    • 1.Nginx反向代理介绍

    • 2.Nginx **和安装

    • 3.Nginx 编译和启动、访问

    • 4.在Linux下搭建Nginx集群

    • 5.在Windows搭建Nginx集群

    • 6.解决Session共享问题

  • 20Java JUC 线程高级

    • 1.volatile 关键字

    • 2.内存可见性分析

    • 3.原子变量与CAS (Compare And Swap) 算法分 析

    • 4.ConcurrentHashMap 锁分段机制

    • 5.CountDownLatch 闭锁

    • 6.实现 Callable 接口

    • 7.Lock 同步锁

    • 8.Condition 控制线程通信

    • 9.线程按序交替

Java中的IO流

>

java中的IO流

      Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。


百度百科：

http://baike.baidu.com/link?url=r9vOfxsGkUHzoGw3rxvw0YQJiFHsmS3P2cQGV4PRjdT14RCCXNxCvd3KNuHgxF56Upj86uJ2EAkK1_vjSiHIYK


在线API：

http://www.apihome.cn/api/java/java.io_1

Java IO流的分类

1) 字节流：数据流中的**小的数据单元是字节，一次读入读出8位二进制；

2) 字符流：数据流中的**小的数据单元是字符，一次读入读出16位二进制，java中的字符是Unicode编码，一个字符占用两个字节。

字节流

输入字节流：InputStream类

InputStream类是个抽象类是所有字节输入流的超类。


读取文件：FileInputStream
在src目录下创建一个a.txt文件



创建一个FileInputStream类的对象用来读取a.txt文件 package com.lingdu.file; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class FileInputStreamDemo { /** * 使用InputStream抽象类的子类FileInputStream类 * 从一个文件中读取流数据 */ public static void test1() { try { //读取src下的a.txt文件 FileInputStream myStream = new FileInputStream("src/a.txt"); int a = 0; //如果没读到文件尾，则继续执行 while((a = myStream.read()) != -1){ System.out.print((char)a); } //关闭流（使用完之后都要关闭） myStream.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public static void main(String[] args) { test1(); } }


使用多态的特性使用子类FileInputStream /** * 使用多态的特性使用子类FileInputStream */ public static void test2() { try { InputStream is = new FileInputStream("src/a.txt"); } catch (FileNotFoundException e) { e.printStackTrace(); } }

输出字节流OutputStream类


写到文件：FileOutputStream

写入一个字符到文件中

/** * 写入一个字符到文件中 * @author Administrator * */ public class FileOutputStreamDemo { public static void test1() { try { OutputStream os = new FileOutputStream("src/a.txt"); os.write(97); os.flush(); os.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


写入一个数组到文件

/** * 写入一个数组到文件 */ public static void test2() { //方法比较笨拙不推荐使用，这里只是作为演示 byte myArray[] = new byte[5]; myArray[0] = 97; myArray[1] = 98; myArray[2] = 99; myArray[3] = 100; myArray[4] = 101; try { OutputStream os = new FileOutputStream("src/b.txt"); os.write(myArray); os.flush(); os.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


写入一个字符串到文件

/** * 写入一个字符串到文件 */ public static void test3() { String myContent = "I am a good man!"; try { OutputStream os = new FileOutputStream("src/c.txt"); os.write(myContent.getBytes()); os.flush(); os.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }



FileInputStream 和 FileOutputStream 类

**FileInputStream 和 FileOutputStream 类拷贝文件

步骤：

1、 使用FileInputStream类读取到文件

2、 使用FileOutputStream类写入到新文件


这里我在src目录下创建一个a.txt文件作为测试


拷贝方法：

/** * 读取文本文件，读取图片，读取视频 */ public static void copyFile(String sourceName,String dest){ System.out.println("源文件：" sourceName ",目标文件：" dest); //1:先读取一个文件 //2:写入一个文件 try { FileInputStream fis = new FileInputStream(sourceName); FileOutputStream fos = new FileOutputStream(dest); int a = 0; //当还未到达文件尾时，循环读取 while((a = fis.read()) != -1){ //每读取一个字节过来，我们就写入到另一个文件里去 fos.write(a);//这里只会正常写入数据，不会把-1写进去 } fos.flush();//把缓冲区里的数据强制写入到文件中 fos.close();//关闭输出流 fis.close();//关闭输入流 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }

这是如果读取一个视频的话，速度就会变的很慢。

我用一个22mb的视频和1G的视频作为测试


Main函数

public static void main(String[] args) { //程序运行开始时间 long begin = System.currentTimeMillis(); HomeWork.copyFile("src/a.txt", "src/b.txt"); //程序运行时间=结束时间-开始时间 ，得到的是毫秒值。 long end = System.currentTimeMillis() - begin; System.out.println("\n用时：" end/1000f "s"); }

复制22mb的视频都那么吃力，可想而知用1G的视频将会等待更久

所以我们要改进一下我们的程序


使用byte数组的方式进行复制

为了测试，我在src目录下创建了一个a.txt的文件用于测试，并且在txt文本中保存一些数据


/** * 由于读取速度太慢，所以要学习新的方法，让我们更快一点 */ public static void test2(){ //设置每次写入3个字节 byte[] myArray = new byte[3]; try { InputStream is = new FileInputStream("src/a.txt"); //如果到达文件尾，无法满足while的条件，不会执行while语句的内容 while(is.read(myArray) != -1){ for (int i = 0; i < myArray.length; i ) { //打印一下每个字符 System.out.print((char)myArray[i]); } } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


结果是可以复制的

问题：

我当前a.txt文件下保存的数据是lingdu,但是如果我在加一些内容会怎样呢？


保存运行一下得到的不是我想要的数据 多出了du 两个字符


原因就是：

因为数组定义的长度是3

**次读取到lin 输出

第二次读取到gdu 输出

第三次读取到a 因为读取时是覆盖操作 所以a覆盖了g之后，后面的全部输出 adu

所以**后的结果是 lingduadu

知道原因之后我们就要改进一下这个方法了

/** * 问题： * 当使用数组的时候，如果文件里的字符的长度不是数组的倍数的时候，拿到的数据会重复 */ public static void test3(){ //这里的数组长度是指 每次读取3个字节 byte[] myArray = new byte[3]; //定义一个变量用来保存数组的长度 int len; try { InputStream is = new FileInputStream("src/a.txt"); //如果到达文件尾，无法满足while的条件，不会执行while语句的内容 while((len = is.read(myArray)) != -1){ //这样就解决了数据重复的问题 for (int i = 0; i < len; i ) { System.out.print((char)myArray[i]); } } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


解决了这个重复的问题之后我们就可以继续进行复制了。

现在我们使用数组的方式对1G视频进行复制

/** * 优化 * 使用数组进行读取 */ public static void test4(){ //这里的数组长度是指 每次读取1024个字节 byte[] myArray = new byte[1024]; //定义一个变量用来保存数组的长度 int len; try { InputStream is = new FileInputStream("src/1.wmv"); OutputStream os = new FileOutputStream("src/test.wmv"); //如果到达文件尾，无法满足while的条件，不会执行while语句的内容 while((len = is.read(myArray)) != -1){ //定义过新的数组，这个数组要防止有多余的数据 byte descArray[] = new byte[len]; //这样就解决了数据重复的问题 for (int i = 0; i < len; i ) { //System.out.print((char)myArray[i]); descArray[i] = myArray[i]; } os.write(descArray); } os.flush(); os.close(); is.close(); System.out.println("写入成功！"); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

使用数组的方式写入一个1G的视频才用了1.7秒左右，比刚刚使用1个字节写入快了几百倍


BufferedInputStream和BufferedOutputStream 类

性能优化

使用封装好的write(byte[] b, int off, int len)方法，简易代码。
/** * 性能优化 * 1：使用封装好的方法直接使用write(myArray, 0, len); */ public static void test5(){ //这里的数组长度是指 每次读取1024个字节 byte[] myArray = new byte[1024]; //定义一个变量用来保存数组的长度 int len; try { InputStream is = new FileInputStream("src/1.wmv"); OutputStream os = new FileOutputStream("src/test.wmv"); //如果到达文件尾，无法满足while的条件，不会执行while语句的内容 while((len = is.read(myArray)) != -1){ //**后一次读取数据的时候，只把数组的第0个长度开始到数组的指定len（我们从流里**好一次实际读出的数据） os.write(myArray, 0, len); } os.flush(); os.close(); is.close(); System.out.println("写入成功！"); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

使用封装好的方法要比自己定义数组数值快很多，而已省去了很多的代码，提高了开发效率


使用缓冲区 BufferedInputStream和BufferedOutputStream
/** * 进一步性能优化 * 2：使用缓冲区 BufferedInputStream跟BufferedOutputStream */ public static void test6(){ //这里的数组长度是指 每次读取3个字节 byte[] myArray = new byte[1024]; //定义一个变量用来保存数组的长度 int len; try { //把原来的流装进一个类里 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src/1g.wmv")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src/test.wmv")); //如果到达文件尾，无法满足while的条件，不会执行while语句的内容 while((len = bis.read(myArray)) != -1){ //**后一次读取数据的时候，只把数组的第0个长度开始到数组的指定len（我们从流里**好一次实际读出的数据） bos.write(myArray, 0, len); } bos.flush(); bos.close(); bis.close(); System.out.println("写入成功！"); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }

使用缓冲区写入数据的时候，速度快了1倍



ByteArrayInputStream 类

当我们没有文件的时候，如何使用流？

这时我们就要用到ByteArrayInputStream 类

/** * 当我们没有文件的时候，如何使用流 * */ public static void test8(){ String content = "lingdu"; ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes()); int i = 0; while((i = is.read()) != -1){ System.out.print((char)i); } }


当文件里有中文的时候，会出现乱码

/** * 新的问题：当文件里有中文的时候，可能会乱码 * */ public static void test9(){ String content = "魑魅魍魉"; byte myArray[] = content.getBytes(); ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes()); for (int i = 0; i < myArray.length; i ) { System.out.print((char)myArray[i]); } System.out.println(); byte a = 0; while((a = (byte)is.read()) != -1){ System.out.print((char)a); } }


如何解决乱码问题呢？

/** * 解决乱码问题 * */ public static void test10(){ String content = "魑魅魍魉"; byte myArray[] = content.getBytes(); ByteArrayInputStream is = new ByteArrayInputStream(content.getBytes()); int len = 0; try { while((len = is.read(myArray)) != -1){ System.out.println(new String(myArray)); } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


如果我要读取一个文本文件里面的中文呢？

我在src下创建一个a.txt,并写入数据


/** * 读取文件 * 解决乱码问题 * */ public static void test11(){ InputStream is; try { is = new FileInputStream("a.txt"); byte myArray[] = new byte[6]; ByteArrayInputStream bais = new ByteArrayInputStream(myArray); int len = 0; while((len = is.read(myArray)) != -1){ System.out.println(new String(myArray)); } } catch (FileNotFoundException e1) { e1.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }

运行结果并不会出现乱码


字符流


Reader类

优点：

对InputStream进行包装

比较擅长读取文本文件

还是拿刚刚的文件进行测试，为了解决中文问题，引用字符流

/** * 引用字符流，来解决中文问题 * Reader抽象类，InputStreamReader实现类 */ public static void test12() { try { //InputStreamReader(InputStream in, String charsetName) 可以设置文件的编码 Reader reader = new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8"); int a; while((a = reader.read())!= -1){ System.out.print((char)a); } reader.close(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }


使用数组进行读取

/** * 字符流其实就是对字节流进行了包装 * 字符流读数组 */ public static void test13() { try { Reader reader = new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8"); //字符长度越大，越不会出错 char myArray[] = new char[12]; int a; while((a = reader.read(myArray))!= -1){ System.out.print(new String(myArray)); } reader.close(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }


BufferedReader类

性能优化：

使用BufferedReader 进行包装 /** * 字符流 * BufferedReader * 提高读取效率 */ public static void test15() { try { BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/a.txt"), "UTF-8")); //准备读取 while (reader.ready()) { //打印一行数据 System.out.println(reader.readLine()); } reader.close(); } catch (UnsupportedEncodingException | FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


Writer类

所谓有读取就有写入，所以引用字符输出流Writer，对OutputStream进行包装

写入数据到文件 /** * 字符流 * Writer抽象类，OutputStreamWriter实现类 * 写入数据到文件 */ public static void test14() { try { //true表示在尾部继续添加数据 Writer writer = new OutputStreamWriter(new FileOutputStream("c.txt",true)); //BufferedWriter bw = new BufferedWriter(writer); writer.write("零度"); writer.flush(); writer.close(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }

数据已经写入到c.txt文件下了


BufferedWriter类

性能优化：

当然我们也可以让程序写快一些，就是使用BufferedWriter /** * 字符流 * BufferedWriter * 提高写入字符流效率 */ public static void test16() { try { BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"))); bw.write("hello 零度!"); bw.write("pro"); bw.flush(); bw.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


Scanner 类

Scanner 类使读取文件更为简单

/** *读取文件的时候要更方便 */ public static void test18() { try { Scanner sc = new Scanner(new FileInputStream("a.txt")); while(sc.hasNextLine()){ System.out.println(sc.nextLine()); } System.out.println("读取完成！"); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }


printWriter类

对输出流进行包装，输出操作更简单了

/** *为了能够输出数据的时候更方便，我们要引入printWriter */ public static void test17() { try { PrintWriter pw = new PrintWriter("a.txt"); pw.print("I am 零度! 我"); pw.print(18); pw.print("岁"); pw.flush(); pw.close(); System.out.println("写入完成！"); } catch (FileNotFoundException e) { e.printStackTrace(); } }




相关推荐：

苏州JAVA培训   

倒计时
11: 59: 19
课程热线：13013833891 | 客服时间：9:00-22:00(其他时间请在线预约报名或留言）

张家港找学java可靠吗

13013833891

周一至周日09:00-22:00

相关资讯

更多>

相关问题

更多>
机构介绍
其然软件是一所专业从事程序编程语言开发培训的机构，我们开设有JAVA、.NET、C/C++，WEB前端等课程，其中JAVA为其然软件的核心课程，从2011年至今已为江浙沪培养一批又一批的专业型软件技术开发人才，每一期学员的就业l都在80%以上，我们有科学的课程体系，人性化的学习管理，努力为昆山地区的软件事业贡献出自己的一份力量。 做朴实的软件开发培训是其然软件的宗旨，朴素而...【详情】

其他课程

相关课程
其他城市
相关机构

申请试听名额

已有10254人申请免费试听

01电话咨询 | 13013833891

QQ：1413838287
加盟合作：0755-83654572