Java进阶之路05-(集合3.异常.文本IO流1)

文中关键字:HashMap TreeMap Throwable异常 Collections工具类 File类 IO流1 递归思想
/**
*HashMap集合本身基于哈希表,是一个双列集合
*
* 它可以保证键的唯一性(Map都是针对键有效)
* 看一下下面代码:
* HashMap<键,值>
* String:人的ID编号
* String:人的姓名
*/
导包:
import java.util.HashMap;
import java.util.Set;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
//创建HashMap集合对象
HashMap<String, String> map = new HashMap<String,String>();
//添加元素
map.put("it001", "马云") ;
map.put("it003", "马化腾") ;
map.put("it004", "乔布斯") ;
map.put("it001", "裘伯君"); //wps
map.put("it005", "比尔盖茨");
//遍历元素
//获取所有的键的集合
Set<String> set = map.keySet() ;
for(String key :set) {
String value = map.get(key) ;
System.out.println(key+"---"+value);
}
}
-----------------------------------------------------------------------------
/**
*HashMap<Student,String> 键:也可以是一种自定义类型
*Student:学生:年龄和姓名
*String:朝代
*如果对象的成员变量值一样,认为同一个人.
*HashMap底层哈希表
* 哈希表:依赖于两个方法 hashCode() ,equals()方法,因此在自定义类中需要重写这两个函数
*/
导包:
import java.util.HashMap;
import java.util.Set;

主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建集合对象
HashMap<Student, String> map = new HashMap<Student,String>() ;

//创建学生对象
Student s1 = new Student("西施", 27) ;
Student s2 = new Student("杨贵妃", 35) ;
Student s3 = new Student("王昭君", 30) ;
Student s4 = new Student("貂蝉",28) ;
Student s5 = new Student("西施", 27) ;

//添加元素
map.put(s1, "元朝") ;
map.put(s2, "宋朝") ;
map.put(s3, "唐朝") ;
map.put(s4, "清朝") ;
map.put(s5, "金") ;

//遍历
Set<Student> set = map.keySet() ;
for(Student s :set) {
String value = map.get(s) ;
System.out.println(s.getName()+"---"+s.getAge()+"---"+value);
}
}
Student类:
public class Student {

private String name ;
private int age ;

public Student() {
super();
}

public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

// 重写hashCode()和equals()方法
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
-----------------------------------------------------------------------------
/**
*LinkedHashMap<K,V> :是Map接口基于哈希表和链接列表实现的
*
*哈希表保证键的唯一性
*链接列表保证元素有序性(存储和取出一致)
*/
导包:
import java.util.LinkedHashMap;
import java.util.Set;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<String,String>() ;

//添加元素
map.put("it001", "hello");
map.put("it002", "mysql");
map.put("it003", "world");
map.put("it004", "javaweb");
map.put("it001", "javaee");

Set<String> set = map.keySet() ;
for(String key :set) {
String value = map.get(key) ;
System.out.println(key+"----"+value);
}
}
-----------------------------------------------------------------------------
/**
*TreeMap存储自定义类型
*TreeMap基于红黑树结构的Map接口的实现,和之前说到的TreeSet相似,都会提供排序
*TreeMap<Student,String>
* 主要条件:年龄从小到大
*/
导包:
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
//创建一个TreeMap集合,使用比较器排序的方式
//匿名内部类的方式
TreeMap<Student, String> tm = new TreeMap<Student,String>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {

//主要条件:年龄从小到大
int num =s1.getAge() -s2.getAge() ;
//年龄相同,不一定姓名一样
int num2 = num ==0 ? s1.getName().compareTo(s2.getName()): num ;
return num2 ;
}

} );

//创建学生对象
Student s1 = new Student("唐伯虎", 28) ;
Student s2 = new Student("杜甫", 35) ;
Student s3 = new Student("李白", 40) ;
Student s4 = new Student("李清照", 32) ;
Student s5 = new Student("唐伯虎", 28) ;
Student s6 = new Student("苏轼", 35) ;

//添加到集合中
tm.put(s1, "宋代") ;
tm.put(s2, "唐代") ;
tm.put(s3, "唐代") ;
tm.put(s4, "宋代") ;
tm.put(s5, "清代") ;
tm.put(s6, "清代") ;
//遍历
Set<Student> set = tm.keySet() ;
for(Student key :set) {
String value = tm.get(key) ;
System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
}
}
Stydent类:
public class Student {

private String name ;
private int age ;

public Student() {
super();
}

public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}
-----------------------------------------------------------------------------
重点例题:
/**
* 需求：
*假设HashMap集合的元素是ArrayList。有3个。
*每一个ArrayList集合的值是字符串。
*元素我已经完成，请遍历。
*结果：
* 三国演义
* 吕布
* 周瑜
* 笑傲江湖
* 令狐冲
* 林平之
* 神雕侠侣
* 郭靖
* 杨过
*HashMap<String,ArrayList<String>>
*/
导包:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
//创建一个大集合对象
HashMap<String, ArrayList<String>> hm = new HashMap<String,ArrayList<String>>() ;

//创建第一个子集合对象
ArrayList<String> array1 = new ArrayList<String>() ;
array1.add("吕布") ;
array1.add("周瑜") ;

//添加到集合中
hm.put("三国演义", array1) ;

//创建第二个子集合对象
ArrayList<String> array2 = new ArrayList<String>() ;
array2.add("令狐冲") ;
array2.add("林平之") ;

//添加到集合中
hm.put("笑傲江湖", array2) ;

//创建第二个子集合对象
ArrayList<String> array3 = new ArrayList<String>() ;
array3.add("郭靖") ;
array3.add("杨过") ;

//添加到集合中
hm.put("神雕侠侣", array3) ;

//遍历
Set<String> set = hm.keySet() ;
for(String key :set) {
System.out.println(key) ;

//通过key获取value
ArrayList<String> value = hm.get(key) ;
for(String s: value) {
System.out.println("\t"+s);
}
}

}
-----------------------------------------------------------------------------
重点例题:
/**
*HashMap集合嵌套HashMap集合
*
* JAVA班
*
* jc(基础班)
* 高圆圆 27
* 张三 28
*
* jy(就业班)
* 赵又廷 29
* 李四 30
*
* HashMap<String,HashMap<String,Integer>>
*
*/
导包:
import java.util.HashMap;
import java.util.Set;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建一个大集合
HashMap<String,HashMap<String,Integer>> map =
new HashMap<String,HashMap<String,Integer>>();

