Java的标准库

集合

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。Java的java.util包主要提供了三种类型的集合：

List：一种有序列表的集合
Set：一种保证没有重复元素的集合
Map：一种键值对（key-value）集合，是一种键和值的映射结构

列表

        // 创建列表，并指定泛型
        List<String> list = new ArrayList<>();
        // 添加元素
        list.add("apple"); 
        list.add("pear"); 
        list.add("apple"); // 允许重复元素
        list.add(null);    // 允许添加null

        // 使用size方法获取列表的长度
        System.out.println(list.size());

        // 遍历列表（还可使用for...in遍历）
        for (int i=0; i<list.size(); i++) {
            // get方法根据索引获取元素
            String s = list.get(i);
            System.out.println(s);
        }

        // Java中列表没有用字面量初始化的语法，但可以使用数组工具类来实现效果
        List<String> lang = Arrays.asList("java","Dart","android","flutter");

boolean add(E e)：在尾部添加元素
boolean add(int index, E e)：在指定索引处添元素
int remove(int index)：删除指定索引处的元素
int remove(Object e)：删除某个元素
E get(int index) ：获取指定索引的元素
int size() ：获取列表长度

除此外，我们还可以使用contains()、indexOf()等方法来判断列表是否包含某个元素，使用isEmpty()判断列表是否为空

注意，Java 8为列表新增了API ：

replaceAll方法：它会调用传入的Lambda表达式，对列表中的每一个元素执行特定的操作，并用处理后的结果替换该元素
```
  List<String> lang = Arrays.asList("java","Dart","android","flutter");
  lang.replaceAll((e)->e.toUpperCase());
  System.out.println(lang);
```
forEach方法：调用传入的Lambda表达式，用于遍历列表
```
lang.forEach(item->System.out.println(item));
```

映射

       Map<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("pear", 2);
        System.out.println(map.get("apple")); 

        // Map的遍历
        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

        // 另一种遍历方式
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

        // 利用迭代器遍历，可在变量时删除元素
        Iterator<Map.Entry<String, Integer>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            if ("apple".equals(entry.getKey())) {
                it.remove();
            }
        }

使用Map时有几点注意

储存的键不能相同，值可以相同
HashMap是无序的，遍历时并不保证按照添加时的顺序输出
普通的遍历方式，不能在遍历元素时删除，必须使用迭代器遍历

注意，Java 8为Map新增了一些API：

getOrDefault方法：如果Map中不存在指定的键，调用该方法可以返回指定的默认值
```
int val = map.getOrDefault("orange",-1);
```
computeIfAbsent方法：如果键不存在，则计算Lambda表达式的值，且存入map中，并返回该值
```
int value = map.computeIfAbsent("banana",key->3);
```
forEach方法：调用传入的Lambda表达式，可用于遍历Map
```
map.forEach((k,v)->System.out.println("key="+k+" value="+v));
```

文件与IO

文本文件读写：

FileWriter：基础文本文件写操作类

try {
    FileWriter fw = new FileWriter("test.txt");
    fw.write("this is Mike");
    fw.write("this is John");
    fw.close();
} catch (IOException e) {
    e.printStackTrace();
}

BufferWriter：带缓冲的高性能文本文件写操作

try {
    FileWriter fw = new FileWriter("test.txt");
    BufferedWriter out = new BufferedWriter(fw);
    out.write("this is Mike");
    out.write("this is John");
    out.close();
} catch (IOException e) {
    e.printStackTrace();
}

FileReader：基础文本文件读操作类

// 逐个字符读取操作（一次读一个字符，循环读）
try {
    FileReader fr = new FileReader("test.txt");
    int ch = 0;
    // 判断此字节的值为-1表示读到文件末尾
    while ((ch = fr.read()) != -1) {
        // 转换为字符输出
        System.out.println((char) ch);
    }
} catch (IOException e) {
    e.printStackTrace();
}

BufferedReader：带缓冲的读操作

try {
    FileReader fr = new FileReader("test.txt");
    BufferedReader br = new BufferedReader(fr);

    StringBuilder sb = new StringBuilder();
    String str;

    // 逐行读取字符
    while ((str = br.readLine()) != null) {
        sb.append(str);
    }
} catch (IOException e) {
    e.printStackTrace();
}

Java字节流相关的读写较为复杂

字节流两大抽象基类：

InputStream ：字节输入流
OutputStream：字节输出流

使用字节流的方式读取字符

File file = new File("test2.txt");
try {
   //字节输入流对象
   FileInputStream fis = new FileInputStream(file);

   // 将字节输入流转化为字符输入流，并设置编码格式（InputStreamReader为Reader的子类）
   InputStreamReader reader = new InputStreamReader(fis, "utf-8");

   //字符缓冲流
   BufferedReader br = new BufferedReader(reader);

   String str = "";
   while ((str = br.readLine()) != null) {
      System.out.println(str);
   }
} catch (Exception ex) {
   ex.printStackTrace();
}

复制文件代码实例

public class CopyFile {

    public static boolean copy(String src, String dst) {
        File srcFile = new File(src);
        File dstFile = new File(dst);

        // 判断源文件是否存在 || 源文件是否是文件
        if (!srcFile.exists() || !srcFile.isFile()) {
            System.out.println("源文件出错");
            return false;
        }

        // 判断目标文件是否存在
        if (dstFile.exists()) {
            return false;
        }

        // 声明输入输出流对象
        FileInputStream from = null;
        FileOutputStream to = null;

        try {
            from = new FileInputStream(srcFile);
            to = new FileOutputStream(dstFile);

            //定义复制缓冲区
            byte[] bufByte = new byte[10 * 1024];

            int len;
            while ((len = from.read(bufByte)) != -1) {
                to.write(bufByte, 0, len);
            }
            return true;
        } catch (IOException e) {
            System.out.println(e.getMessage());
            return false;
        } finally {
            //关闭流
            if (from != null) {
                try {
                    from.close();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
            if (to != null) {
                try {
                    to.close();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
        }
    }
}

公众号“编程之路从0到1”

标准库

Java的标准库

集合

列表

映射

文件与IO

results matching ""

No results matching ""