【java】io包和util包常用类和方法

Java.util

• Calendar
• Date
• Random

集合——继承Collection接口

只能放对象，放的是对象的引用，可以放不同的对象

• Set接口
• List接口
• Map接口

Set

• HashSet类：不可重复，不保证排序顺序，不是线程安全的

import java.util.Set;

Object o = new Object();
Set s = new HashSet();
s.add(null);  // 添加任意对象
s.remove(1);  // 删除
s.contains(o);  // 判断是否包含
s.clear();  // 清空
s.size();  // 集合大小
/*遍历*/ 
Iterator it = s.iterator();  // 用迭代器遍历
while(it.hasNext()){
    System.out.print(it.next());
}
for(Object obj : s){  // for each 迭代
    obj
}

Set<String> s2 = new HashSet<String>();  // 泛型，这样子只能存String类型的对象

• TreeSet类： 保证集合处于排序的状态下，它的排序是调用了compareTo方法

import java.util.Set;
import java.util.TreeSet;

Set<Integer> set = new TreeSet<Integer>();  // 泛型
// 添加、删除等与HashSet的接口名相同
for(Integer i : set){
    // 会是有序的，默认是升序
}
// 
class Person implements Comparator<Person>{
    int age;
    String name;
    public Person(int age, String name){
        this.age =age;
        this.name = name;
    }
    @Override
    public int compare(Person o1,Person o2){
        if (o1.age > o2.age){  // 正序
            return 1;
        }else if(o1.age < o2.age){
            return -1;
        }else{
            retunr 0;
        }
    }
}
Set<Person> s2 = new TreeSet<Person>(new Person());  // 按年龄升序

List

• ArrayList类： 有序、可重复、有索引，线程不安全
• Vector类：不推荐用，和ArrayList差不多

import java.util.List;
import java.util.ArrayList;

List<String> l = new ArrayList<String>();
l.add("a");  // 索引下标从0开始
l.add(1, "b");  // 在指定位置插入，其余的后移
l.addAll(1, list);  // 插入集合
String a = l.get(0);  // 按索引取值
l.indexOf("b");  // 获取元素第一次出现下标
l.lastIndexOf("b");  // 获取最后一次出现下标
l.remove(2);  // 移除指定下标的数据
l.set(1, "ff");  //  改指定下标的数据
l.subList(2, 4);  // 截取子列表，左闭右开[2，4)
l.size();

Map

• HashMap类：不可重复，有一一映射关系，线程不安全，不保证顺序
• TreeMap类：会对key排序。

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);  // 添加 key:value 键值对
map.get("a");  // 根据key取值
map.remove("a");  // 根据key删除
map.size();
map.containsKey("a");
map.containsValue(1);
map.clear();
// 遍历map
map.keySet();  // key的集合，返回值是Set集合
map.values();   //  value的集合
Set<String> keys = map.keySet();
for(String key: keys){ // 用keySet()
    int value = map.get(key);
}
Set<Entry<String, Integer>> entrys = map.entrySet();
for (Entry<String, Integer> en :entrys){  // 用entrySet()
    System.out.println("key:"+en.getKey()+" value:"+en.getValue());
}

Collections 类

是对集合进行操作的类

Collections.reverse(list);  // 反转
Collections.shuffle(list);  // 重新随机排列
Collections.sort(list);  // 字典升序排列
Collections.sort(stus, new Student());  // 对stus集合进行排序，其中Student类里面需继承Comparator接口，并重新方法，与之前相同。
Collections.swap(list,i,j);  // 指定替换集合中的元素
Collections.max(list);  
Collections.min(list); 
Collections.max(stus,new Student()); // 同理
Collections.frequence(list, "a");    // 指定元素出现次数
Collections.replaceAll(list,"a", "aa");  //  a全部替换aa
// 提供线程有关的的方法

java.io

File类

//  File.separetor = "\\";  
File f = new FIle("D:"+File.separator+"a\\b.txt");  // 此时f为这个文件
String s=f.getName();  //  获取文件名
f.renameTo(new File("D:\\a\\c.txt"));  // 重命名
f.creatNewFile(); // 创建文件
f.mkdir();  // 创建目录
f.mkdirs();  // 创建多层目录
f.delete();
boolean f.exists();  // 判断文件or文件夹是否存在
boolean f.isFile();
boolean f.isDirectory();
String[] li = f.list();  // 返回当前文件夹下下的所有文件
File[] flist = f.listFiles();  // 返回当前文件夹下的文件对象