//创建第一子HashMap集合,存储元素
HashMap<String, Integer> hm1 = new HashMap<String,Integer>() ;
hm1.put("高圆圆", 27) ;
hm1.put("张三", 28) ;

//将第一个子集合添加到大集合中
map.put("jc", hm1) ;

//创建第二个子HashMap集合,存储元素
HashMap<String, Integer> hm2 = new HashMap<String,Integer>() ;
hm2.put("赵又廷", 29) ;
hm2.put("李四",30) ;

//添加到大集合中
map.put("jy", hm2) ;

//遍历
Set<String> mapSet = map.keySet() ;
for(String mapSetKey :mapSet) {
System.out.println(mapSetKey);
//通过大集合的对象,通过键获取值(HashMap集合)

HashMap<String, Integer> mapSetKeyValue = map.get(mapSetKey) ;
//获取所有的键的集合
Set<String> mapSetKeyValueKey = mapSetKeyValue.keySet() ;
for(String mapSetKeyValueKeyKey :mapSetKeyValueKey) {
Integer mapSetKeyValueKeyKeyValue = mapSetKeyValue.get(mapSetKeyValueKeyKey) ;
System.out.println("\t"+mapSetKeyValueKeyKey+"---"+mapSetKeyValueKeyKeyValue);
}
}

}
-----------------------------------------------------------------------------
*面试题:
* HashMap集合和Hashtable的区别?
* 共同点:都是map接口的实现类,都是基于哈希表的实现类
* HashMap集合线程不安全的类,不同步,执行效率高(允许键和值是null的)
* Hashtable集合线程安全的类,同步,执行效率低(不允许有null键和null值)
*线程安全的类:
* StringBuffer :字符串缓冲区
* Vector :List集合
* Hashtable :Map集合的
-----------------------------------------------------------------------------
用到了很多之前的知识点:
/**
*需求:
* 字符串:比如: aaaaabbbbcccddddee ,最终控制台要出现的结果:a(5)b(4)c(3)d(3)e(2)
*
*思路:
* 1)改进:键盘录入一个字符串
* 2)创建一个HashMap集合key:Character,Value:Integer
* 3)将录入的字符串转换成字符数组
* 4)遍历可以获取每一个字符
* 5)将元素添加到对应的HashMap集合中
* 使用的put(key,value): 通过判断值是否null ,如果是null表示第一次存储
* 集合对象.put(ch,1) ;
* 否则,不是null
* Integer那个值++;
* 集合对象.put(ch,变量Integer值) ;
* 6)遍历HashMap集合即可
*/
导包:
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入一个字符串:");
String line = sc.nextLine() ;

//创建一个HashMap集合来存储对应的字符和值
HashMap<Character, Integer> hm = new HashMap<Character,Integer>() ;

//将字符串转换成字符串
char[] chs = line.toCharArray() ;

//遍历字符数组,获取到每一个字符
for(char ch:chs) {
//获取到每一个字符
Integer i = hm.get(ch) ; //肯定要把值获取到
System.out.println(i);

//通过put方法添加元素,看这个值是否为null
if(i==null) {
//第一次存储
hm.put(ch, 1);
}else {
//不是null,存储了多次
i ++ ;
hm.put(ch, i) ;
}
}
//创建一个字符串缓冲区对象
StringBuilder sb = new StringBuilder() ;
//遍历HashMap集合
Set<Character> set = hm.keySet() ;
for(Character key :set) {
//获取值
Integer value = hm.get(key) ;
sb.append(key).append("(").append(value).append(")") ;
}
String str = sb.toString() ;
System.out.println("str:"+str);
}
*****************************************************************************
/**
*Collections:针对集合操作的工具类
*Collection和Collections的区别:
* Collection:顶层次单列集合的根接口,它是一个集合,是一个接口
* Collections:是针对集合操作的工具类,有一些功能:随机置换,集合里面的二分查找,将集合的元素进行反转
*
*集合的二分查找
* public static <T> int binarySearch(List<T> list, T key)
* static T max(Collection coll):获取集合中的最大值
* public static void reverse(List<?> list):将集合中的元素顺序反转
* public static void shuffle(List<?> list):将集合中的元素打乱
* public static void sort(List<T> list)
*/
导包:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.SynchronousQueue;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
List<Integer> array = new ArrayList<Integer>() ;
//添加元素
array.add(55);
array.add(11);
array.add(10);
array.add(20);
array.add(25);
array.add(21);
array.add(29);

System.out.println(array);

Collections.sort(array);//集合排序
System.out.println(array);

int index = Collections.binarySearch(array,11); //针对集合元素有序
System.out.println(index);

//static T max(Collection coll):获取集合中的最大值
System.out.println(Collections.max(array));

//public static void reverse(List<?> list):将集合中的元素顺序反转
Collections.reverse(array);
System.out.println(array);

//public static void shuffle(List<?> list):将集合中的元素打乱
Collections.shuffle(array) ;
System.out.println(array);
}
-----------------------------------------------------------------------------
/**
*public static void sort(List<T> list ,Comparator comparator):可以使用比较器进行排序
*
*/
导包:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
List<Student> list = new ArrayList<Student> (); //元素可以重复
//创建学生对象
Student s1 = new Student("高圆圆", 28);
Student s2 = new Student("唐嫣", 28);
Student s3 = new Student("刘诗诗", 28);
Student s4 = new Student("文章", 30);
Student s5 = new Student("马伊琍", 39);
Student s6 = new Student("高圆圆", 28);

//添加到集合中
list.add(s1) ;
list.add(s2) ;
list.add(s3) ;
list.add(s4) ;
list.add(s5) ;
list.add(s6) ;

//直接可以使用Collections的sort功能进行条件排序

//比较器排序 (两种方式习惯使用比较器排序)
Collections.sort(list, new Comparator<Student>() {

@Override
public int compare(Student s1, Student s2) {
//主要条件
int num = s1.getAge()-s2.getAge() ;
int num2= num==0 ?s1.getName().compareTo(s2.getName()) :num ;
return num2 ;
}
});

