java中处理中文输入,不需要用到的类是

Posted 2023-03-18

Java把不同类型的输入、输出抽象为流stream，分为输入流和输出流，用统一的接口来表示
Java开发环境中提供了包java.io，其中包括一系列的类来实现输入／输出处理
InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先
public abstract class InputStream implements Closeable
public abstract class OutputStream implements Closeable, Flushable
具体子类： ByteArrayInputStream, FileInputStream, FilterInputStream, ObjectInputStream,
PipedInputStream, SequenceInputStream, StringBufferInputStream
InputStream
InputStream类是一个抽象类，方法包括：
int read()
int read(byte[])
int read(byte[],int,int)
void close()关闭流
int available()报告流中直接可读的字节数
skip(long)跳过流中指定的字节
OutputStream
OutputStream也是一个抽象类。它的主要方法包括：
void write(int)
void write(byte[])
void write(byte[],int,int)
其中第一个方法的int型的参数对应要写入的字节，后两个方法的参数与InputStream类似。
void close() 关闭输出流
void flush() 强行将写入缓冲区中剩余的数据写入
File file = new File("d:\\FileTest.java");
if (file.exists())
try (InputStream is = new FileInputStream(file);)
byte[] buffer = new byte[8192];
int len = is.read(buffer);
while (len > 0)
System.out.write(buffer, 0, len);
len = is.read(buffer);

catch (Exception e)
e.printStackTrace();


InputSream 和 OutputStream 中定义了 read() 和 write() 方法，它们被派生流类重载。字节流是字节序
列，它与外部设备中的字节存在着一一对应的关系，不存在字符的转换，被读写字节的个数与外部设备中的字节个数是相同的
基本输入输出方法
System类是Java语言中一个功能强大、非常有用的类，它提供了标准输入/输出及运行时的系统信息
System类不能创建对象，也就是说，System类的所有属性和方法都是静态的，引用时要以System 作为前缀
System.in与System.out是System类的两个静态属性，分别对应了系统的标准输入/输出流 System类管理标准输入输出流和错误流
System.out：把输出送到缺省的显示(通常是显示器)，是PrintStream的对象
System.in：从标准输入获取输入(通常是键盘)，是InputStream的对象
System.err：把错误信息送到缺省的显示，是PrintStream的对象
同时使用System.out和System.err输出信息不能保证显示顺序就是执行顺序，为了避免这种情况在测试代码执行中经常使用System.err输出

FileInputStream、FileOutputStream 顺序读取文件
PipedInputStream、PipedOutputStream 管道
ByteArrayInputStream、ByteArrayOutputStream 内存读写
FilterInputStream、FilterOutputStream 过滤流（有多线程同步）
DataInputStream、DataOutputStream 对数据类型读写，有多线程同步
BufferedInputStream、BufferedOutputStream 缓冲类型读写

1 、使用字节流进行文件的单字节复制
FileInputStream是InputStream的子类，FileInputStream属于节点流，用于按字节读取文件内容
FileOutputStream是OutputStream的子类，FileOutputStream属于节点流，用于按字节输出数据到文件中
//FileInputStream中read方法的定义
/**
从指定的输入流中按字节读取数据，如果读到流的末尾则返回-1,否则返回读取到的数据。如果文件不存
在则异常FileNotFoundException【IOException的子类】
*/
public int read() throws IOException
return read0();

//FileOutputStream中write方法的定义
//属性,用于表示是否进行文件的追加操作而不是覆盖操作
private final boolean append;
//构造器方法的定义，其中name是文件名称，默认采用覆盖操作
public FileOutputStream(String name) throws FileNotFoundException
this(name != null ? new File(name) : null, false);

//按照字节执行写出int数据，自动会去除多余的字节。如果文件不存在则自动创建新文件，如果
文件已经存在则按照append的值决定采用的是追加操作还是覆盖操作
public void write(int b) throws IOException
write(b, append);

private native void write(int b, boolean append) throws IOException; //
由VM采用对等类的方式提供实现
public class Test1
public static void main(String[] args) throws IOException
try (InputStream is = new FileInputStream("c:/面向对象文档.txt");
OutputStream os = new FileOutputStream("test.txt");)
int kk;
while ((kk = is.read()) != -1)
os.write(kk);




2 、读取 A.java 文件并在控制台上显示
如何使用控制台输出 : System.out 字节流
分析：使用字节流从 A.java 中一个字节一个字节的读取内容，然后再使用 System.out.print 方法输出即可
注意：读取操作返回的 int 的取值范围为 0-255 ，则表示这里不会有符号位，所以 is.read()==-1 不是只适合于文本文件
File ff = new File("T1.java");
if (ff.exists()) // 如果文件存在则进行拷贝操作，否则提示文件不存在
InputStream is = new FileInputStream(ff);
OutputStream os = new FileOutputStream("t1.bak");
while (true)
int kk = is.read();// 返回值应该是0-255，如果返回-1表示流已经结束
if (kk < 0)break;
os.write(kk);

