笔记3
文章目录
- 第五部分
- 1.多态性
- 2.instanceof操作符
- 3.Object类
- 4.对象类型转换
- 5.==与equals
- 6.包装类和toString
- 7.关键字static
- 8.单例设计模式
- 第六部分
- 1.代码块
- 2.关键字final
- 3.抽象类
- 4.接口interface特殊的抽象类
- 5.工厂方法举例
- 6.内部类
- 第七部分
- 1.异常
- 2.捕获异常
- 3.抛出异常 （不全）
- 4.....集合....
- 第八部分
- 1.泛型类
- 2.泛型接口
- 3.泛型方法
- 4.泛型通配符
- 5.enum 枚举类
- 第九部分
- 1.File类及其操作
- 2.IO以及IO流
- 3.文件字节输入流FileInputStream
- 4.文件字节输出流FileOutputStream
第五部分涉及
多态面向对象的知识，Instanceof操作符，Object类，对象类型转换，==与equal，包装类和toString，关键字static，单例模式
第六部分
代码块，关键字final，抽象类，接口，工厂方法，内部类
第七部分
异常和集合的问题
第八部分
泛型类 泛型接口 泛型方法 泛型通配符 枚举类
第九部分
流的问题（PS：还没写完）
第五部分
1.多态性
①
体现在两个方面
第一是 方法的重载和重写
第二是对象的多态性–直接应用到抽象类和接口上。
注意：若编译时类型和运行时类型不一致就会出现多态
②
一个引用类型变量可能指向（引用）多种不同类型的对象。
Person e=new Student();指向了Student对象
子类可看作是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型。
③
动态绑定必须存在于方法的重写之上。
2.instanceof操作符
x instanceof A 检验x是否为类A的对象，返回值为boolean型
如果x属于A的子类B，返回的还是true
3.Object类
它是所有java类的根父类
它有许多的方法后续会涉及到
4.对象类型转换
父类到子类的强制转换
例如：
Object obj="hello" ; String s=(String) obj;
应用 判断对象。
public class test
{
public void method(Person e)Person中没有getschool的方法
{
if(e instanceof Student)
{
Student s=(Student) e;
s.getschool();
}
}
public static void main(String[] args)
{
test a=new test();
a.method(new Student());
}
}
5.==与equals
①只有指向同一个对象的时候 = = 才返回true
Person a=new Person();
Person b=new Person();
a==b 但会的是false
②所有的类都继承了Object 也获得了equals()
s1.equals(s2);
总结：
对于特殊的类来说 如String,File,Date.==比较的是地址,equals比较的是内容。
除此之外 = = 和equals对于其他的类比较的都是内存地址。
6.包装类和toString
父类的Object的toString方法就是输出当前对象的内存地址
同样你也可以重写方法
7.关键字static
在类内属性被其修饰 称为类变量
方法称为类方法 需要注意的是static方法内部不能有this之类的
8.单例设计模式
解决的问题是new 对象太费劲或者是频频的new新对象没有必要。
①饿汉式
public class Single
{
private Single(){}
private static Single single=new Single();
public static Single getInstance()
{
return single;
}
}
public class test
{public static void main(String[] args)
Single s=Single.getInstance();
}
②懒汉式（存在问题）
public class Single
{
private Single(){}
private static Single single=null;
public static Single getInstance()
{ if(single==null)
single=new Single();
return single;
}
}
public class test
{public static void main(String[] args)
Single s=Single.getInstance();
}
第六部分
1.代码块
就是用大括号括起来的
{
这叫做非静态代码块
}
static
{
这叫做静态代码块
这里只能使用static修饰的属性和方法
}
静态代码块只执行一次（级别大于非静态），而非静态的每次创建对象的时候都会执行一次。
程序的执行顺序
声明成员变量的默认值→显示初始化，多个初始化块（代码块）被依次执行（同一级别俺顺序）→构造器再对成员进行赋值操作。
2.关键字final
可以修饰类属性方法、
①final修饰的类不能被继承
②final修饰的方法不能被子类重写。
③final修饰的变量即成为常量，名称大写，且只被赋值一次。
3.抽象类
含有抽象方法的类必须被声明为抽象类。
它可以有构造方法，
抽象类是不能直接创建抽象类的实例化对象
public abstract class Animal
{
public abstract void test();
public abstract void move();
}
class Dog extends Animal
{
@Override
public void test()
{}
@Override
public void move()
{}
}
当你继承抽象类的时候必需要重写里面的所有的abstract方法
4.接口interface特殊的抽象类
①
一个类可以实现多个接口，接口也可以继承其他接口。
特点：变量默认 是public static final
方法默认是public abstract
类实现多个接口又继承父类 的写法！！！！！！！
public class A extends B implements C,D;
②应用描述会唱歌的厨子是个老师
为什么不能直接写多个类呢？因为这样每个类中会多出许多奇奇怪怪与本类无关的东西！！！！所以需要接口
public abstract class Person
{
int age;Strign name;
public abstract coid shouInfo();
}
//歌手接口
public interface Sing
{
void singing();
}
//厨师
public interface Cook
{
void cooking();
}
public class Teacher extends Person implements Cook,Sing
{
String course;
@Override
public void showInfo()
{
}
@Override
public void singing()
{
}
@Override
public void cooking()
{
}
}
5.工厂方法举例
如果要该类名而不影响后续开发人员
public interface BWM
{
void showInfo();
}
class BWM3 implements BWM
{
@Override
public showInfo()
{
System.out.println("宝马3系车");
}
}
class BWM5 implements BWM
{
@Override
public showInfo()
{
System.out.println("宝马5系车");
}
}
class BWM7 implements BWM
{
@Override
public showInfo()
{
System.out.println("宝马7系车");
}
}
工厂区
public interface BWMfactory
{
BWM productBWM();
}
class BWM3factory implements BWMfactory
{
@Override
public BWM productBWM()
{
System.out.println("生产宝马3系");
return new BWM3();
}
}
class BWM5factory implements BWMfactory
{
@Override
public BWM productBWM()
{
System.out.println("生产宝马5系");
return new BWM5();
}
}
class BWM7factory implements BWMfactory
{
@Override
public BWM productBWM()
{
System.out.println("生产宝马7系");
return new BWM7();
}
}
////////////////////////////////////////////////////////////////
这是开发人员B的工作
public class test
{
public static void main(String[] args)
{
BWM b3=new BWM3factory().productBWM();
b3.showInfo();
}
}
6.内部类
最大的作用是实现了多重继承。
面向对象的大纲总结
第七部分
1.异常
例如：
超出数组：
空指针访问（比方说 一个对象是个null，你还输出它的属性）
常见异常
①RuntimeException
{
错误的类型转换
数组下标越界
空指针访问
}
②IOException
{
从一个不存在的文件中读取数据
越过文件结尾继续读取EOFFException
链接一个不存在的URL
}
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
2.捕获异常
用
try{} 包住你认为异常的代码
catch{}
所有异常的父类是 Exception
public class test
{
public static void main(String[] args)
{
String [] s=new String[] {"1","2"};
Person a=null;
try
{
System.out.println(a.u);
}catch(Exception e)
{
// e.printStackTrace();
// System.out.println(e.getMessage());
}
System.out.println("000000");
}
}
在try代码块内部，异常 之后的信息不再输出。
如果catch内不写内容，那么程序会跳过try代码块内的代码，
e.printStackTrace(); 输出的是异常类型。
System.out.println(e.getMessage()); 输出异常的信息
在catch后面还可以加finally{} 这个是可写可不写，
它是捕捉异常体系中最终一定会执行的部分
注意：在捕获异常的try代码块中，如果前面代码有异常，就不会执行后面的
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
3.抛出异常 （不全）
①人工抛出异常：
public class Person
{
int age;
public void test(int age) throws Exception
{
if(age>=0&&age<=120)
{
this.age=age;
System.out.println("年龄是"+age+"岁");
}
else
{
throw new Exception("年龄超出0~120的范围");
}
}
}
当我写下b.test(-1)的时候系统会让你补全，
然后直接点击Surround with try/catch 他就会自动补全。
public class test
{
public static void main(String[] args)
{
Person b=new Person();
try {
b.test(-1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
②重写方法不能抛出比重写方法范围更大的异常类型。
③用户也可以自定义异常类。
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
4…集合…
①
HashSet
是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现
类。我们大多数时候说的set集合指的都是HashSet
HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet具有以下特点:
不能保证元素的排列顺序
不可重复
HashSet不是线程安全的
集合元素可以使null
当向HashSet集合中存入一个元素时，HashSet 会调用该对象的hashCode()
方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在
HashSet中的存储位置。
如果两个元素的equals()方法返回true,但它们的hashCode()返回值不相等,
hashSet将会把它们存储在不同的位置，但依然可以添加成功。
HashSet基本用法
Set set=new HashSet();
上边的写法等价于
Set<Object> set=new HashSet<Object>();
当你想让Set储存特定类型就在<>里面写上就可以。这就是泛型。
注意：需要导入两个包。import java.util.HashSet;import java.util.Set;方法如下
输入Set然后按alt+/ 选择第一个包，然后再HashSet按alt+/弹出包选中就行。
************************************************
System.out.println(set) 输出set所有元素
set.add() 向set中添加括号类的元素
set.remove() 移除set中 括号内的元素。
set.clear() 清空
set.contains();返回boolean类型，判断set中是否包含括号内的那个数
set.size()返回集合大小
集合遍历的方法*******
第一种方法迭代器：
（要导包 Iterator后面加alt+/）
Iterator it set.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
第二种方法(for each迭代)推荐用法！！！！！！！！！！
for(Object obj:set) 把每一个都取出来赋给obj
{
System.out.println(obj);
}
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
②TreeSet
TreeSet是SortedSet接口的实现类，
TreeSet可以确保集合元素处于排序状态，它支持两种排序方法：自然排序和定制排序。默认情况下，采用自然排序
之前那些方法仍然能够实现
声明 Set<Integar> set=new TreeSet<Integar>();
要导入包import java.util.Set;import java.util.TreeSet;
写了一个A类，按照年龄大小输出他们的姓名+年龄。
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
A p1=new A("小红",15);
A p2=new A("小白",20);
A p3=new A("小虎",30);
A p4=new A("小狗",25);
Set<A>set=new TreeSet<A>(new A());
set.add(p1);set.add(p2);set.add(p3);set.add(p4);
for(A a:set)
{
System.out.println(a.name+" "+a.age);
}
}
}
class A implements Comparator<A>
{
public int compare(A a,A b)
{
if(a.age<b.age)
return -1;
else if(a.age>b.age)
return 1;
else return 0;
}
int age;String name;
public A(){}
public A(String name,int age)
{
this.age=age;this.name=name;
}
}
注意几个问题：
①构造函数要public 两个都要写
②集合这样写 ：Set < A > set=new TreeSet< A >(new A());
③A类这样写 class A implements Comparator< A >
实现接口Comparator
④compare方法的重写
public int compare( A a,A b)
并且要导入包
import java.util.Comparator;
还是Alt+/
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
③.List集合
首先是声明问题
List<String>list=new ArrayList<String>();
泛型自己弄
记得导入包
import java.util.ArrayList;
import java.util.List;
然后是一些用法
以添加元素"a"为例
list.get(index);这是获得下标为index的元素
list.add("a"); 向集合添加元素
list.add(index,"a");在下标为index下插入元素
****************************
插入一小段list集合
假设
List<String>l=new ArrayList<String>();
l.add("1");l.add("2");
list.addAll(index,l);在下标为index下开始插入l集合的所有元素。
****************************
list.indexOf("a");获得指定元素第一次出现的下标
list.lastIndexOf("a")这是获得最后一次出现的下标
list.remove(index) 移除下标为index的元素
list.set(index,"a")把下标为index的元素改为"a"；
System.out.println(list.subList(1, 3));
这个就是输出了下标为1,2的元素 记得不包括最后一个
这一段也可以变成一个新的集合
List<String>s=list.subList(1,3);
长度还是size
应用一个类Student按顺序输出年龄姓名。
这里跟TreeSet的那个有个地方不同就是那个❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤❤
Listlist=new ArrayList();
括号内没写new Student（）；
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
Student s1=new Student(14,"张4");
Student s2=new Student(12,"张2");
Student s3=new Student(16,"张6");
Student s4=new Student(13,"张3");
List<Student>list=new ArrayList<Student>();
list.add(s1);list.add(s2);list.add(s3);list.add(s4);
for(Student s:list)
{
System.out.println(s.age+","+s.name);
}
}
}
class Student implements Comparator<Student>
{
int age;String name;
public Student() {}
public Student(int age,String name)
{
this.age=age;this.name=name;
}
@Override
public int compare(Student o1, Student o2) //升序
{
if(o1.age>o2.age)
return 1;
else if(o1.age<o2.age)
return -1;
else return 0;
}
}
▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
④Map集合
Map接口与HashMap类
导包
import java.util.HashMap;
import java.util.Map;
建立Map: Map<String, Integer> m=new HashMap<String, Integer>();
m.put("a",1)添加Ket为“a”，value为1的元素；
m.get("a")根据key返回的value
m.remove（“a”）根据key移除元素
m.size() 长度
m.containsKey("a") 判断集合是否有这个key
m.containsValue("a") 判断是否含有这个value
m.clear()清空
用到Set别忘了导入包！！！！！！！！
m.keySet()获得Map集合的key集合
m.values()获得集合所有的value集合
*************遍历Map集合***********************
第一种：
Set<String>k=m.keySet();
for(String s:k)
{
System.out.println("key:"+key+", value: "+m.get(s));
}
第二种：entrySet();
导包
import java.util.Map.Entry;
import java.util.Set;
Set<Entry<String, Integer>> set=m.entrySet();
for(Entry<String, Integer>en:set)
{
System.out.println("key:"+en.getKey()+",value:"+en.getValue());
}
*********************************************
⑤TreeMap
自然排序 是按照字典序
例如：
Map<Integer,String>map=new TreeMap<Integer, String>();
map.put(5,"a");
map.put(0,"b");
map.put(2,"x");
map.put(15,"d");
System.out.println(map);
输出结果：
{0=b, 2=x, 5=a, 15=d}
5.操作集合的工具类Collections
包： import java.util.Collections;
正常类的用法：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
List<String>list=new ArrayList<String>();
list.add("a");
list.add("v");
list.add("s");
list.add("t");
System.out.println(list);
输出结果 [a, v, s, t]
Collections.reverse(list);反转
System.out.println(list);
输出结果[t, s, v, a]
Collections.shuffle(list);随机
System.out.println(list);
[a, s, t, v]
Collections.sort(list);升序
System.out.println(list);
[a, s, t, v]
Collections.swap(list, 0, 2);交换
System.out.println(list);
[t, s, a, v]
System.out.println(Collections.max(list));
Collections.max(list)返回最大值
System.out.println(Collections.min(list));
Collections.mix(list)返回最小值
System.out.println(Collections.frequency(list,"a"));
返回某个元素出现的次数Collections.frequency(list,"a")
Collections.replaceAll(list, "t", "w");
System.out.println(list);
[w, s, a, v]
Collections.replaceAll(list, oldVal, newVal) 把所有的old替换成new
}
}
下面这个是需要 Comparator的实例，有一些需要重写的
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
Student s1=new Student(14,"张4");
Student s2=new Student(12,"张2");
Student s3=new Student(16,"张6");
Student s4=new Student(13,"张3");
List<Student>list=new ArrayList<Student>();
list.add(s1);list.add(s2);list.add(s3);list.add(s4);
Collections.sort(list,new Student());
for(Student s:list)
{
System.out.println(s.age+","+s.name);
}
*********************这个输出结果就是按照年龄升序输出的结果
Student s=Collections.max(list,new Student());
*********************接收年龄最大的元素
Student ss=Collections.min(list,new Student());
*********************接收年龄最大的元素
}
}
class Student implements Comparator<Student>
{
int age;String name;
public Student() {}
public Student(int age,String name)
{
this.age=age;this.name=name;
}
@Override
public int compare(Student o1, Student o2)
{
if(o1.age>o2.age)
return 1;
else if(o1.age<o2.age)
return -1;
else return 0;
}
}
第八部分
1.泛型类
public class test
{
public static void main(String[] args)
{
泛型是自己写的String Integer等等
A<String>a1=new A<String>();
如果什么都不写 A a1=new A();泛型就是 Object类型
}
}
此处的泛型T可以取任意的名字
class A<T>
{
private T key;
public void setKey(T key)
{
this.key=key;
}
public T getKey()
{
return this.key;
}
}
2.泛型接口
interface A<T>
{
T test(T t);
}
这就是T泛型接口
未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也要一起加到类中
就是像这样。
class B<T> implements A<T>
{
@Override
public T test(T t) {
return null;
}
}
如果你不这样的话会想上面的那个图显示的一样。
如果实现接口时指定接口的泛型是具体数据类型的，
这个类实现接口的所有的方法的位置都要泛型替换时机的具体数据类型
就像是这样
class B2 implements A<String>
{
@Override
public String test(String t) {
return null;
}
}
创建对象的时候
B<Object>s1=new B<String>();
下面的是那个指定泛型了
B2 s2=new B2();
3.泛型方法
在调用之前没有固定的数据类型，在调用的时候，传入参数是什么类型，就会把泛型改成什么类型。
三种方法
1.无返回值的
2.有返回值的
3.可变参数的
4.static型
class C
{
public<T>void set(T t)
{
}
public<T> T get(T t)
{
return t;
}
public <T>void test(T...s)
{
for(T t:s)
{
System.out.println(t);
}
}
public static<T>void test1(T t)
{
}
}
4.泛型通配符
①不确定集合元素的具体类型，用？表示
当某个方法需要list集合的参数并且类型不确定，可以这样写。
public void set(List<?> list)
②有限制的通配符
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{ gg g=new gg();
List<AA>a1=new ArrayList<AA>();
List<BB>b1=new ArrayList<BB>();
List<CC>c1=new ArrayList<CC>();
List<DD>d1=new ArrayList<DD>();
g.test1(d1);
g.test1(c1);
g.test2(c1);
g.test2(a1);
g.test2(b1);
List<EE> e1=new ArrayList<EE>();
g.test3(e1);
}
}
class gg
{
public void test1(List<? extends CC> list)仅允许CC以及他的子类
{
}
public void test2(List <? super CC> List)仅允许CC以及他的父类
{
}
public void test3(List <? extends IA> List)仅允许实现过接口的
{
}
}
interface IA{}
class EE implements IA{}
class AA{}
class BB extends AA{}
class CC extends BB{}
class DD extends CC{}
5.enum 枚举类
public class test
{
public static void main(String[] args)
{
Season spring1=Season.SPRING;
spring1.showInfo();
Season spring2=Season.SPRING;
spring2.showInfo();
System.out.println(spring1==spring2);
返回true
每次都是获得相同的对象。枚举类中的每个枚举都是单例模式
}
}
enum Season
{
SPRING("春天","春暖花开"),
SUMMER("夏天","炎炎夏日"),
AUTUMN("秋天","秋高气爽"),
WINTER("冬天","寒风凛冽");
调用私有构造方法
private final String name;
private final String desc;
private Season(String name,String desc)
{
this.name =name;
this.desc=desc;
}
public void showInfo()
{
System.out.println(this.name+","+this.desc);
}
}
枚举类也是可以实现接口的和普通类实现接口一样。
第九部分
1.File类及其操作
假设我在d盘test中有个tt.txt文档
File f=new file("D:\\test\\tt.txt")
要用两个斜杠哦
在java中\是转移符，\\ /这俩才是文件的分隔符
File类只能操作文件本身但不能操作内容。
假设我在d盘test中有个tt.txt文档
File f=new file("D:\\test\\tt.txt")
f.getName();获取文件名tt.txt
f.getPath();获取文件或者文件夹路径D:\\test\\tt.txt 就是new对线的时候协商的那个
f.getAbsolutePath();获取当前文件或者文件夹的绝对路径
f.getAbsouluteFile();返回一个用当前的文件或者文件夹的绝对路径创建的File对象
f.getParent();返回当前文件或者文件夹的父级路径
f.renameTo(new File(D:\\test\\tt1.txt ));重命名给文件或者文件夹重新命名为tt1
f.exists();判断这个文件或者文件夹存不存在。返回boolean
f.canWrite();f.canRead();文件是否可写 可读，返回boolean
f.isFile();判断这f是不是文件
f.isDirectory()判断f是不是文件夹
f.lastModified()获得文件最后修改的时间。返回毫秒数
f.length()返回文件大小字节
f.delete() 删除文件
f.createNewFile()创建新的文件 但要捕获异常
File f=new File("D:\\test.txt");
if(!f.exists())
{
try {
f.createNewFile();
} catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
例如
File f=new File("D:\\test\\a\\b\\c");
如果我现在只有到test的文件夹
f.mkdir()；创建目录；那么他就依次创建a b c目录
f.list() 就是返回他文件内的目录或者文件名字
File f=new File("D:\\office");
for(String s:f.list())
{
System.out.println(s);
}
f.listFiles()返回当前文件夹的子集的file对象，详细的地址
File[] fs=f.listFiles();
for(File ff:fs)
{
System.out.println(ff);
}
递归遍历文件夹所有文件
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
File f=new File("D:\\office");
gg(f);
或者是下面不用static 然后直接 new test.gg(f);
}
public static void gg(File f)
{
if(f.isFile())
{
System.out.println(f.getAbsolutePath()+"是文件");
}
else
{
System.out.println(f.getAbsolutePath()+"是文件夹");
File a[]=f.listFiles();
for(File z:a)
{
gg(z);
}
}
}
}
2.IO以及IO流
3.文件字节输入流FileInputStream
指从文件中或者其他地方读取数据输入到内存中
这个是输出了那个文件的内容
注意
in.close();别忘了写
in.read()；是返回依次读取的长度。知道读到最后 返回-1
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
FileInputStream in;
try
{
in = new FileInputStream("D:\\office\\new.txt");
byte b[]=new byte[100];
int len=0;
while((len=in.read(b))!=-1)
{
System.out.println(new String(b,0,len));
new String (缓冲数据的数组，从那个位置开始转化，总共转换多少字节)
}
in.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
4.文件字节输出流FileOutputStream
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class test
{
public static void main(String[] args)
{
/*FileInputStream in;
try
{
in = new FileInputStream("D:\\office\\new.txt");
byte b[]=new byte[100];
int len=0;
while((len=in.read(b))!=-1)
{
System.out.println(new String(b,0,len));
//new String (缓冲数据的数组，从那个位置开始转化，总共转换多少字节)
}
in.close();
}
catch (Exception e)
{
e.printStackTrace();
}
*/
try {
FileOutputStream out=new FileOutputStream("D:\\office\\new.txt");
String s=" are you ?";
out.write(s.getBytes());把数据写到内存
out.flush();把内存中的数据刷写到硬盘
out.close();关闭流
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}