//方式1:自然排序如果两种排序都出现了,那么会按照后面的排序方法排序
//Collections.sort(list);
for(Student s: list) {
System.out.println(s.getName()+"---"+s.getAge());
}
}
Student类:
public class Student implements Comparable<Student>{

private String name ;
private int age ;

public Student() {
super();
}

public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public int compareTo(Student s) {
//主要条件
int num = s.getAge() -this.getAge() ;
int num2= num==0 ?this.getName().compareTo(s.getName()) :num ;
return num2 ;
}
}
-----------------------------------------------------------------------------
重点例题:因为代码中包含了四种花色属于特殊符号,因此在保存的时候选择编码格式为utf-8格式保存
/**
*需求:针对自定义对象的年龄从小到大排序 ,Collections的sort(List,Comparator)
*模拟斗地主的洗牌和发牌的逻辑
*
*
*
*思路:
* 1)创建一个牌盒(容器:集合)
* ArrayList<String>
* 2)装牌
* 定义花色数组和点数数组(A,K)
* 红桃A
* 黑桃A
* 梅花A
* 方片A
* ....
* 3)洗牌
* Collections中的随机置换的功能
*
* 4)发牌
* 遍历集合(获取集合中的具体的牌)
* 需要判断:选择结构语句
* 1--->A 2--->B 3----C
* 4---A .................
*
* 斗地主三个玩
* 发个三个人----->三个人分别ArrayList<String>
* 如果当前牌 % 3 ==0/1/2
*
* 5)看牌
* 三个人看牌:将看牌封装成一个功能(独立的代码块)
*
*/
导包 :
import java.util.ArrayList;
import java.util.Collections;
主方法:
public class Poker {

public static void main(String[] args) {

//1.创建牌盒
ArrayList<String> array = new ArrayList<String>() ;

//2.装牌
//2.1创建花色数组
String[] colors = {"♥","♠","♣","♦"} ;
//2.2 创建点数数组
String[] numbers = {"A","2","3","4","5","6","7","8","9",
"10","J","Q","K"} ;
for(String color :colors) {
for(String number:numbers) {
String poker = color.concat(number) ;
array.add(poker) ;
}
}

//添加小王和大王
array.add("小王") ;
array.add("大王") ;

//3. 洗牌
Collections.shuffle(array);
//System.out.println(array);

//4.发牌
//现在三个人玩,把每一个看成集合ArrayList
ArrayList<String> player1 = new ArrayList<String>() ;
ArrayList<String> player2 = new ArrayList<String>() ;
ArrayList<String> player3 = new ArrayList<String>() ;
ArrayList<String> diPai = new ArrayList<String>() ;

//有规律的:遍历ArrayList集合使用普通for循环,获取到集合的元素
//通过元素 % 人数 = 0 /1/2 /..
for(int x = 0 ; x < array.size() ; x ++) {
//获取到每一个元素
if(x >= array.size() -3) {
diPai.add(array.get(x)) ;
}else if(x % 3 == 0) {
//玩家1
player1.add(array.get(x)) ;
}else if(x % 3 == 1) {
//玩家2
player2.add(array.get(x)) ;
}else if(x % 3 == 2) {
player3.add(array.get(x)) ;
}
}

//5)看牌
//三个人看牌:将看牌封装成一个功能(独立的代码块)
lookPoker("玩家1", player1);
lookPoker("玩家2", player2);
lookPoker("玩家3", player3);
lookPoker("底牌", diPai);
}

public static void lookPoker(String name,ArrayList<String> array) {
System.out.print(name+"的牌是:");
for(String s : array) {
System.out.print(s+" ");
}
System.out.println();
}
}
-----------------------------------------------------------------------------
斗地主改进版:
/**
* 模拟斗地主的洗牌和发牌,发到每一个手上的牌是保证有序的.. 思考: 1)创建牌盒
* 创建两个集合:HashMap<Integer,String>,ArrayList<Integer> 2)装牌定义花色数组和点数数组
* 从0开始编号,将编号和编号对应的牌都存储到HashMap集合中,同时往ArrayList单独存储编号 3)洗牌洗的是编号 4)发牌
* 发的也是编号,为了保证牌有序,集合由TreeSet集合接收 5)看牌封装功能

导包:
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

import java.util.TreeSet;

public class Porker2 {
public static void main(String[] args) {
// 1. 创建两个集合:HashMap<Integer,String>,ArrayList<Integer>
HashMap<Integer, String> hm = new HashMap<Integer, String>();
ArrayList<Integer> array = new ArrayList<Integer>();

// 2.装牌
// 2.1 定义花色数组和点数数组
String[] colors = { "♥", "♠", "♣", "♦" };
String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };

// 从0开始编号,将编号和编号对应的牌都存储到HashMap集合中,同时往ArrayList单独存储编号
int index = 0;
// 拼接
for (String number : numbers) {
for (String color : colors) {
String poker = color.concat(number);
hm.put(index, poker);
array.add(index);
index++;
}
}

// 装小王和大王
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王");
array.add(index);
// 不能++了,角标越界

// 洗牌
Collections.shuffle(array);
// System.out.println(array);

// 4)发牌
// 发的也是编号,为了保证牌有序,集合由TreeSet集合接收
TreeSet<Integer> player1 = new TreeSet<Integer>();
TreeSet<Integer> player2 = new TreeSet<Integer>();
TreeSet<Integer> player3 = new TreeSet<Integer>();
TreeSet<Integer> diPai = new TreeSet<Integer>();

// 有规律的:遍历ArrayList集合使用普通for循环,获取到集合的元素
// 通过元素 % 人数 = 0 /1/2 /..
for (int x = 0; x < array.size(); x++) {
// 获取到每一个元素
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
// 玩家1
player1.add(array.get(x));
} else if (x % 3 == 1) {
// 玩家2
player2.add(array.get(x));
} else if (x % 3 == 2) {
player3.add(array.get(x));
}
}
//5)看牌封装功能
lookPoker("玩家1", player1, hm);
lookPoker("玩家2", player2, hm);
lookPoker("玩家3", player3, hm);
lookPoker("底牌", diPai, hm);

}

public static void lookPoker(String name,TreeSet<Integer> ts,
HashMap<Integer, String> hm) {
System.out.print(name+"的牌是:");
//遍历TreeSet集合获取到每一个编号
for(Integer key :ts) {
//获取到编号,通过编号找牌(在HashMap中找)
String value = hm.get(key) ;
System.out.print(value+" ");
}
System.out.println();
}
}
*****************************************************************************
**
*当程序出现一些问题的,可以是严重问题,可以是一种异常,将这些通常为Throwable
*Throwable 类是 Java 语言中所有错误或异常的超类
* Throwable
* error
* exception
*
* 举例:
* 张三去山上旅行
* 1)张三骑车去旅行,山路崩塌了,不能前行了----->不可抗力因素
* 2)张三骑车去旅行,骑着发现轮胎没气了------->需要检查的问题
* 3)骑着,山路有石子,他就非得往石子上骑,导致车胎没气了---->自己原因造成的,no zuo no die
*
* 不抗力因素----->error: 属于严重问题内存溢出了 (加载页面中大量图片的时候,程序会挂掉---使用第三方的框架去处理:ImageLoader)
* 异常:
* 编译时期异常:只要出现的不是运行时期异常,统称为编译时期日期的文本格式---解析 java.util.Date类型:ParseException:解析异常
* 编译时期异常:开发者必须处理!
* 运行时期异常:RuntimeException
* 编译通过了,但是开发者代码不严谨(NullPointerExceptino等等...)
*/
看下面代码:
public class ExceptionDemo {

public static void main(String[] args) {
int a = 10 ;
int b = 0 ;
System.out.println(a/b);//java.lang.ArithmeticException: 除数不能为0的异常
}
}
-----------------------------------------------------------------------------
**
*异常的处理分为两种:
* 1)try...catch...finally (标准格式) :捕获异常快捷键:shift+alt+z
* 2)throws ... 抛出异常
*
*
*变形格式...
*try...catch...
*try...catch...catch...
*catch....
*
*try{
* 一些代码
* try里面的代码越少越好
* 代码包含了可能会出现问题的代码
*}catch(异常类异常类对象){
* try出现异常了,描述的异常刚好就是catch的异常类,就会执行catch里面代码
* //处理异常
*}
*
*/
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