is.close();
os.close();
else
System.out.println("T1.java文件不存在");
InputStream基本输入类
InputStream类是基本的输入类。它定义了所有输入流所需的方法。

public abstract int read() throws IOException读取一个字节并以整数的形式返回，0-255。如果 返回-1已到输入流的末尾。
public int read(byte b[]) throws IOException读取一系列字节并存储到一个数组，返回实际读取的 字节数。如果已经读到输入流的末尾则返回-1
public void close() throws IOException 关闭输入流并释放资源
public int read(byte b[],int offset,int length) throws IOException功能为从输入流中读数据。这一 方法有几种重载形式，可以读一个字节或一组字节。当遇到文件尾时，返回-1。最后一种形式中的 offset是指把结果放在b[]中从第offset个字节开始的空间，length为长度
public long skip (long n) throws IOEnception 从输入流跳过几个字节。返回值为实际跳过的字节数
OutputStream基本输出类
三个重载形式都是用来向输出流写数据的
public abstract void write(int b)向输入流写入一个字节数据，该字节为参数的低8位。
public void write(byte b[],int offset,int length)将一个字节类型的数组中的从指定位置offset开始 的length个字节写入到输出流
public void close( ) 关闭输出流，释放资源
public void write(byte b[])将一个字节类型的数组中的数据写入到输出流
public void flush() 清除缓冲区，将缓冲区内尚未写出的数据全部输出
字符流
在顶层有 Reader 和 Writer 两个抽象类。 Reader 和 Writer 中定义了 read() 和 write() 方法，它们被派生流类重载
Reader 抽象类的定义
public abstract class Reader implements Readable, Closeable
//BIO，读取一个有效的字符，返回值为0到65535的整数，如果到达流的末尾则返回-1
public int read() throws IOException
//BIO,读取字符存储到char数组中，返回读取的字符个数，流结束则返回-1
public int read(char cbuf[]) throws IOException
//关闭流，同时释放资源
abstract public void close() throws IOException;
Writer 抽象类的定义
public abstract class Writer implements Appendable, Closeable, Flushable
//写出一个字符到字符流，要写的字符包含在给定整数值的16个低位；16个高位被忽略。
public void write(int c) throws IOException
//将字符数组中的指定部分内容压入到字符流，从off开始共len个字符
abstract public void write(char cbuf[], int off, int len) throws
IOException;
/关闭流，同时释放资源
abstract public void close() throws IOException;
相关的子类
InputStreamReader、OutputStreamWriter桥接流，用于自动实现字节流和字符流的转换
FileReader、FileWriter文件流，用于实现针对文本文件的读写操作
CharArrayReader、CharArrayWriter内存流，用于实现针对char数组的读写操作
PipedReader、PipedWriter管道流，用于线程之间的通讯
FilterReader、FilterWriter过滤流的父类
BufferedReader、BufferedWriter缓存流，用于在流中添加缓冲区
StringReader、StringWriter内存流，用于实现针对字符串的读写操作

使用字符流实现 txt 文件的读取显示【其中包含中文】
编写一个程序，读取文件 test.txt 的内容并在控制台输出。如果源文件不存在，则显示相应的错误信息。
字符流 Reader
int read()读取一个字符并以整数的形式返回0-65535，如果返回-1则已到输入流末尾
int read(char[] cbuf)读取一系列字符并存储到一个数组中，返回实际读取的字符数，如果读到输入流末尾则返回-1
void close()关闭输入流并释放内存资源
int read(char[] cbuf, int off, int len) 读取len个字符并存储到一个数组中，从off位置开始，返回实
际读取的字符数，如果读取到输入流末尾则返回-1
long skip(long n)跳过n个字符不读，返回实际跳过的字节数
字符流 Writer
void write(int c) 将字符（int数组的低8位）压入到字符流中
void write(char[] cbuf, int off, int len)将字符数组中的指定部分内容压入到字符流中，从off开始共len个字符
void write(String str) 将字符串中的内容压入到字符流中
void close() 关闭流并释放所占用的资源
void write(String str, int off, int len) 将字符串中的指定部分内容压入到字符流中，从下标off开始共len个字符
void flush()刷新缓冲区，将缓冲区中的数据全部送出到目标地，然后清空缓冲区
void write(char[] cbuf) 将字符数组中的所有数据压入到字符流中
一般来说：一次读写一个字符效率太低，可以引入 char[] 数组提高执行效率
小结
在学些BIO时记忆父类的方法，区分子类的实现不同
InputStream中的方法 read(byte[]):int； Reader中方法read(char[]):int 如果到达流末尾 则-1
OutputStream中的方法 write(byte[],0,len):void；Writer中的方法 write(char[],0,len)/write(String)
一般在使用中，如果读取数据使用字节流，则写出数据采用的也是字节流；不建议混用，除非引入 桥接流
文件流
FileInputStream("file-name") FileInputStream(File) FileNotFoundException
FileReader("file-name") FileReader(File) FileNotFoundException
FileOutputStream("file-name") FileOutputStream("file-name",true) 默认文件覆盖，如果 参数true表示追加
FileWriter("file-name") FileWriter("file-name",true)
一般不使用单字节或者单字符的操作方法，使用数组
注意：try()是推荐写法，否则应该使用tryfinally结构保证流的关闭
针对二进制文件不建议使用字符流，建议使用字节流进行操作，否则有可能拷贝文件出现问题：