f.lastModified(); // 文件最后修改时间，毫秒数
f.length();
f.canRead();  // 判断文件是否可以读
f.canWrite();// 判断文件是否可以写
f.getPath();  // 获取路径
f.getAbsolutePath();
f.getParent(); // 返回父级路径

// 创建新的文件
if(!f.exists()){
    try{
        f.createNewFile();
    }catch(IOException e){
        e.printSrackTrace();
    }
}
// 递归遍历当前目录全部文件
public void test(File file){
    if (file.isFile()){
        // 是文件
    }else{
        // 是文件夹，可能有子文件
        File[] fs = file.listFiles();
        if(fs != null && fs.length>0){
            for (File ff: fs){
                test(ff);
        	}
        }
        
    }
}

流

• 字节流：8bit 以二进制读写，非常通用
• 字符流：16bit 只适合操作内容是字符的文件

抽象基类：	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

• 访问文件：File+基类【FileInputStream、FileOutputStream、FileReader、FileWirter】

// 字节流-读入。字符流类似，但是传递的数组为char类型
FileInputStream in = new FileInputStream("filepath"); // 有异常，try-catch包围
byte[] b = new byte[10]; // 字节流
char[] b = new char[10]; // 字符流
int len=0;
// int len = in.read(b);  // 当返回值为-1 时表示读取完毕
while((len = in.read(b)) != -1){
    System.out.println(new String(b,0,len));
}
in.close();

// 字节流-输出（覆盖）
FileOnputStream out = new FileOnputStream("filepath");
String str = "adfadf";
out.write(str.getBytes());  // 字节流写到内存
out.write(str);  // 字符流写到内存
out.flush();  // 刷到磁盘
out.close();

• 处理流之一 缓冲流：Buffered+基类。需要嵌套在相应节点流之上，提高io效率

// 输入
FileInputStream in = new FileInputStream("filepath");
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[10]; // 字节流
int len=0;
while((len = br.read(b)) != -1){
    System.out.println(new String(b,0,len));
}
br.close();  // 最晚开最早关
in.close();

// 输出类似

• 处理流之二：转换流。在字节流和字符流中转换

// 字节转为字符。输出流同理
FileInputStream fs = new FileInputStream("filepath");
InputStreamReader in = new InputStreamReader(fs,"GBK");   // 第二个参数为文件编码

• 标准输入输出流

// 创建一个键盘接受的输入流
InputStreamReader is = new InputStreamReader(System.in);
// 把输入流放到缓冲区里
BufferedReader br = new BufferedReader(is);
String str = "";
while( (str = br.readLine()) != null){
    // 循环读写
}

• 数据流：专门用来做基本数据类型的读写的。

• 对象流：Object+基类。保存对象到硬盘（对象的持久化）、网络传输。不能序列化static和transient修饰的成员变量。

  • 序列化serialize：用ObjeckOutputStream将java中的对象写入IO流中。
  • 反序列化deserialize：从IO流中恢复java对象。ObjeckInputStream
  • 能序列化的对象需要实现接口Serializable
  • 要求序列化和反序列化使用的类的包名、类名等均一样。

class Person implements Serializable{
    private static final long serialVersonUID = 1L;  // 一个表示序列化版本标识的静态变量，用来表明类的不同版本间的兼容性。
    String name;
    int age;
}
// 定义对象的输出流，把对象序列化的流放到指定的文件中
ObjeckOutputStream out = new ObjeckOutputStream(new FileOutputStream("filepath"));
Person p = new Person();
p.name = "lzq";
p.age = 1;
out.writeObject(p);  // 序列化
out.flush();
out.close();

// 从指定文件中读取对象
ObjeckInputStream in = new ObjeckInputStream(new FileInputStream("filepath"));
Object obj = in.readObject();  // 反序列化
Person p = (Person)obj;  // 强制转换

• 随机存取流：文件随机读写，可追加。RandomAccessFile类

// 参数1是文件路径，参数2是文件读写模式，有以下几种
// r   只读
// rw  可读可写
// rwd  可读可写，文件内容同步更新
// rws  可读可写，文件内容、元数据同步更新
RandomAccessFile  ra = new RandomAccessFile("filepath" , mode);
ra.seek(0);  //  设置读取文件内容的起始点
ra.seek(ra.length());  // 从文件最后开始
// 之后的读写和字符流相似