int a = 10 ;
int b = 0 ;
try {//捕获到
//出现问题的代码
System.out.println(a/b);
}catch(ArithmeticException e) { //ArithmeticException e = new ArithmeticException() ;
//用输出语句来处理异常
System.out.println("初始不能0");
//e.printStackTrace();
}

System.out.println("over");

}
-----------------------------------------------------------------------------
/**
*如何处理多个异常
* 两个或两个以上的异常的时候怎么办?
*
* try{
* 可能出现问题的代码
* }catch(异常类对象名){
* 处理异常的代码
* }
*
*
* try{
* 可能出现问题的代码
* int[] arr = {1,2,3} ;
* Sop(arr[3]);
* int a = 10 ;
* int b =0 ;
* Sop(a/b) ;
*
*
* }catch(异常类名1 对象名1){
* //异常处理
* }catch(异常类名2 对象名2(){
*
* //异常处理
* }
*
*/
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//method1();
//method2();
//两个异常的处理:直接进行处理,不用分别try...catch
method3();
}
方法代码:
private static void method3() {
int a = 10 ;
int b = 0 ;
int[] arr = {1,2,3} ;
try {
//产生一个异常对象
System.out.println(arr[3]);
System.out.println(a/b);
System.out.println("代码可能到这一步出现了问题,怎么办?");
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("访问了数组中不存在的角标");
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}catch(Exception e) { //爷爷 (最大的类一定在最后几个异常 extends RuntimeException extends exception
System.out.println("程序出问题了....");
}
}

//两个异常的处理
//分别try...catch
private static void method2() {

int a = 10 ;
int b = 0 ;

try {
System.out.println(a/b);
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}

int[] arr = {1,2,3} ;
try {
System.out.println(arr[3]);
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("访问数组中不存在的角标...");
}
}

//一个异常的处理
private static void method1() {
int a = 10;
int b = 0 ;

try {
System.out.println(a/b);
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}

}
-----------------------------------------------------------------------------
Jdk7以后出现另一种方式处理多个异常
*
* try{
* 可能出现问题的代码;
* }catch(异常类名1 | 异常类名2 |... 对象名){
*
* 处理异常
* }
例:
try {
//可能有问题
System.out.println(a/b);
System.out.println(arr[3]);
}catch(ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println("程序出问题了...");
}
-----------------------------------------------------------------------------
编译时期异常和运行时期异常的区别?
* 编译时期:开发者必须进行显示处理,不处理,编译不能通过,
* 运行时期异常:无需进行显示处理,可以像编译时期一样进行处理
*
* 处理异常的第二种方式:使用throws 抛出异常 (跟在方法的后面)
* xxx 返回值方法名() throws 异常类名{
* }
-----------------------------------------------------------------------------
/**
* 标准格式 try{ ... }catch(异常类对象){ // 异常处理 } 执行try里面的代码
* ,如果出现了问题,它会通过代码的问题创建一个异常对象,然后通过异常对象和catch里面的异常类是否一致
* 如果一致的情况,就会出现catch里面的代码,执行Throwable里面的方法
*
* public String getMessage() :消息字符串
* public String toString(): 异常的简短描述 ":
* ":由冒号和空格组成
*
* public void printStackTrace():返回值void 直接调用, 包含了消息字符串,还有": "
* 信息描述,具体出现异常的代码定位以及定位的源码上
*
*/
导包:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//定义日期文本格式
try {
String strDate = "2018-6-20" ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
//解析
Date d = sdf.parse(strDate) ; //
System.out.println(d);

}catch(ParseException e) { //创建一个异常对象:PareException e = new ParseException() ;
//使用throwable里面的一些方法
//String str = e.getMessage() ;
//System.out.println(str);//Unparseable date: "2018-6-20"

/*String str = e.toString() ;//简单描述
System.out.println(str);//包名.类名: getMessage() ;
*/
//public void printStackTrace():返回值void 直接调用(输出在控制台的), 包含了消息字符串,还有": "
//*信息描述,具体出现异常的代码定位以及定位的源码上
e.printStackTrace();
}

System.out.println("日期解析完毕...");

System.out.println("---------------------------");

