// static <T> List<T> emptyList()
// 返回空的列表（不可变的）。
// static <K,V> Map<K,V> emptyMap()
// 返回空的映射（不可变的）。
// static <T> Set<T> emptySet()
// 返回空的 set（不可变的）。
// static <T> boolean addAll(Collection<? super T> c, T... elements)
// 将所有指定元素添加到指定 collection 中。
List<String> list = new ArrayList<>();
list.add("ddd");
list.add("aaa");
list.add("bbb");
list.add("ccc"); Collections.addAll(list,"eee","fff","ggg");
// static <T> int binarySearch(List<?> list, T key) // 使用二分搜索法搜索指定列表，以获得指定对象。
// static <T> int binarySearch(List<?> list, T key, Comparator<? > c)
// 使用二分搜索法搜索指定列表，以获得指定对象。 Collections.sort(list);
int index = Collections.binarySearch(list, "ddd");
// static <T> void copy(List<? super T> dest, List<? extends T> src)
// 将所有元素从一个列表复制到另一个列表。
List<String> list1 = new ArrayList<>();
Collections.addAll(list1, "111", "222", "333");
Collections.copy(list, list1);// 替换
// static <T> void fill(List<? super T> list, T obj) // 使用指定元素替换指定列表中的所有元素。
Collections.fill(list1, "000"); System.out.println("list1 ====== " + list1);
// static int indexOfSubList(List<?> source, List<?> target)
// static int lastIndexOfSubList(List<?> source, List<?> target)
list.addAll(list1);
int index1 = Collections.indexOfSubList(list, list1); // static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
// 根据元素的自然顺序，返回给定 collection 的最大元素。
// static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
// 根据指定比较器产生的顺序，返回给定 collection 的最大元素。 // static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
// 根据元素的自然顺序 返回给定 collection 的最小元素。
// static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
String min = Collections.min(list);
String max = Collections.max(list);
// static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
// 使用另一个值替换列表中出现的所有某一指定值。
boolean xyz = Collections.replaceAll(list1, "000", "xyz");
// static void reverse(List<?> list)
// 反转指定列表中元素的顺序。
Collections.reverse(list1);
// void shuffle(List<?> list) 类似洗牌
// 使用默认随机源对指定列表进行置换。 Collections.shuffle(list1);
// static <T extends Comparable<? super T>> void sort(List<T> list)
// 根据元素的自然顺序 对指定列表按升序进行排序。
// static <T> void sort(List<T> list, Comparator<? super T> c)
// static void swap(List<?> list, int i, int j)
// 在指定列表的指定位置处交换元素。
Collections.swap(list1, 0, list1.size() - 1);
// static <T> Collection<T> synchronizedCollection(Collection<T> c)
// 返回指定 collection 支持的同步（线程安全的）collection。
// static <T> List<T> synchronizedList(List<T> list) // 返回指定列表支持的同步（线程安全的）列表。
// static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) // 返回由指定映射支持的同步（线程安全的）映射。
// static <T> Set<T> synchronizedSet(Set<T> s)
IO流：数据持久化
-
I : Input 输入 , 编写的程序读取数据到内存中
-
O : Output 输出 , 编写的程序将内存中的数据输出到其他地方(硬盘,用户端
-
流向是相对于程序而言
-
按照操作数据的单位进行划分 :
-
字节流 一个字节一个字节操作 , 可以操作所有类型文件 Stream 结尾
-
字符流 一个字符一个字符操作 , 只能操作 文本文件(纯文字的文件) Reader/Writer 结尾
-
-
注意 : 电脑在存储数据时,是按字节存储,所有文件都是 字节
-
将数据写入硬盘 :输出流 :OutputStream : 此抽象类是表示输出字节流的所有类的超类。
-
ileNotFoundException : 输出流抛出该异常的条件 : 1.文件不存在,且指定位置不可创建 2.文件存在,但不可用3.指定目录不存在
-
文件位置 :
-
绝对路径 : F:/aa/a.txt
-
new File("F:/aa").mkdir();// 在F盘创建aa目录
-
-
相对路径 : Java程序中 IO流默认的相对路径 是从 当前项目工程名 开始计算的
-
new File("aa").mkdir();
-
-
-
// 输出流在创建对象时的三件事 : a.内存中创建流对象 b.查看指定文件是否存在,不存在就创建 c.将流对象和文件关联起来
OutputStream outputStream = new FileOutputStream("a.txt");
// void write(int b) 该函数只能写最右边的一个字节
// 将指定的字节写入此输出流。
outputStream.write('A');outputStream.write(101);
// void write(byte[] b)
// 将 b.length 个字节从指定的 byte 数组写入此输出流。
byte[] bytes = "华夏ABC".getBytes();outputStream.write(bytes);
System.out.println(Arrays.toString(bytes));
// void write(byte[] b, int off, int len)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
outputStream.write(bytes, 4, 5);
// void flush() 缓冲流刷新缓冲区使用// 刷新此输出流并强制写出所有缓冲的输出字节。
outputStream.flush();
// void close() 1.就是将内存流对象和文件解绑 2.具备 flush() 函数的功能
// 关闭此输出流并释放与此流有关的所有系统资源。
outputStream.close(); -
InputStream : 此抽象类是表示字节输入流的所有类的超类。
-
FileInputStream :FileNotFoundException : 输入流中,文件不存在直接抛异常
-
InputStream inputStream = new FileInputStream("a.txt");
// int read() 如果已到达文件末尾，则返回 -1。
// 从此输入流中读取一个数据字节。
int read = inputStream.read();
System.out.println("read = " + read);
read = inputStream.read();
System.out.println("read = " + read);
read = inputStream.read();
System.out.println("read = " + read);
// int read(byte[] b) : 返回值是读取到的数据的长度
// 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
byte[] bytes = new byte[10];
System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
int len = inputStream.read(bytes);
System.out.println("len = " + len);
System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
len = inputStream.read(bytes);
System.out.println("len = " + len);
System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
// int read(byte[] b, int off, int len)
// void close()
// 关闭此文件输入流并释放与此流有关的所有系统资源。
inputStream.close();
-
NotSerializableException : 未序列化异常
-
// 缓冲流 :
// BufferedInputStream// BufferedOutputStream
// 文件拷贝
// fileCopy("C:\\Users\\guanh\\Desktop/file.txt", "x.txt");
fileCopy2("C:\\Users\\guanh\\Desktop/file.txt","y.txt");