如果针对文本文件则建议使用字符流，因为编码使用比较方便

文章知识点与官方知识档案匹配
Java技能树类和接口类和面向对象
89124 人正在系统学习中
点击阅读全文
打开CSDN，阅读体验更佳

java用于输入输出流的类_java输入输出流_lsgn的博客
java输入输出流 java IO综述 在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable。 Java I/O主要包括如下几个层次,包含三个部分: ...
java常见输入输出类型_3分钟秒懂大数据的博客
输入:每行输入一个数,连续输入n行,遇到0结束输入,然后输出结果。 importjava.util.ArrayList; importjava.util.Scanner; publicclassTest4 publicstaticvoidmain(String[] args) Scannersc=newScanner(System.in); ...
25、JAVA进阶——输入输出流
一、认识Java的流 二、使用字节流读写文本文件 1、使用字节流类FileInputStream读文本文件 2、使用字节流类FileOutputStream写文本文件 三、使用字符流读写文本文件 1、使用字符流类BufferedReader和FileReader读文本文件 2、使用字符流类BufferedWrite和FileWrite写文本文件 四、读写二进制文件 1、 使用字节流读二进制文件 2、 使用字节流写二进制文件 五、序列化和反序列化 1、认识序列化 2、序列化保存对
继续访问

java 输入类_java 输入输出类
java中输入输出类如果理不清思路的话就会很混乱!一.File类提供与操作系统无关的文件操作!可以查看api文档了解它的方法二.输出操作:1.把信息输出到屏幕上最简单的操作就是使用标准输出:System.out.println();下面讨论一下流方式的输出,与之相关的类如下OutputStreamWriter:它提供字符流到字节流的转换,换句话说它写入字符数据然后按照指定字符集转换为字节数据Buf...
继续访问
JAVA的输入输出_努力的地球人的博客_java输出
Java的输入 Scanner类 为了使用scanner类,我们首先需要导入java.util.Scanner包 import java.util.Scanner; 1 创建scanner对象,从用户获取输入 //创建scanner对象 Scanner str=new Scanner(System.in); //接受用户输入 int w=str.nextIn...
java输入输出_java中输入输出总结_weixin_39609407的博客
标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 二、java.io包中的数据流和文件类 字节流:从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。
Java——不同数据类型的输入输出方式与转化方式
java 中不同数据类型的 输入方法 输出格式 与 转化方式
继续访问

Java文本输出常用类
package com.ss.extract; import java.io.*; import org.apache.log4j.Logger; /** * 结果输出类 * @author Shu */ public class ResultOutput private ...
继续访问
1.Java基础入门 -(2)输入输出类_菜鸟的小虫子的博客
一. Java Scanner 类 java.util.Scanner是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入。 Scanner 对象的基本语法: Scanner in= new Scanner(System.in); 示例1: 输入结果: ...
java的输入输出流类型_理解JAVA输入输出流_天接云涛的博客
1、字节流抽象类 InputStream输入流 OutputStream输出流 2、字符流抽象类 Reader 输入字符流 Writer 输出字符流 四、JAVA中流体系架构 有一些对流进行操作的基本的方法,我们以文件输入输出流进行说明: ...
java的输出类
System.out这个类是PrintStream类，定义如下 public class PrintStream extends FilterOutputStream PrintStream都是用print的相关函数输出到控制台上。print的实现都是用write（String s）实现。 而，PrintWriter这个输出类，也同样实现输出：PrintWriter extends ...
继续访问
Java中的各种输出形式
一、Java中的各种输出形式： package cn.jl.lwj; public class Demo00 public static void main(String[] args) //标识符定义 区分大小写 int a = 5; int A = 6; //区分大小写 int Class = 6; int age = 5; //定义常量 final int AGE_MAX = 30;...
继续访问
java中的BIO基础-3
java中的io基础
继续访问
Java学习-IO流进阶
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。
继续访问