//final,finally,finalize的区别?
//final 可以修饰类,该类不能被继承;可以修饰变量,该变量是常量;可以修饰成员方法,该方法重写
//finalize:gc():运行垃圾回收器,实际是调用finalize()方法,和垃圾回收器有关系
//finally:在io,数据库中以及后面对数据库操作(DBUtuls/c3p0/Hibernate/MyBatis)里面中释放资源的

try {
String str = "2018-6-20" ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
Date dd = sdf.parse(str) ;
System.out.println(dd);
System.exit(0); //finally中代码:只有在一种情况下,它不会执行,在指向finally语句之前,jvm退出了
} catch (ParseException e) {
e.printStackTrace();//处理异常的:直接有问题直接打印在控制台上,告诉开发者哪一块有问题!
}finally {
//释放资源
System.out.println("这里释放资源....");
}
}
-----------------------------------------------------------------------------
throw:表示也是抛出异常,抛出的一个异常对象 (throw new 异常类名() :匿名对象的方式)

面试题:
throws和throw的区别?
throws:也是表示抛出异常,它后面跟的异常类名,并且可以多个异常类名中间逗号开
举例:
public void show() throws IoException,ClassNotFoundException{...}
在方法上抛出,由调用者处理
它表示抛出异常的可能性
throw:抛出的一个异常对象
在语句体中抛出的,由语句体进行处理
它表示抛出异常的肯定性
-----------------------------------------------------------------------------
try...catch...finally
finally语句体是一定会执行的,除非是Jvm退出了

面试题:
如果catch里面有return 语句,finally中的代码还会执行,是在return语句之前执行还是return后执行?
finally中代码是一定会执行的,是在return前
-----------------------------------------------------------------------------
如何自定义一个异常类呢?
自定义异常类,两种方式
1)自定义一个类,这个继承自Exception
2)继承RuntimeException

导包:
import java.util.Scanner;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public class Demo {

public static void main(String[] args) throws MyException {

//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;

//接收数据
System.out.println("请输入学生成绩:");
int score = sc.nextInt() ;

Teacher t = new Teacher() ;
t.check(score);
}
}
//自定义的异常类
public class MyException extends Exception {

public MyException() {
super();
}

public MyException(String message) {
super(message) ;
}

}
Teacher类:
public class Teacher {

//校验学生成绩的功能
public void check(int score) throws MyException {
if(score <0 || score>100) {
throw new MyException("该学生成绩不符合...") ;
//有时候需要处理的逻辑代码
}else {
System.out.println("该学生成绩没有问题");
}

}
}
-----------------------------------------------------------------------------
异常中的注意事项:
子类继承父类的时候的注意事项
1)子类重写父类的方法的时候,子类的方法的抛出的异常必须要么是父类的方法异常一样,要么是父类方法异常的子类
2)子类重写父类方法的时候,如果父类中的这个方法没有抛出异常,那么子类重写的这个方法也不能抛出异常,只能try...catch
*****************************************************************************
/**
*File类:表示文件或者目录的路径的抽象表现形式. IO流就是对文件进行操作的
*public File(String pathname):表示pathname的抽象路径表现的形式 (开发中使用这种方式)
*public File(String parent,String child)
* 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例
*public File(File parent, String child):根据一个file对象和一个文件路径来构造File实例
*
*
*/
导包:
import java.io.File;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//表示:e盘下的demo文件夹中的a.txt文件
//E:\\dmeo\\a.txt
//public File(String pathname):表示pathname的抽象路径表现的形式
File file = new File("E:\\demo\\a.txt") ;
System.out.println(file);

//public File(String parent,String child)
File file2 = new File("E:\\demo","a.txt");
System.out.println(file2);

//3.public File(File parent, String child)
File file3 = new File("E:\\demo") ;
File file4 = new File(file3, "a.txt") ;
System.out.println(file4);

//三种方式都可以使用(表示文件/目录的路径的抽象形式),根据具体的要求(第一种方式最常用的)

}
-----------------------------------------------------------------------------
/**
*跟创建相关的功能:
* public boolean createNewFile():创建文件,当文件不存在的时候,创建此抽象路径下的文件
* public boolean mkdir():创建一个文件夹,如果文件夹存在,不创建
* public boolean mkdirs():创建文件夹,如果父目录不存在,会创建此目录
*/
导包:
import java.io.File;
import java.io.IOException;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//E盘下创建demo文件夹
File file = new File("e:\\demo") ;
System.out.println("mkdir:"+file.mkdir());

System.out.println("------------------------");

//public boolean createNewFile():创建文件,当文件不存在的时候,创建此抽象路径下的文件
//本身方法异常:IOException
File file2 = new File("e:\\demo\\a.txt") ;
System.out.println("createNewfile:"+file2.createNewFile());

///java.io.IOException: 系统找不到指定的路径。
File file3 = new File("e:\\test\\b.txt") ;
System.out.println("createNewFile:"+file3.createNewFile());
//创建文件的前提:文件夹一定要存在,如果不存在,IOException

//public boolean mkdirs():创建文件夹,如果父目录不存在,会创建此目录
//在E盘下创建E:\\aaa\\bbb\\ccc
File file4 = new File("e:\\aaa") ;
System.out.println("mkdir:"+file.mkdir());

File file5 = new File("E:\\aaa\\bbb\\ccc") ;
System.out.println("mkdirs:"+file5.mkdirs());
}
-----------------------------------------------------------------------------
删除功能
* public boolean delete() :删除文件或者文件夹(目录不能是空的) :逐一删除文件或者目录的
* 如果此路径名表示一个目录，则该目录必须为空才能删除。
* 如果创建一个文件/目录,没有写盘符的时候,会创建在哪里呢?
* 会创建在当前项目路径下
-----------------------------------------------------------------------------

导包:

import java.io.File;

主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
//表示当前项目下的高圆圆.jpg这个文件
File file = new File("高圆圆.jpg") ;
File newFile =new File("杨桃.jpg") ;
System.out.println("renameTo():"+file.renameTo(newFile));//路径相同时改名字
System.out.println("-------------------------");

