大家好，欢迎来到IT知识分享网。
一、计算机基础知识
1、 软件开发：
*什么是软件？
软件是一系列按照特定顺序组织的计算机数据和指令的集合。程序设计的最终结果是软件
系统软件：系统软件为计算机使用提供最基本的功能：如：DOS，Windows，Linux，Unix，Mac，Android，IOS
2、人机交互
图形化界面：
命令行方式
3、Java语言特征（跨平台）
Java通过java虚拟机跨平台（JVM）
4、JDK、JRE、JVM之间的关系
JDK是整个java和核心，包括java的运行环境、java工具、java基础类库
JRE，运行JAVA程序所必须的环境的集合，保护JVM标准实现及java核心类库
JVM是java虚拟机，是一种用于计算设备的规范，他是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟平台
相关信息，使jva程序只需生产在java虚拟机上运行的目标代码，就可以在多种平台上不加修改地运行。
5：JDK安装：
官网：www.oracle.com java.sun.com
在JDK里面就有JRE，所以提示安装JRE时可以不装
6.在我的电脑-熟悉=高级=环境变量设置java工具即bin所在路径就可以了
注：%%代表调用，需要用;分割
临时配置，在dos中输入set path=你携带的U盘就JRE中的bin的路径
第二讲 基本语法及实例
1、进制的转换
实例：
1 import java.util.LinkedList; 2 3 import javax.swing.text.html.HTMLDocument.Iterator; 4 5 //查表法转换进制 6 public class jinZhi { 7 public static void main(String [] args){ 8 9 int num=6; 10 11 tobin(num); 12 13 toOct(num); 14 15 toHex(num); 16 } 17 private static void toHex(int num) { 18 con(num,15,4); 19 20 } 21 22 private static void toOct(int num) { 23 con(num,7,3); 24 25 } 26 27 private static void tobin(int num) { 28 con(num,1,1); 29 30 } 31 //列表法结合集合运用实例 32 private static void con(int num, int diwei, int yiwei) { 33 if(num==0){ 34 System.out.println("num="+0); 35 return; 36 } 37 38 // 表格法 39 char[] chs={'0','1','2','3','4','5','6','7', 40 '8','9','a','b','c','d','e','f'}; 41 42 LinkedList<Character> list=new LinkedList<Character>(); 43 44 while(num!=0){ 45 list.addFirst(chs[num&diwei]); 46 num>>>=yiwei; 47 } 48 while(!list.isEmpty()){ 49 System.out.print(list.removeFirst()); 50 } 51 System.out.println(); 52 } 53 }
直接转换的快捷方法：
1 Integer.toHexString(int num); 2 10进制——16进制 3 Integer.toOctalString(int num); 4 10进制——8进制 5 Integer.toBinaryString(int num); 6 10进制——2进制
2.数据类型
注意：String是类不是基本数据类型
当出现Object数组Object[]，可以看出是引用数据类型，是不能放入基本数据类型的；
第三讲 面向对象
概述：
面向过程强调过程、执行者、强调功能行为；
面向对象强调功能、指挥者、将功能封装进对象，强调具备功能的对象
面向对象思想的特点：问题简单化，执行者变指挥者
三大特征：封装、继承、多态
1、封装：
封装就是将具体对象一些属性和方法通过封装打包到一起，对外提供一种访问形式。
2、继承：
当多个类拥有相同的功能时，那么这些类不需要每个都写这些相同的功能，只需要把相同功能抽到
一个单独的类中，继承这个类就能获得这些相同的功能；
3、多态：
多态可以理解为事物存在的多种体系形式。比如猫，是猫也是动物
重写(override)和重载(overload)的区别：
重载的特点：
重载在同一类中。
重载方法名相同，参数列表不同。
重写的特点：
重写要有继承关系。在子父类中
重写方法的声明相同。(方法名和参数列表都相同)
子类覆盖时，子类方法权限一定要大于等于父类方法权限
父类的权限不能是私有的
父类静态只能覆盖静态。接口：
当一个类中所有的方法都是抽象的时候，你没必要定义为抽象类，定义为接口就可以了。
(2)成员特点：所以不能被创建，只能被继承
- A：只有成员变量和成员方法。
- B：成员变量 默认修饰符 public static final
- int X = 20;
- 其实是这样的 public static final int X = 20;
- C：成员方法 默认修饰符 public abstract
- void show();
- 其实是这样的 public abstract void show();
- 建议：为了便于阅读,自己手动加上修饰符
第四讲 String类和基本数据类型包装类
一、String
1、String方法
int length（）：获得长度 char charAt（index）：获得指定角标的字符返回字节
int indexOf（int ch（ASCII码））：返回ch在字符中第一次出现的位置的角标，没有则返回-1
int indexOf（int ch，int fromIndex）：从fromIndex位置开始，获取ch在字符串中位置
int indexOf（String Str）：获取str的第一次出现位置
int indexOf（String str，int fromIndex）：获取从fromIndex后第一次出现的位置角标
boolean contains（str）：判断是否包含___常用
isEmpty（）：判断是否空——常用
startsWith（str）：头部有某字符串
endsWith（str）：尾巴有某字符串
equals：判断字符串是否相同——常用——也经常被复写
equalsIgnoreCase：忽略大小写的判断字符串是否相同
2、String转换
构造函数：String（char[]）
String(char[],offset,count)//讲字符数组一部分转换为字符串
3
char[] tocharArray():将字符串转换为字符数组
String（byte[]）;将字符数组转换为字符串
String(byte[],offset,count)
byte[] getBytes();将字符串装好为字符数组
String valueOf（int）：int变String
String valueOf(double)：double变字符串
4、替换：String replace（older，newer）
5切割：String[] split(“”);切割括号捏的字符串，分成若干字符串组成字符串数组
6、获得字符串的一部分 String subString（begin,end）
7、大写：UpperCase() 小写：toLowerCase()
compareTo:字符串的自然顺序排序：常用
实例：判断字符串key在字符串Str出现的次数：
1 public static int count(String str,String key){ 2 int count=0; 3 int index=0; 4 5 while( (index=str.indexOf(key,index))!=-1){ 6 index=index+key.length(); 7 count++; 8 } 9 return count; 10 }
实例：反转字符串数组：
1 class ReverString{ 2 3 4 public static String reverseString(String s){ 5 return reverseString(s,0,s.length()); 6 } 7 8 public static String reverseString(String s, int start, int end) { 9 // 变字符数组 10 char[] ch=s.toCharArray(); 11 // 将数组反转,已经得到ch的对象的反转字符数组 12 charRecerse(ch,start,end); 13 14 return new String().valueOf(ch); 15 } 16 17 public static void charRecerse(char[] ch, int start, int end) { 18 for(int x=start,y=end-1;x<y;x++,y--){ 19 swap(ch,x,y); 20 } 21 } 22 private static void swap(char[] ch,int x,int y){ 23 char t=ch[x]; 24 ch[x]=ch[y]; 25 ch[y]=t; 26 } 27 }
实例：寻找相同子字符串
1 /* 2 * 需求：获取连个字符串中最大的相同子串 3 */ 4 5 public static String getMaxSubString(String s1,String s2){ 6 String max,min; 7 max=(s1.length()>s2.length())?s1:s2; 8 min=(max==s1)?s2:s1; 9 10 for(int x=0;x<min.length();x++){ 11 for(int y=0,z=min.length()-x;z<min.length()+1;y++,z++){ 12 String tenp=min.substring(y,z); 13 if(max.contains(tenp)){ 14 return tenp; 15 } 16 } 17 } 18 return "没有字符串"; 19 20 }
二、StirngBuffer
1、 一个长度可变的，可以操作多个数据类型的、可以通过toString方法变成字符串的容器
2方法：
append():添加
insert（数据，index）：指定位置添加
delete（start，end）删除
delexteCharAt（index）:删除指定位置
charAt（index）：获取并返回char
indexOf（Str）:返回字符串的位置
length（）：长度
subString（start，end）：获取指定位置返回String
setCharAt（index，char ch）：
反转： reverse（）
三、基本数据类型的包装类
将基本数据类型封装成对象的好处：可以在对象中定义许多功能方法操作该数据
byte—Byte short———Short int——Integer long——Long
boolean——Boolean float——Float double——Double char——Character
包装类的常用方法：
static int parseInt(String str):将数组字符串转换成数组
Integer.toBinaryString();10转2
Integer.toOctalString():10转8
Integer.toHexSfring():10转16
实例：
1 private static String StringSort(String s) { 2 // 分割 3 String[] str=s.split(" "); 4 // 转成int型 5 int[] arr=new int[str.length]; 6 for(int x=0;x<str.length;x++){ 7 // 使用Interger.parseInt方法将字符数组变Int数组 8 arr[x]=Integer.parseInt(str[x]); 9 } 10 Arrays.sort(arr); 11 12 StringBuilder sb=new StringBuilder(); 13 for(int x=0;x<arr.length;x++){ 14 sb.append(arr[x]+""); 15 } 16 sb.append(arr[arr.length-1]+""); 17 18 return sb.toString(); 19 }
Arrays工具类：
static sort(所有数据类型);
static int |
binarySearch(byte[] a, byte key) 使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。 |
|
static int |
binarySearch(byte[] a, int fromIndex, int toIndex, byte key) 使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(char[] a, char key) 使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。 |
|
static int |
binarySearch(char[] a, int fromIndex, int toIndex, char key) 使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(double[] a, double key) 使用二分搜索法来搜索指定的 double 型数组，以获得指定的值。 |
|
static int |
binarySearch(double[] a, int fromIndex, int toIndex, double key) 使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(float[] a, float key) 使用二分搜索法来搜索指定的 float 型数组，以获得指定的值。 |
|
static int |
binarySearch(float[] a, int fromIndex, int toIndex, float key) 使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(int[] a, int key) 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 |
|
static int |
binarySearch(int[] a, int fromIndex, int toIndex, int key) 使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(long[] a, int fromIndex, int toIndex, long key) 使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(long[] a, long key) 使用二分搜索法来搜索指定的 long 型数组，以获得指定的值。 |
|
static int |
binarySearch(Object[] a, int fromIndex, int toIndex, Object key) 使用二分搜索法来搜索指定数组的范围，以获得指定对象。 |
|
static int |
binarySearch(Object[] a, Object key) 使用二分搜索法来搜索指定数组，以获得指定对象。 |
|
static int |
binarySearch(short[] a, int fromIndex, int toIndex, short key) 使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。 |
|
static int |
binarySearch(short[] a, short key) 使用二分搜索法来搜索指定的 short 型数组，以获得指定的值。 |
|
static
|
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) 使用二分搜索法来搜索指定数组的范围，以获得指定对象。 |
|
static
|
binarySearch(T[] a, T key, Comparator<? super T> c) 使用二分搜索法来搜索指定数组，以获得指定对象。 |
第五讲 多线程
一个进程又多个线程同时操控，从而达到同时运行的效果：
1两种方式
extend Thread方式：首先类继承Thread，然后复写run；创建这个类，使用start（）方法启动
inplements Runnable：类implements Runnable，复写run；创建类，创建线程Thread一类对象为参数，使用startt（0启动
2、买票练习：
1 import java.util.Arrays; 2 //买票 3 public class StringSort { 4 5 public static void main(String[] args){ 6 Ticket tk = new Ticket();//建立票信息对象 7 sealCentre tsc = new sealCentre(tk);// 创建售票中心。 8 tsc.set(200);//售票中心分配一定数量的票 9 new Thread(new windowsSeal(tk,"一号窗口")).start();// 创建、启动线程，开始卖票。 10 new Thread(new windowsSeal(tk,"二号窗口")).start(); 11 new Thread(new windowsSeal(tk,"三号窗口")).start(); 12 new Thread(new windowsSeal(tk,"四号窗口")).start(); 13 } 14 15 } 16 17 18 class Ticket{ 19 private int ticket; 20 21 public int getTicket() { 22 return ticket; 23 } 24 25 public void setTicket(int ticket) { 26 this.ticket = ticket; 27 } 28 29 30 } 31 32 33 class sealCentre{ 34 private Ticket tk; 35 sealCentre(Ticket tk){ 36 this.tk=tk; 37 } 38 public void set(int t){ 39 tk.setTicket(t); 40 } 41 } 42 43 class windowsSeal implements Runnable{ 44 private Ticket tk; 45 private String name; 46 windowsSeal(Ticket tk,String name){ 47 this.tk=tk; 48 this.name=name; 49 } 50 @Override 51 public void run() { 52 53 while(true){ 54 synchronized (tk) { 55 int t=tk.getTicket(); 56 if(t>0){ 57 System.out.println(name+"第"+(t--)+"张票卖出"); 58 tk.setTicket(t); 59 }else{ 60 System.out.println(name+"票已经售完"); 61 // System.exit(0); 62 break; 63 } 64 } 65 } 66 } 67 }
在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,join(),wait(),yield等方法都可以导致线程阻塞。
第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。
线程之间的通信：
1、多个线程并法执行是，CUP是随机切换的，如果我们希望他们有规律的执行，例如:各自运行一次
2、方法步骤：如果希望线程等待wait（）；希望被唤醒notify；这两个方法必须同步，并且使用同步锁为对象
3、多个线程通信出现问题：
notify（）方法是随机唤醒一个线程
notifyAll（）方法是唤醒所有线程
JDK5之前无法唤醒指定线程
如果多个线程之间通信，需要使用notifyAll（）通知所有线程，用while反复判断条件
第六讲 集合
主要掌握的集合：
Collection
List：
|–ArrayList：底层的数据结构使用的是数组结构；查询快，增删慢，不同步
|-LinkedList：底层的数据结构使用的是链式结构；查询慢，增删快
|-Vector：底层数组结构：同步
Set：不可重复，无索引，无序（）(注意：Set集合都要求不可重复的，所以如何做到不可重复是这里要掌握的)
|——HashSet：底层数据结构式哈希表。不同步，判断依据是hashCode值，然后是equals
|——TreeSet：底层数据位2查数，判断依据是compareTo和hashCode
还有LinkedHashSet
Map
|-HashMap：哈希表，hashCode，equals
|-TreeMap：二叉树，compareTO，hashCode
还有Hashtable 和LinkedHashMap
实例：使用ArrayLIst添加自定义对象，注意复写equals
1 mport java.lang.*; 2 2 import java.util.*; 3 3 /*需求：使用ArrayList添加字符串元素，并提出重复项 4 4 * 原理：添加一个临时容器，在迭代原集合，临时集合包含时才添加到临时集合 5 5 由于contains判断依据是equals所以我在自定义的类中复写equals 6 6 */ 7 7 8 8 class Student{ 9 9 private String name; 10 10 private int age; 11 11 Student(String name,int age){ 12 12 this.name=name; 13 13 this.age=age; 14 14 } 15 15 public String getName() { 16 16 return name; 17 17 } 18 18 19 19 public int getAge() { 20 20 return age; 21 21 } 22 22 public boolean equals(Object obj) { 23 23 if (!(obj instanceof Student)){ 24 24 return false; 25 25 } 26 26 Person p=(Person)obj; 27 27 return this.name.equals(name)&&this.age==age; 28 28 } 29 29 30 30 } 31 31 public class ArrayListDemo { 32 32 public static void main(String[] args){ 33 33 ArrayList<Student> al=new ArrayList<Student>(); 34 34 35 35 al.add(new Student("shuiyin",35)); 36 36 al.add(new Student("shuiyin",25)); 37 37 al.add(new Student("shuiyin",15)); 38 38 al.add(new Student("shuiyin",15)); 39 39 40 40 al=(ArrayList<Student>) zouni(al); 41 41 42 42 Iterator<Student> it=al.iterator(); 43 43 while(it.hasNext()){ 44 44 System.out.println(it.next()); 45 45 } 46 46 47 47 } 48 48 49 49 private static List zouni(ArrayList<Student> list) { 50 50 // 迭代 51 51 Iterator<Student> it=list.iterator(); 52 52 List<Student> al=new ArrayList<Student>(); 53 53 while(it.hasNext()){ 54 54 Object obj=it.next(); 55 55 if(al.contains(obj)){ 56 56 al.add((Student) obj); 57 57 } 58 58 } 59 59 return al; 60 60 } 61 61 }
实例：LinkedList增删方面，尤其是他在头尾添加取出元素的方法好用
1 模拟堆栈和队列 2 3 1 LinkedList<String> l=new LinkedList(); 4 2 l.addFirst("shuiyin01"); 5 3 l.addFirst("shuiyin02"); 6 4 l.addFirst("shuiyin03"); 7 5 l.addFirst("shuiyin04"); 8 6 l.addFirst("shuiyin05"); 9 7 // 堆栈 10 8 stack(l); 11 9 // 队列 12 10 queque(l); 13 11 } 14 12 15 13 private static void queque(LinkedList<String> l) { 16 14 while(!l.isEmpty()){ 17 15 System.out.print(l.removeLast()); 18 16 } 19 17 20 18 } 21 19 22 20 private static void stack(LinkedList<String> l) { 23 21 while(!l.isEmpty()){ 24 22 System.out.print(l.removeFirst()); 25 23 } 26 24 }
使用HashSet集合注意需要复写HashCode（）和equals（）方法
1 public boolean equals(Object obj){ 2 16 if(!(obj instanceof Student)){ 3 17 return false; 4 18 } 5 19 Student s=(Student)obj; 6 20 return this.name.equals(s.name)&&this.age==age; 7 21 } 8 22 9 23 public int hashCode(){ 10 24 return this.name.hashCode()*31+this.age*2; 11 25 }
是TreeSet就比较麻烦需要implements Comparable 同时复写comparaTo
1 class Student implements Comparable{ 2 7 private String name; 3 8 private int age; 4 9 Student(String name,int age){ 5 10 this.name=name; 6 11 this.age=age; 7 12 } 8 13 // 需要复写compareTo()使得比较结构-1,0,1,比较年龄在比较名字compareTo 9 14 public int compareTo(Object obj){ 10 15 if(!(obj instanceof Student)){ 11 16 throw new RuntimeException("类型不对啊！"); 12 17 } 13 18 Student s=(Student)obj; 14 19 if(this.age==s.age){ 15 20 return this.name.compareTo(s.name); 16 21 } 17 22 return new Integer(this.age).compareTo(new Integer(s.age)); 18 23 // 可以return this.age-s.age;上面这样可以保证结果是-1,1 19 24 } 20 25 21 26 public String getName() { 22 27 return name; 23 28 } 24 29 25 30 public int getAge() { 26 31 return age; 27 32 }
TreeSet还有自身独特的优先级高的方法：比较器
1 TreeSet<Student> al=new TreeSet<Student>(new myCompare());（新创比较器做参数） 2 3 4 //实现Comparator并复写compare（elements1，elements2）{} 5 //定义一个比较器哦，以性命的长度作为主要比较 6 20 class myCompare implements Comparator<Student>{ 7 21 8 22 public int compare(Student s1, Student s2) { 9 23 int num=s1.getName().length()-s2.getName().length(); 10 24 // 相同是比较CompareTo 11 25 if(num==0){ 12 26 return s1.getName().compareTo(s2.getName()); 13 27 } 14 28 return num; 15 29 }
Map集合掌握keySet和entrySet的取值方法：根据集合底层类型决定自定义类中复写的方法：
如Hash就复写HashCode（）和equals；如Tree就复写compareTo；
keySet迭代法：
1 65 private static void keySet(HashMap<Student, String> hm) { 2 66 // 使用keySet迭代法 3 67 Iterator<Student> it=hm.keySet().iterator(); 4 68 5 69 while(it.hasNext()){ 6 70 Student key=it.next();//得到键 7 71 String value=hm.get(key); 8 72 System.out.println(key+"::"+value); 9 73 }
entrySet迭代法：
1 Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator(); 2 16 while(it.hasNext()){ 3 17 Map.Entry<Student, String> me=it.next(); 4 18 Student key=me.getKey(); 5 19 String value=me.getValue(); 6 20 System.out.println(key+"**"+value);
扩展：
BigInteger
1创建：BigInteger（String）来创建一个很大的整数，可以无限大，之创建后不会被改变（类似String）
2.常用方法：
×BigInteger add（BigInter val）;加
×BigInteger subtract（BigInter val）;减
×BigInteger multiply（BigInter val）;乘
×BigInteger divide（BigInter val）;除
×BigInteger mod（BigInter val）;摸，取余
×BigInteger max（BigInter val）;最大值
×BigInteger min（BigInter val）;最小值
第七讲 IO流
读写数据用的类：InputStream OutputStream Reader Writer以及他们的子类组成IO流
实例：键盘输入，把输入的数据写入文件，，大写后按over结束；
1 import java.io.*; 2 3 public class OutInDemo { 4 public static void main(String[] args)throws Exception{ 5 BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in)); 6 7 BufferedWriter bufw=new BufferedWriter(new FileWriter("D:\\tt.txt")); 8 9 String line=null; 10 11 while((line=bufr.readLine())!=null){ 12 bufw.write(line); 13 bufw.newLine(); 14 bufw.flush(); 15 } 16 17 bufw.close(); 18 bufr.close(); 19 } 20 }
拷贝媒体文件：
1 BufferedOutputStream bufo=new BufferedOutputStream(new FileOutputStream("aa.mp3")); 2 BufferedInputStream bufi=new BufferedInputStream(new FileInputStream("bb.mps")); 3 4 int len=0; 5 while((len=bufi.read())!=-1){ 6 bufo.write(len); 7 } 8 bufo.close(); 9 bufi.close();
序列流的玩法：
1 FileInputStream fs1=new FileInputStream("a.txt"); 2 FileInputStream fs2=new FileInputStream("b.txt"); 3 SequenceInputStream sis=new SequenceInputStream(fs1,fs2); 4 5 FileOutputStream fos=new FileOutputStream("c.txt"); 6 7 byte[] bu=new byte[104]; 8 int len=0; 9 while((len=sis.read(bu))!=-1){ 10 fos.write(bu,0,len); 11 } 12 sis.close(); 13 fos.close();
整合多个
1 FileInputStream fs1=new FileInputStream("a.txt"); 2 FileInputStream fs2=new FileInputStream("b.txt"); 3 FileInputStream fs3=new FileInputStream("c.txt"); 4 5 Vector<InputStream> v=new Vector<InputStream>(); 6 v.add(fs1); 7 v.add(fs2); 8 v.add(fs3); 9 10 Enumeration<InputStream> en=v.elements(); 11 12 SequenceInputStream sis=new SequenceInputStream(en); 13 14 FileOutputStream fos=new FileOutputStream("c.txt"); 15 16 byte[] bu=new byte[104]; 17 int len=0; 18 while((len=sis.read(bu))!=-1){ 19 fos.write(bu,0,len); 20 } 21 sis.close(); 22 fos.close();
内存输出流：
该输出流可以向内存中希尔数据，把内存当作一个缓冲区，然后一次性获取所有数据
1 public static void main(String[] args)throws Exception{ 2 3 FileInputStream fis=new FileInputStream("a.txt"); 4 5 ByteArrayOutputStream bis=new ByteArrayOutputStream(); 6 int b; 7 while((b=fis.read())!=-1){ 8 bis.write(b); 9 } 10 // 只需要 一次性输出就行了 11 System.out.println(bis); 12 13 fis.close(); 14 }
IO流方法总结
1、字节流：
×FileInputStream，FileOutputStream，自定义数组拷贝文件
×BufferedInputStream，BufferedOutputStream，内置缓冲区拷贝文件
2、字符流：
×FileReader，FileWriter
×InoutStreamReader，OutputStreamWriter，转换流，在键盘录入和编码表转换使用过
×BufferedReader，BufferedWriter，记得newLine和flush，除非了使用PrintWriter
3、File
×掌握文件的递归
免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://yundeesoft.com/34598.html