IO进阶之高级IO
高级IO
继续访问
Java中的IO进阶操作
Java中的IO进阶操作 一、序列化和反序列化 常用于多台服务器之间进行java对象的数据传递。 1.概念 序列化 是指程序中准备好的Java对象，永久的保存在磁盘中，这个过程其实是一个out的动作。 ObjectOutputStream：通过在流中使用文件可以实现对象的持久存储。 创建对象：ObjectOutputStream(OutputStream out) 常用方法： void writeObject(Object obj)：将指定的对象写入ObjectOutputStream 反序列化 是指把
继续访问
Java IO最详解，欢迎提出意见
Java IO 详解 初学java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。 首先看个图：（如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！） 这是java io 比较基本的一些处理流，除此之外我们还会...
继续访问
java输出类型_java中各种类型的输入输出
import java.lang.Exception;import java.lang.String;import java.util.Scanner;public class test public static void main(String[] args) Scanner s = new Scanner(System.in);char ch;System.out.print("Char...
继续访问
java中输入流的类_Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 (1)处理字节流的有DataInput接口和DataOutput接口，RandomAccessFile同时实现了这两个接口； (2)处理对象流的有ObjectInput接口和ObjectOutput接口，ObjectInputStream类实现了ObjectInput接口，ObjectOutputStream类实现了ObjectOutp...
继续访问
使用java的输入/输出类
1． 什么是IO？ I：input 输入 通常做读取操作(将不同数据源的数据读入到内存中，也叫读取流) O：output 输出通常做写入操作（将内存中的数据写入到不同的数据源，也叫写入流） 2． 理解流的概念。 想像一下自来水公司要把水输到用户家里，应该先把自来水公司到用户家里的连接水管建好，再将水输出去。管道里输送的是水，但IO里输送的是字节。 u流是...
继续访问
Java中的输入/输出流类
Java中包含的输入/输出流类 1.java.io包中的接口 （1）处理字节流的有DataInput接口和DataOutput接口，RandomAccessFile同时实现了这两个接口； （2）处理对象流的有ObjectInput接口和ObjectOutput接口，ObjectInputStream类实现了ObjectInput接口，ObjectOutputStream类实现了ObjectOutp...
继续访问
最新发布 【Java基础】自定义一个格式输出类
在项目实际开发中，后端接口都按照一定的格式输出给前端调用，在返回中包括状态码和接口的主要作用等注释，再包含实际的data。
继续访问

IO流（进阶提高）
本篇文章继上一篇IO流(小试牛刀)继续更新JavaIO流的知识。 常见IO流的结构图解： 回顾一下IO的基本接口知识： ————————————————————我是不起眼的分割线———————————————————————— IO的序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程；Java反序列化是指把字节序列恢复为Java对象的过...
继续访问
java进阶8——IO流
File类 File概述 File文件和目录路径名的抽象表示形式。即，Java中把文件或者目录（文件夹）都封装成File对象。也就是说如果我们要去操作硬盘上的文件，或者文件夹只要找到File这个类即可。 File类的构造函数 File(String pathname); // 将一个字符串路径封装成File对象 File(String parent,String child);...
继续访问
Java IO流进阶之常用流（一）
请多参考JDK文档：http://www.matools.com/api/java8或https://docs.oracle.com/javase/8/docs/api/ 转换流——OutputStreamWriter类和InputStreamReader类 字节与字符的转换流： OutputStreamWriter：是Writer类的子类，将输出的字符流变为字节流。 InputStreamRe...
继续访问
详解JAVA I/O之二——java.io层次结构
<br />java I/O(Input/Output)学习——java.io层次结构文章分类:Java编程stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型： <br />(1)字节流 <br /><br /> 表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据， 参考技术A java中处理中文输入,不需要用到的类是
经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。

1. JVM相关(包括了各个版本的特性)

对于刚刚接触Java的人来说，JVM相关的知识不一定需要理解很深，对此里面的概念有一些简单的了解即可。不过对于一个有着3年以上Java经验的资深开发者来说，不会JVM几乎是不可接受的。

JVM作为Java运行的基础，很难相信对于JVM一点都不了解的人可以把Java语言吃得很透。我在面试有超过3年Java经验的开发者的时候， JVM几乎就是一个必问的问题了。当然JVM不是唯一决定技术能力好坏的面试问题，但是可以佐证Java开发能力的高低。

在JVM这个大类中，我认为需要掌握的知识有：

JVM内存模型和结构

GC原理，性能调优

调优：Thread Dump， 分析内存结构

class 二进制字节码结构， class loader 体系 ， class加载过程 ， 实例创建过程

方法执行过程

Java各个大版本更新提供的新特性(需要简单了解)

2. Java的运行（基础必备）

这条可能出看很简单，Java程序的运行谁不会呢？不过很多时候， 我们只是单纯通过IDE去执行Java程序，底层IDE又是如何执行Java程序呢？很多人并不了解。

这个知识点是最最基本的Java开发者需要掌握的，初学Java，第一个肯定是教你如何在命令行中执行Java程序，但是很多人一旦把Java学完了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了Java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。 这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。

在这里需要掌握的知识有：

Javac 编译Java文件为 class 文件

Java 命令的使用， 带package的Java类如何在命令行中启动

Java程序涉及到的各个路径(classpath， Java。library。path， Java运行的主目录等)

3. 数据类型

这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断

主要知识点：

基本类型： int， long， float， double， boolean ， 。。。

对应的对象类型： Integer 等类型到基本类型的转换， 装箱和拆箱

Object类型： equals， hashcode

String 类型的特点

4. 对象和实例，对象的创建

在这方面，开发者需要了解class和instance的概念以及之间的差别， 这是Java面向对象特性的一个基础。主要知识点有：

Class和 Instance 的概念

Instance 创建的过程：

1、 无继承：分配内存空间， 初始化变量， 调用构造函数

2、 有继承：处理静态动作， 分配内存空间， 变量定义为初始值 ， 从基类->子类， 处理定义处的初始化， 执行构造方法

需要注意的点：

3、静态属性等从基类->子类进行初始化

4、默认无参构造方法相关的特性

5. 访问控制

这也是Java封装特性的一个基础，需要掌握的有：

public protected default private 对于class， method， field 的修饰作用

6. 流程控制

Java 流程控制的基础， 虽然有些语法不一定很常用，但是都需要了解，并且在合适的地方使用它们。

需要掌握的有：

if， switch， loop， for， while 等流程控制的语法

7. 面向对象编程的概念

这是一个Java的核心概念，对于任何Java开发者都需要熟练掌握。Java中很多特性或者说知识点都是和Java面向对象编程概念相关的。在我的理解，一个好的开发者不仅仅需要了解这些特性（知识点）本身，也更需要知道这些对象在Java的面向对象编程概念中是如何体现出来的，这样更有利于开发者掌握Java这门开发语言，以及其他面向对象编程的语言。在这里只是简单罗列了一下，主要的知识点包括有：

面向对象三大特性：封装，继承，多态; 各自的定义概念，有哪些特性体现出来，各自的使用场景

静态多分派，动态单分派的概念

重载的概念和使用

继承：接口多实现，基类单继承

抽象，抽象类，接口

多态：方法覆盖的概念和使用

接口回调

8. Static

静态属性在Java日常开发中也是经常使用，需要了解和 static 关键字相关的用法，还有和其他关键字的配合使用， 如是否可以和 abstract， final 等关键字联合使用。

主要需要掌握的有：

静态属性的定义，使用，以及类加载时如何初始化

静态方法的定义和使用

静态类的定义和使用

静态代码块的定义和初始化时机

9. 基础知识点

这里主要罗列一些散落的，没有系统归类的一些Java知识点。在日常的开发中用到也不少。 这块内容其实还有很多，目前只是暂时归纳了这几个在这里：

包括有：

equals ， hashcode ， string/stringbuffer ，final ， finally ， finalize

10.集合框架

这个是一个需要多加掌握的部分，做Java开发，可以说没有不用到集合框架的，这很重要。但是这里的知识点并不难，但是对于集合最好要了解内部的实现方式，因为这样有助于你在各个不同的场景选择适合的框架来解决问题，比如有1W个元素的集合，经常要进行contains判断操作，知道了集合的特性或者内部实现，就很容易做出正确的选择。

这里包括了如下内容(并发相关不包含在内)：

集合框架的体系： 基础Collection ，Map

具体集合实现的内容， List ，Set ，Map 具体的实现，内部结构， 特殊的方法， 适用场景等

集合相关的工具类 Collections 等的用法

11.异常框架

异常在Java的开发中可能没有那么被重视。一般遇到异常，直接上抛，或者随便catch一下处理之后对于程序整体运行也没有什么大的影响。不过在企业级设计开发中， 异常的设计与处理的好坏，往往就关系着这个系统整体的健壮性。一个好的系统的异常对于开发者来说，处理应该统一，避免各处散落很多异常处理逻辑；对于系统来说，异常应该是可控的，并且是易于运维的，某些异常出现后，应该有应对的方法，知道如何运维处理，所以虽然异常框架很简单，但是对于整个企业级应用开发来说，异常处理是很重要的，处理好异常就需要了解Java中的异常体系。

这部分需要掌握的知识点不多，主要就是：

异常的体系：

Throwable

Exception

RuntimeException

Error

RuntimeException 和 一般 Exception 的区别， 具体处理方法等

12. Java IO

IO 在Java中不仅仅是文件读写那么简单，也包括了 socket 网络的读写等等一切的输入输出操作。比如说 标准HTTP请求中Post的内容的读取也是一个输出的过程，等等…

对于IO，Java不仅提供了基本Input、Output相关的api，也提供了一些简化操作的Reader、Writer等api，在某些开发（涉及大量IO操作的项目）中也很重要，一般日常的开发中也会涉及（日志，临时文件的读写等）。

在这中的知识点主要有：

基本IO的体系： 包括有InputStream ， OutputStream， Reader/Writer， 文件读取，各种流读取等

NIO 的概念， 具体使用方式和使用场景

13.多线程并发

多线程是Java中普遍认为比较难的一块。多线程用好了可以有效提高cpu使用率， 提升整体系统效率， 特别是在有大量IO操作阻塞的情况下；但是它也是一柄双刃剑， 如果用不好，系统非但提升不大，或者没有提升，而且还会带来多线程之间的调试时等问题。

在多线程中内容有很多，只是简单说明一下Java中初步使用多线程需要掌握的知识点，以后有机会单独再详细介绍一些高级特性的使用场景。

多线程的实现和启动

callable 与 runable 区别

syncrhoized ，reentrantLock 各自特点和比对

线程池

future 异步方式获取执行结果

concurrent 包

lock

..

14.网络

Java中也是提供了可以直接操作 TCP协议、UDP协议的API。在需要强调网络性能的情况下，可以直接使用TCP/UDP 进行通讯。在查看Tomcat等的源码中，就可以看到这些相关API的使用情况。不过一般也比较少会直接使用TCP，会使用诸如MINA、Netty这样的框架来进行处理，因为这个方面的开发涉及不多，所以就不再详细罗列了。

15.时间日期处理

几乎对于每个应用来说，时间日期的处理也是绕不过去的，但是JDK8 之前的时间相关API用法并不友好。在那个时代，可以选择Joda等时间框架。到了JDK8 发布之后，全新的时间API基本融合了其他框架的优点，已经可以很好的直接使用了。

对于Java开发者来说，需要熟练地使用API来对时间和日期做相关的处理。

具体知识点不再罗列，会在以后再写个专门的文章来总结一下JDK8中时间日期API的用法。

16.XML解析/ JSON解析

其实这两块内容都不是J2SE里面的内容，但是在日常开发中，和其他程序交互，和配置文件交互，越来越离不开这两种格式的解析。

不过对于一个开发者来说，能够了解一些XML/JSON具体解析的原理和方法，有助于你在各个具体的场景中更好的选择合适你的方式来使得你的程序更有效率和更加健壮。

XML： 需要了解 DOM解析和 SAX解析的基本原理和各自的适用场景

JSON： 需要了解一些常用JSON框架的用法， 如 Jackson， FastJson， Gson 等。。

17.Maven的使用

Maven也不是Java里面的内容，但是maven是革命性的，给Java开发带来了巨大的便利。从依赖的引入和管理，开发流程的更新和发布产出，乃至版本的更新，使用maven可以大大简化开发过程中的复杂度，从而节省大量时间。可以说，maven已经成为Java开发者的标配了。所以我把maven也作为一个Java开发者对于基础必备的知识点。以后会再放上一些我的一些对于maven使用的经验和技巧等，这里就不再细说了。

18.泛型

这是JDK5开始引入的新概念，其实是个语法糖，在编写Java代码时会有些许便利， 一般的应用或者是业务的开发，只需要简单使用，不一定会用到定义泛型这样的操作， 但是开发一些基础公共组件会使用到，可以在需要的时候再细看这个部分，一般情况下只要会简单使用即可。

19.标注

也是jdk5 之后引入的。spring是个优秀的框架，最开始就以xml作为标准的配置文件。不过到了Spring3 之后，尤其是 spring-boot 兴起之后，越来越推崇使用标注来简化xml配置文件了，对于开发者来说，可以节省不少xml配置的时间。但是劣势是在于标注散落在各个类中，不像xml，可以对所有配置有个全局性的理解和管理，所以还没有办法说完全就取代所有的xml。对于一般开发者，会使用标注即可，一些公共组建的开发者可能会需要了解标注的定义和实现，可以在具体需要的时候再细看。

20.RMI

RemoteMethodInvocation ，Java语言特有的远程调用接口，使用还是比较简单方便。不过需要跨语言的情况下，就需要使用 webservice 等其他方式来支持。一般来说，程序都不需要使用RMI，不过可以在特定的情况下使用，我就在一个项目中，使用RMI来进行程序远程启动停止的控制。

21.JNI

Java Native Interface，可以允许Java中调用本地接口方法，一般用于C/C++代码的调用。需要注意的是在Java中加载so/dll文件的路径问题，本身调用接口并不复杂，但是经常在是否加载了所需的本地接口库中花费较多时间。

以上也只是简单介绍了下我对于这些Java基本知识点和技术点的一些看法和介绍， 这些内容都源自于我这些年来使用Java的一些总结， 希望给刚刚接触Java， 或者打算从Java开发的人一些经验， 希望能够更有效率地学习和使用Java， 避免走了弯路浪费了宝贵的时间。这当中还有些内容不够完善的地方，会通过以后的文章再添加上。由于个人能力有限，当然其中也会有些错误和疏漏，欢迎指正，一起讨论，共同来把这篇文章再完善下，希望它可以真正帮助到有需要的人。 参考技术B 我们以中文win2k操作系统为例说明JAVA类是如何来编码和被解码的。

第一步，我们在中文win2k中用编辑软件如记事本编写一个Java源程序文件(包括以上五类JAVA程序)，程序文件在保存时默认采用了操作系统默认支持GBK编码格式(操作系统默认支持的格式为file.encoding格式)形成了一个.java文件，也即，java程序在被编译前，我们的JAVA源程序文件是采用操作系统默认支持的file.encoding编码格式保存的，java源程序中含有中文信息字符和英文程序代码；要查看系统的file.encoding参数，可以用以下代码：

public class ShowSystemDefaultEncoding

public static void main(String[] args)

String encoding = System.getProperty("file.encoding");

System.out.println(encoding);



第二步，我们用JDK的javac.exe文件编译我们的Java源程序，由于JDK是国际版的，在编译的时候，如果我们没有用-encoding参数指定我们的JAVA源程序的编码格式，则javac.exe首先获得我们操作系统默认采用的编码格式，也即在编译java程序时，若我们不指定源程序文件的编码格式，JDK首先获得操作系统的file.encoding参数(它保存的就是操作系统默认的编码格式，如WIN2k，它的值为GBK)，然后JDK就把我们的java源程序从file.encoding编码格式转化为JAVA内部默认的UNICODE格式放入内存中。然后，javac把转换后的unicode格式的文件进行编译成.class类文件，此时.class文件是UNICODE编码的，它暂放在内存中，紧接着，JDK将此以UNICODE编码的编译后的class文件保存到我们的操作系统中形成我们见到的.class文件。对我们来说，我们最终获得的.class文件是内容以UNICODE编码格式保存的类文件，它内部包含我们源程序中的中文字符串，只不过此时它己经由file.encoding格式转化为UNICODE格式了。

这一步中，对于JSP源程序文件是不同的，对于JSP，这个过程是这样的：即WEB容器调用JSP编译器，JSP编译器先查看JSP文件中是否设置有文件编码格式，如果JSP文件中没有设置JSP文件的编码格式，则JSP编译器调用JDK先把JSP文件用JVM默认的字符编码格式(也即WEB容器所在的操作系统的默认的file.encoding)转化为临时的Servlet类，然后再把它编译成UNICODE格式的class类，并保存在临时文件夹中。如：在中文win2k上，WEB容器就把JSP文件从GBK编码格式转化为UNICODE格式，然后编译成临时保存的Servlet类，以响应用户的请求。

第三步，运行第二步编译出来的类，分为三种情况：

A、 直接在console上运行的类

B、 EJB类和不可以直接运行的支持类(如JavaBean类)

C、 JSP代码和Servlet类

D、 JAVA程序和数据库之间

下面我们分这四种情况来看。

A、直接在console上运行的类

这种情况，运行该类首先需要JVM支持，即操作系统中必须安装有JRE。运行过程是这样的：首先java启动JVM，此时JVM读出操作系统中保存的class文件并把内容读入内存中，此时内存中为UNICODE格式的class类，然后JVM运行它，如果此时此类需要接收用户输入，则类会默认用file.encoding编码格式对用户输入的串进行编码并转化为unicode保存入内存(用户可以设置输入流的编码格式)。程序运行后，产生的字符串(UNICODE编码的)再回交给JVM，最后JRE把此字符串再转化为file.encoding格式(用户可以设置输出流的编码格式)传递给操作系统显示接口并输出到界面上。

Java Swing中键盘的处理

参考技术A

　　在jdk 中 分别针对Jponent和Text类的对象定制了不同的处理键盘事件的方法 在Jponent中 定义了registerKeyboardAction方法 使用这个方法来将需要处理的键盘事件以及处理事件的行为绑定在一起 Text类中具有keymap对象 同Jponent中的处理方法类似 这个对象保存著需要处理的键盘事件和对应的行为

　　而在jdk 中 使用一种新的方法来处理键盘事件 它将jdk 的两种方法整合在一起 不需要区分被处理的是Jponent还是Text类型的组件 它定义了两个新的类 InputMap和ActionMap 他们均是简单的表或映射 一个InputMap将一个Keystroke对应到一个对象 ActionMap将一个对象对应到一个行为（Action） 通常InputMap中KeyStroke所对应的对象是一个字符串 通过这个字符串可以在ActionMap中查找到相应的行为

　　InputMap和ActionMap中均有put方法 InputMap的put方法可以将Keystroke对应到一个对象 而ActionMap的put方法可以将一个对象对应到一个行为

　　在每一个Jponent组件中 会有三个缺省的InputMap和一个缺省的ActionMap 他们可以通过调用getInputMap（int condition）和getActionMap（）得到 三个InputMap分别是当组件本身拥有焦点时的InputMap（WHEN_FOCUSED） 当组件的祖先拥有焦点时的InputMap（WHEN_ANCESTOR_OF_FOCUSED_PONENT）和组件所在的窗体具有焦点时的InputMap（WHEN_IN_FOCUSED_WINDOW）（括号内表示为了得到这些InputMap 应该在getInputMap中设置的参数） 以下分别说明这三种InputMap:

　　 组件本身拥有焦点时的InputMap:当组件拥有焦点时 键盘按键按下 则java在这个InputMap中查找键盘事件所对应的KeyStroke对象

　　 组件的祖先拥有焦点时的InputMap:当组件的祖先拥有焦点时 键盘按键按下 则java查找这个InputMap

　　 组件所在的窗口拥有焦点时的InputMap:当组件所在的窗口具有焦点时 键盘按键按下 则java查找这个InputMap

　　当一个键被按下 这个事件被转化成一个KeyStroke对象 java会查找这个Jponent的相应InputMap（例如 当组件的祖先具有焦点时 java就查找这个Jponent的祖先拥有焦点的InputMap）中是否有这个KeyStroke 如果有 取出它所对应的对象（通常是字符串） 利用这个对象在这个Jponent的ActionMap中查找 如果找到对应的行为（Action） 则java执行这个行为的actionPerformed方法（随后介绍这个方法） 从而达到处理键盘事件的目的

　　每一个InputMap可以具有parent属性 这个属性的值是一个InputMap 当在一个InputMap中查找不到键盘事件的KeyStroke时 java会自动在它的parent属性指定的InputMap中查找 依次向上查找 直至找到 使用parent的好处是 当有一些固定的 不希望用户进行改动的键盘映射可以存放在parent属性所指定的InputMap中 从而避免被意外修改 另外可以将多个Jponent的缺省InputMap设置具有相同的parent 使得可以共享一些键盘绑定的设置 可以通过InputMap类的setparent（）方法设置它的parent属性 ActionMap也具有相同的parent属性 使用方法也相同

　　以上是如何将一个键盘事件对应到一个行为 以下就简单介绍行为（Action）

　　行为是一个实现了Action接口的类 在Action接口中定义了 个方法 其中最关键的是actionPerformed（）方法 这个方法描述了这个行为的具体操作过程 其他几个方法包括setEnabled isEnabled putValue getValue addPropertyChangeListener 和removePropertyChangeListener方法 他们分别用来设置行为是否可用 判断行为可用的状态 设置和取得行为的一些属性 最后两个方法用来允许其他对象在行动对象的属性发生变化后得到通知

　　通常我们使用一个实现了Action接口的大部分方法的抽象类AbstractAction类作为基类 重载actionPerformed方法以实现我们的行为

　　我们用一个例子来具体说明如何进行实际的操作

　　 首先编写一个具体的行为 对指定的键盘事件进行处理

　　public class TextAction extends AbstractAction

　　

　　private String a;

　　public TextAction（String a）

　　 this a = a;

　　public void actionPerformed（ActionEvent parm ）

　　

　　String b = parm getActionCommand（） //得到行为的命令字符串

　　System out println（ mand= +b）

　　System out println（ prompt= +this a）

　　

　　

　　 建立四个TextAction对象

　　TextAction whenFocusSon = new TextAction（ focus son ）

　　TextAction whenFocusFather = new TextAction（ focus father ）

　　TextAction window = new TextAction（ window ）

　　TextAction ancestor = new TextAction（ ancestor ）

　　随后 在一个窗体中加入两个面板 名为sonPanel和parentPanel 使得parentPanel是sonPanel的祖先 并在sonPanel中加入一个名为son的button 在parentPanel中加入名为parent的button 在fatherPanel外加入几个button

　　得到son组件的三个InputMap 并创建一个名为focusFatherIm的InputMap 使得这个InputMap成为focusIm的parent:

　　//get default inputMap （when focus inputmap） and set a parent InputMap

　　focusIm = son getInputMap（）

　　focusFatherIm = new InputMap（）

　　focusIm setParent（focusFatherIm）

　　//get WHEN_ANCESTOR_OF_FOCUSED_PONENT inputMap

　　ancestorIm = son getInputMap（WHEN_ANCESTOR_OF_FOCUSED_PONENT）

　　//get WHEN_IN_FOCUSED_WINDOW inputMap

　　windowIm = son getInputMap（WHEN_IN_FOCUSED_WINDOW）

　　 在这些InputMap中分别加入键盘绑定

　　focusIm put（KeyStroke getKeyStroke（ f ） actionFocusSon ）

　　focusFatherIm put（KeyStroke getKeyStroke（ F ） actionFocusFather ）

　　ancestorIm put（KeyStroke getKeyStroke（ a ） actionAncestor ）

　　windowIm put（KeyStroke getKeyStroke（ w ） actionWindow ）

　　得到son组件的缺省的ActionMap 并将已经建立的行为与特定的对象（字符串）进行绑定

　　am = son getActionMap（）

　　am put（ actionFocusSon whenFocusSon）

　　am put（ actionFocusFather whenFocusFather）

　　am put（ actionAncestor ancestor）

　　am put（ actionWindow window）

　　 运行程序及其相应结果

　　 单击son按钮 这时如果按下 f F a w 程序均会有相应的输出 这是因为 此时的焦点在son按钮上 而son按钮组件的三个InputMap都是有效的 所以他们对应的事件都会发生

　　 单击parent按钮 这时按下 w 程序会有相应的输出 而按下 f F a 程序没有反应 这是因为parent按钮具有焦点 这个按钮不是son按钮的祖先 而son所在的窗口具有焦点 所以只有组件所在窗口具有焦点的InputMap是有效的

lishixinzhi/Article/program/Java/hx/201311/26304