File file2 = new File("杨桃.jpg") ;
File file3 = new File("e:\\高圆圆.jpg") ;
System.out.println("renameTo():"+file2.renameTo(file3));//路径不同时,相当于剪切加改名...
}
-----------------------------------------------------------------------------
/**
* 绝对路径:c:\\xxx\\xxx.txt
* 相对路径:a.txt
*
*回想:html页面(以后jsp页面)
* 后台地址 :URI 统一资源定位符
* <form action="http://localhost:8080/Web工程名称/后台(XXX.servlet)" metod="提交方式">
* 用户名:<input type="text" name="username"/>
* 密码:<input type ="password" name="pwd"/>
* <input type ="hidden" name="hid"/>
*
* <img src="图片的路径"/>
* </form>
*
* 页面的重定向/转发
* response.sendRedirect("/工程名称/xxx.jsp") ;
*
*File 的重命名功能:
* public boolean renameTo(File dest)重新命名此抽象路径名表示的文件。
* 如果路径名一致的情况,那么只是重命名
* 如果两次路径名称不一致,那么不只是重命名,并且剪切
*
*File类的判断功能
* public boolean isDirectory():判断是否是文件夹
* public boolean isFile() :判断是否是文件
* public boolean canRead(): 是否可读
* public boolean canWriter():是否可写
* public boolean exists() :是否存在
* public boolean isHidden():是否是隐藏文件
*
*/
导包:
import java.io.File;
import org.junit.Test;
这是一个测试方法,不需要main方法来涵盖进去
@Test
public void demo() { //测试环境
//表示一个当前项目下的a.txt
File file = new File("a.txt") ;
System.out.println("isDirectory:"+file.isDirectory());
System.out.println("isFile:"+file.isFile());
System.out.println("canRead:"+file.canRead());
System.out.println("canWriter:"+file.canWrite());
//public boolean exists() :是否存在
System.out.println("exites:"+file.exists());
//public boolean isHidden():是否是隐藏文件
System.out.println("isHidden:"+file.isHidden());
}
-----------------------------------------------------------------------------
/**
*File类的获取功能:
* public String getAbsolutePath():获取抽象文件的绝对路径
* public String getPath():获取相对路径的字符串
* public String getName()返回由此抽象路径名表示的文件或目录的名称
* public long length()返回由此抽象路径名表示的文件的长度。
* public long lastModified():文件最后一次被修改的时间(时间毫秒值)
*/
导包:
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.junit.Test;
同样是测试方法
@Test
public void demo() {
//表示一个当前项目下的a.txt
File file = new File("a.txt") ;
System.out.println(file.getAbsolutePath());//F:\eclipse-workspace\day16\a.txt
System.out.println(file.getPath());//a.txt
//public String getName()返回由此抽象路径名表示的文件或目录的名称
System.out.println(file.getName());
//public long length()返回由此抽象路径名表示的文件的长度。
System.out.println(file.length());
//public long lastModified():文件最后一次被修改的时间(时间毫秒值)
System.out.println(file.lastModified());//1526183014044

//知道了时间毫秒值
Date d = new Date(1526183014044L) ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(d) ;
System.out.println(str);

}
-----------------------------------------------------------------------------
/**
* File的高级功能
* public String[] list() :获取当前某个路径下的所有的文件夹以及文件名称的字符串数组
* public File[] listFiles() :获取当前某个路径下所有的文件夹以及文件的File数组
*
* 需求:获取e盘下所有的文件夹以及文件的名称
*
*/
导包:
import java.io.File;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//表示e盘
File file = new File("e:\\") ;
String[] list = file.list() ;
for(String s:list) {
System.out.println(s);
}
System.out.println("--------------------------");

File[] fileArray = file.listFiles() ;
//防止他出现空指针异常
if(fileArray !=null) {
//遍历
for(File f:fileArray) {
System.out.println(f.getName());
}
}
}
-----------------------------------------------------------------------------
/**
*1 )判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
*
* e盘下:图片文件
* 思路:
* 1)使用File对象表示e盘的根目录
* 2)File[] listFiles() ;String[] list() 获取当前盘符下所有的文件以及文件夹的File数组
* 3)对File数组对象进行非空判断,判断他是否为null,不是null,遍历
* 4)如果他是文件,并还有满足是否以.jpg结尾
* 满足就可以进行输出文件名称
*/
导包:
import java.io.File;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {
//封装e盘根目录
File file = new File("e:\\") ;

//获取当前盘下所有的文件夹以及文件的File数组
File[] fileArray = file.listFiles() ;
//非空判断
if(fileArray!=null) {
//遍历
for(File f :fileArray) {
//将每一个表示的文件/文件夹对象遍历出来
//判断是否是文件
if(f.isFile()) {
//满足文件
//并且以.jpg结尾的
if(f.getName().endsWith(".jpg")) {
//满足就输出
System.out.println(f.getName());
}
}
}
}
}
-----------------------------------------------------------------------------
/**
*
1 )判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称

使用方式:A:封装e盘,获取所有的文件以及文件夹的File数组(文件以及文件及的名称数组)
遍历的时候进行一系列判断进行条件过滤,麻烦
B:当前获取到的时候就已经拿到.jpg文件等等....


File的高级功能
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)

FilenameFilter:一个接口: 文件名称过滤器
boolean accept(File dir, String name)测试指定文件是否应该包含在某一文件列表中。

文件是否包含在文件列表中,取决于返回值,true;false表示不包含
*/
导包:
import java.io.File;
import java.io.FilenameFilter;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//封装e盘
File src = new File("e:\\");//表现形式

//采用文件名称过滤器:匿名内部类的方式
String[] strArray = src.list(new FilenameFilter() {

@Override
public boolean accept(File dir, String name) {//自定义内部功能
//首先封装File对象
/*File file = new File(dir, name) ;
//判断是否文件
boolean flag = file.isFile() ;
boolean flag2 = name.endsWith(".jpg") ;

return flag && flag2 ;*/

//一步走
return new File(dir, name).isFile() && name.endsWith(".jpg") ;
}
}) ;

//遍历字符串数组
for(String s: strArray) {
System.out.println(s);
}
}
*****************************************************************************
  /**
     *
     * IO:在设备和设备之间的一种数据传输!
     * IO流的分类:
     * 按流的方向分:
     * 输入流: 读取文件 (e:\\a.txt):从硬盘上文件读取出来后输出这个文件的内容
     * 输出流: 写文件:将e:\\a.txt 内容读出来--->写到f盘下
     * 按数据的类型划分:
     * 字节流
     * 字节输入流:InputStream :读取字节
     * 字节输出流:OutputStream :写字节
     * 字符流
* 字符输入流:Reader :读字符
     * 字符输出流:Writer :写字符
     * 需求:在当项目下输出一个文件,fos.txt文件(文本文件)
     * 只要文本文件,优先采用字符流,字符流在字节流之后出现的
     * 使用字节流进行操作
     * 无法创建字节输出流对象:OutputSteam :抽象类,不能实例化
     * 又学习过File类,并且当前是对文件进行操作,子类:FileOutputSteam进行实例化
     *
     * File+InputStream
     * File+OutputStream
     * FileXXX (FileReader)
     * FileXXX (FileWriter)
     *
     * 开发步骤:
     * 1)创建字节输出流对象
     * 2)写数据
     * 3)关闭资源
     *
     *

导包:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {
//1)创建一个字节输出流对象
// OutputStream out = new OutputStream() ;
// FileOutputStream(String name)
// OutputStream out = new FileOutputStream("fos.txt") ; //抽象类多态
//创建对象做了几件事情
/**
* 1)构造了输出流对象 (系统创建对象)
* 2)指向了当前项目下输出fos.txt
*/
FileOutputStream fos = new FileOutputStream("fos.txt") ; //FileNotFoundException

//写数据
// 使用流对象给文件中写入数据
fos.write("hello".getBytes());

//关闭资源
/**
* 1)将文件和流对象不建立关系了 (fos对象不指向fos.txt)
* 2)及时释放掉流对象所占用的内存空间
*/
fos.close();
/**
* 如果关闭流对象了,那么就不能对流对象进行操作了
*/
//fos.write("java".getBytes());//java.io.IOException: Stream Closed :流已经关闭了

}
-----------------------------------------------------------------------------
/**
* 关于字节输出流写数据的方法
* public void write(int b):一次写一个字节
* public void write(byte[] b) :一次写一个字节数组
* public void write(byte[] b, int off,int len):一次写一部分字节数组

导包:
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//构造一个字节数出流对象
FileOutputStream fos = new FileOutputStream("fos2.txt") ;

//写数据
//一次一个字节
// fos.write(97);
// fos.write(127);
// public void write(int b):

// public void write(byte[] b) :一次写一个字节数组
byte[] bys = {97,98,99,100,101} ;
// fos.write(bys);

// public void write(byte[] b, int off,int len):一次写一部分字节数组
fos.write(bys, 0, 2);

//关闭资源
fos.close();
}
-----------------------------------------------------------------------------
/**
*
* 需求:输出文本文件,给文本文件中添加一些数据
*
* 问题:
* 写一些数据,这些数据并没有换行,如何实现换行的效果...
* 针对不同的操作系统,里面的换行符合不一样的
*
* windows: \r\n
* Linx:\n
* mac:\r
*
*
* 一些高级记事本针对任意的换行会有换行的效果
*
* 问题:如何末尾追加数据呢
* public FileOutputStream(File file, boolean append):指定为true,末尾追加数据
*
*
*/
导包:
import java.io.FileOutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//1)创建字节文件输出流对象:FileOutputStream
// FileOutputStream fos = new FileOutputStream("fos3.txt") ;
FileOutputStream fos = new FileOutputStream("fos3.txt",true) ;

//2)写数据
for(int x = 0 ; x < 10 ; x ++) {
fos.write(("hello"+x).getBytes());
//写入换行符号
fos.write(("\r\n").getBytes()); // editplus工具
}

//3)释放资源
fos.close();
}
-----------------------------------------------------------------------------
/**
*
* IO流中加入异常处理(try...catch...)
*/
导包:
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

// 方式1) 分别进行异常处理
// 创建字节文件输出流对象
/*
* FileOutputStream fos = null ; try { fos = new FileOutputStream("fos.txt") ; }
* catch (FileNotFoundException e) { e.printStackTrace(); }
*
* //写数据 try { fos.write("hello".getBytes()); } catch (IOException e) {
* e.printStackTrace(); }
*
* //释放资源 try { fos.close(); } catch (IOException e) { e.printStackTrace(); }
*/

// 方式2: 一起处理 (针对整个资源没有释放,不好)
// try {
// FileOutputStream fos = new FileOutputStream("fos2.txt") ;
// fos.write("java".getBytes());
// fos.close();
// } catch (IOException e) {
// e.printStackTrace();
// }

// 方式3:经常这样使用:try...catch...finally...
// finally中访问这个对象,需要将对象放到try语句外面
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos3.txt");
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
// 释放资源
// 对象对象进行非空判断 :数据连接池 (由于很多资源:Statment,PreparedStatement)
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}

}

}
-----------------------------------------------------------------------------
/**
*
*需求:去读取当前项目下的fis.txt这个文件内容,将文件的内容输出在控制台上
* InputStream抽象类:字节输入流
* FileInputStream
* 构造方法:
* public FileInputStream(String name)
* 开发步骤:
* 1)创建字节文件输入流对象
* 2)读数据
* 3)释放资源
*
* 读数据方式:
* public abstract int read():一次读取一个字节
* public int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)

*
*
*/
导包:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import org.junit.Test;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public class FileInputStreamDemo {

@Test
public void demo() throws Exception{

//创建一个字节文件输入流对象
//方式1:一次读取一个字节
FileInputStream fis = new FileInputStream("fis.txt") ;
// FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java") ;
//开始读取:第一次读取
/*int by = fis.read() ;
System.out.println(by);
System.out.println((char)by);

//第二次读取
by = fis.read() ;
System.out.println(by);
System.out.println((char)by);

//第三次读取
by = fis.read() ;
System.out.println(by);
System.out.println((char)by);

//第四次读取
by = fis.read() ;
System.out.println(by);
System.out.println((char)by);

//第五次读取
by = fis.read() ;
System.out.println(by);
System.out.println((char)by);

//上述代码重读高,使用循环改进,循环的结束条件是什么呀?
//第六次读取
by = fis.read() ;
System.out.println(by);*/
//结束条件就是:如果文件读到末尾了,没有字节数了,所以是一个-1
/*int by = fis.read() ;
while(by!=-1) {
System.out.print((char)by);
//继续获取字节
by = fis.read() ;
}*/

//最终版代码:可不可以将赋值,判断写在一块呢?
int by = 0 ;
while((by=fis.read())!=-1) {
System.out.print((char)by);
}

//释放资源
fis.close();

}
-----------------------------------------------------------------------------
//blic int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)
导包:
import java.io.FileInputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//创建一个字节文件输入流对象
FileInputStream fis = new FileInputStream("fis2.txt") ;

//读取文件:一次读取一个字节数组
//public int read(byte[] b):一次读取一个字节数组 (读取实际的字节数)
//第一次读取
/* byte[] bys = new byte[5] ;
int len = fis.read(bys) ;
System.out.println(len);//5 :每次读5个字节数
System.out.println(new String(bys));

//第二次读取
len = fis.read(bys) ;
System.out.println(len);
System.out.println(new String(bys));

//第三次读取
len = fis.read(bys) ;
System.out.println(len);
System.out.println(new String(bys));

//第四次
len = fis.read(bys) ;
System.out.println(len);
System.out.println(new String(bys));

//代码重复读高,改进:循环
//结束条件?
len = fis.read(bys) ;
System.out.println(len);
System.out.println(new String(bys));*/
//结束条件也是-1: 实际的字节数

/*byte[] bys = new byte [115] ;
int len = 0 ; //实际字节数
while((len=fis.read(bys))!=-1) {
System.out.println(new String(bys)); //显示数据,会有问题(读取的从指定长度读取的实际字节数)
}

System.out.println("-------------------------");*/

//最终版代码
////指定字节数组的长度是:1024或者1024的倍数
byte[] bys2 = new byte[1024] ;
int len2 = 0 ;
while((len2=fis.read(bys2))!=-1) { //判断,赋值,循环
System.out.println(new String(bys2, 0, len2)); //带上len的用法
}

}
-----------------------------------------------------------------------------;
/**
* 复制文本文件。
将当前项目下的a.txt文件的内容读取出来,复制到b.txt文件中
* @author Administrator
*
*源文件: a.txt ---> 读取文件的内容---->FileInputStream
*目的地文件: b.txt----> 输出文件 --->FileOutputStream
*
*本身读写操作:
* 读取一个字节,写一个字节,针对不会出现中文乱码的问题..
*/
导包:
import java.io.FileInputStream;
import java.io.FileOutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//封装目的地文件和源文件
FileInputStream fis = new FileInputStream("a.txt") ;
FileOutputStream fos = new FileOutputStream("b.txt") ;

//进行读写操作
//一次读取一个字节
int by = 0 ;
while((by=fis.read())!=-1) {
//第一个字节,写个一个字节
fos.write(by);
}
System.out.println("------");

//一次读取一个字节数组

//释放资源
fis.close();
fos.close();
}
-----------------------------------------------------------------------------
/**
*复制文件:
* 源文件:c:\\a.txt
* 目的地文件:d:\\b.txt
*
* 源文件---->FileInputStream 读取操作
* 目的地文件--->FileOuputStram 写入操作
*/
导包:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//封装目的地文件和源文件
FileInputStream fis = new FileInputStream("c:\\a.txt") ;
FileOutputStream fos = new FileOutputStream("d:\\b.txt") ;

//读写操作
int by = 0 ;
while((by=fis.read())!=-1) {
//不断写数据
fos.write(by);
}

//释放资源
fos.close();
fis.close();
}
-----------------------------------------------------------------------------
/**
* 源文件: 高圆圆.jpg
* 目的地文件: mm.jpg
*
* 源文件: FileInputStream --->读取
* 目的地文件: FileOutputStream--->写入
*/
导包:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//封装源文件和目的地文件
FileInputStream fis = new FileInputStream("高圆圆.jpg") ;
FileOutputStream fos = new FileOutputStream("mm.jpg") ;

//读写操作
//一次读取字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=fis.read(bys))!=-1) {
//写数据
fos.write(bys, 0, len);
}

//释放资源
fis.close();
fos.close();

}
*******************************************************************************
/**
*递归:只的是方法调用方法本身的一种现象
*
*Math类:max() 方法 Math.max(10,Math.max(15,20)); 方法嵌套
*
*举例
* 方法递归:
* public void show(int n){
* if(n<0){
* System.exit(0) ;//jvm退出了
* }
*
* System.out.println(n) ;
* show(n--) ;
* }
*
*方法递归的三个必要条件:
* 1)方法递归必须有出条件
* 2)必须满足一些规律
* 3)一定要写方法
*
*注意:构造方法不存在方法递归的
* 举例
* 从前有座山,山里有个庙,庙里有个老和尚和小和尚,老和尚给老和尚讲了一个故事是:
* 从前有座山,山里有个庙,庙里有个老和尚和小和尚,老和尚给老和尚讲了一个故事是:
* 从前有座山,山里有个庙,庙里有个老和尚和小和尚,老和尚给老和尚讲了一个故事是:
* 从前有座山,山里有个庙,庙里有个老和尚和小和尚,老和尚给老和尚讲了一个故事是:
* 条件结束:山塌了,或者和尚挂了
*
*/

-----------------------------------------------------------------------------
/**
*需求:求5的阶乘
* 5! = 5 * 4 * 3 * 2　*1
* 5! = 5 * 4!
*
* 方式:
* 1)普通for循环
* 2)用递归的方式去写
* 1)方法递归必须有出条件
* 2)必须满足一些规律
* 3)一定要写方法
*
*/
全部代码如下:
public class DiGuiDemo2 {

public static void main(String[] args) {

//求5的阶乘
//定义结果变量
int jc = 1 ;
for(int x =2 ;x <=5 ; x ++) {
jc*=x ;
}
System.out.println("5的阶乘是:"+jc);
System.out.println("-------------------------");
System.out.println("5的阶乘是:"+jieCheng(5));
}
/**
* 1)先出口,在找规律
* 出口条件是什么
* if(n==1){
* return 1 ;
* }else{
* return n*jicheng(n-1) ;
* }
*/
递归方法如下:
private static int jieCheng(int n) {
if(n==1) {
return 1 ;
}else {
return n*jieCheng(n-1) ;
}
}
-----------------------------------------------------------------------------

Java进阶之路05-(集合3.异常.文本IO流1)

猜你喜欢