网站建设vipjiuselu,汕头建站培训,wordpress中文转英文,wordpress 安装 权限设置前言#xff1a;前面主要涉及到java的基本语法#xff0c;接下来本篇博客主要记录Java中Collections类、泛型、以及File类、IO流的学习。 目录
数据结构
泛型
集合
分类
Collection的分类
collection常用方法
collection遍历方式
迭代器
for循环
Lambda表达式
Lis… 前言前面主要涉及到java的基本语法接下来本篇博客主要记录Java中Collections类、泛型、以及File类、IO流的学习。 目录
数据结构
泛型
集合
分类
Collection的分类
collection常用方法
collection遍历方式
迭代器
for循环
Lambda表达式
List集合
特点
增删改查
List集合的遍历方式
for循环
迭代器
增强for循环for
Lambda表达式
ArrayList集
底层原理
适合场景
LinkedList集合
底层原理
应用场景
设计队列
栈
Set集合
特点
HashSet
底层原理
适用场景
LinkedHashSet
底层原理
适用场景
TreeSet
底层原理
适用场景
Map集合
特点
常用方法
遍历方式
for循环
键找值
Lambda表达式
File
常用方法
递归
递归应用-搜索文件
字符集
IO流
IO流体系
字节流
FileInputStream文件字节输入流
每次读取一个字节
每次读取多个字节
一次性全都读完全部字节
OutputStream FileOutputStream文件字节输出流
拷贝文件
释放资源
try-catch-finally
try-with-resource
实用场景
字符流
每次读取一个字符
每次读取多个字符
FileWriter文件字符输出流
适用场景 数据结构
数据结构是组织数据的方式数据结构算法程序。
数组是一种基本的数据结构。
基础的数据结构List、Set、Queue、Map比较高级的有Tree、Heap。
泛型
英文名generics
ListString ret new ArrayList()
什么是泛型
推荐阅读下面的这篇文章。
还不知道泛型是什么这一篇深入浅出泛型教学 - 知乎 (zhihu.com)
集合 集合是没有顺序的。
import java.util.Collection; 分类
单列集合 colleciton
双列集合 Map
Collection的分类
接口 CollectionE
ListE
ArrayListELinkedListE
SetE
HashSetE LinkedHashSetETreeSetE
List系列集合添加的元素是有序、可重复、有索引
ArrayList、LinkedList有序、可重复、有索引
Set系列集合添加的元素是无序、不重复、无索引
HashSet无序、不重复、无索引LinkedHashSet有序、不重复、无索引TreeSet按大小默认升序排序、不重复、无索引
collection常用方法
package learn11;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;public class ListMrjj {public static void main(String[] args) {ListString List new ArrayList();//添加元素List.add(mrjj);List.add(test);List.add(wy);// 获取集合的大小System.out.println(List.size());//判断集合是否包含某个元素 精确匹配System.out.println(List.contains(wy));System.out.println(List.contains(WY));//移除第3个元素System.out.println(List.remove(2));System.out.println(List);//获取特定索引的元素System.out.println(List.get(0));//修改指定索引的元素System.out.println(List.set(0, Mrjj));System.out.println(List);//集合转为数组Object[] arr List.toArray();System.out.println(Arrays.toString(arr));//集合中的数据都是字符串String[] arr2 List.toArray(new String[List.size()]);System.out.println(Arrays.toString(arr2));//清空集合List.clear();//判断集合是否为空System.out.println(List.isEmpty());//将其中一个集合的数据加入另一个集合中CollectionString c1 new ArrayList();c1.add(test1);c1.add(test2);CollectionString c2 new ArrayList();c2.add(test_a);c2.add(test_b);c1.addAll(c2);System.out.println(c1);System.out.println(c2);}
}collection遍历方式
迭代器
package learn11;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class ListLearn {public static void main(String[] args) {ListString List new ArrayList();List.add(learning);List.add(wyLearning);List.add(test);List.add(wy);List.add(wangying);List.add(wyy);IteratorString it List.iterator();while (it.hasNext()) {String name it.next();System.out.println(name);}}
}for循环
package learn11;import java.util.ArrayList;
import java.util.List;public class ListLearn {public static void main(String[] args) {ListString List new ArrayList();List.add(learning);List.add(wyLearning);List.add(test);List.add(wy);List.add(wangying);List.add(wyy);for (int i 0; i List.size(); i) {String s List.get(i);System.out.println(s);}}
}
Lambda表达式
package learn11;import java.util.ArrayList;
import java.util.List;public class ListLearn {public static void main(String[] args) {ListString List new ArrayList();List.add(learning);List.add(wyLearning);List.add(test);List.add(wy);List.add(wangying);List.add(wyy);
//可简写成 List.forEach(System.out::println)List.forEach(s - {System.out.println(s);});}
}
List集合
特点
List系列集合添加的元素是有序、可重复、有索引
ArrayList、LinkedList有序、可重复、有索引
增删改查
package learn11;import java.util.ArrayList;
import java.util.List;public class ListMrjj {public static void main(String[] args) {ListString List new ArrayList();List.add(mrjj);List.add(test);List.add(wy);System.out.println(List);System.out.println(List.remove(2));System.out.println(List);System.out.println(List.get(0));System.out.println(List.set(0, Mrjj));System.out.println(List);}
} List集合的遍历方式
for循环
package learn11;import java.util.ArrayList;
import java.util.List;public class ListLearn {public static void main(String[] args) {ListString List new ArrayList();List.add(learning);List.add(test);List.add(wy);for (int i 0; i List.size(); i) {String s List.get(i);System.out.println(s);}}
}
迭代器
IteratorString it List.iterator();while (it.hasNext()){System.out.println(it.next());}
增强for循环for
for (String s : List) {System.out.println(s);}
Lambda表达式
List.forEach(s-{System.out.println(s);});
数据结构存储组织数据的方式是不同的。
ArrayList集
底层原理
基于数组实现的
数组的特点
根据索引查询数据是比较快的
删除、添加效率较低
适合场景
根据索引查询数据
不适合场景
数据量较大时需要频繁的增删操作
LinkedList集合
底层原理
基于双链表
特点
查询慢增删相对较快首尾元素进行增删改查的速度是极快的
应用场景
设计队列
设计队列队列先进先出、后进后出
实现一个队列
package learn11;import java.util.LinkedList;public class ListQueue {public static void main(String[] args) {LinkedListString queue new LinkedList();queue.addLast(第1个人);queue.addLast(第2个人);queue.addLast(第3个人);queue.addLast(第4个人);queue.addLast(第5个人);queue.addLast(第6个人);System.out.println(queue);queue.removeFirst();queue.removeFirst();queue.removeFirst();System.out.println(queue);}
}栈
进入栈压栈、进栈push
离开栈弹栈、出栈pop
package learn11;import java.util.LinkedList;public class ListQueue {public static void main(String[] args) {LinkedListString stack new LinkedList();stack.addFirst(第1颗子弹);stack.addFirst(第2颗子弹);stack.addFirst(第3颗子弹);stack.addFirst(第4颗子弹);stack.addFirst(第5颗子弹);stack.addFirst(第6颗子弹);System.out.println(stack);System.out.println(stack.removeFirst());System.out.println(stack.removeFirst());System.out.println(stack.removeFirst());System.out.println(stack);}
}package learn11;import java.util.LinkedList;public class ListQueue {public static void main(String[] args) {LinkedListString stack new LinkedList();stack.push(第1颗子弹);stack.push(第2颗子弹);stack.push(第3颗子弹);stack.push(第4颗子弹);stack.push(第5颗子弹);stack.push(第6颗子弹);System.out.println(stack);System.out.println(stack.pop());System.out.println(stack.pop());System.out.println(stack.pop());System.out.println(stack);}
}
实际上push方法就是调用的addFirst方法pop方法调用的removeFirst方法 Set集合
特点
Set系列集合添加的元素是无序、不重复、无索引
HashSet无序、不重复、无索引LinkedHashSet有序、不重复、无索引按大小默认升序排序、不重复、无索引
HashSet
package learn11;import java.util.HashSet;
import java.util.Set;public class SetLearn {public static void main(String[] args) {SetInteger set new HashSet();set.add(23);set.add(67);set.add(24);set.add(74);set.add(33);set.add(23);System.out.println(set);}
} 哈希值
一个int类型的数值java中每个对象都有一个哈希值
java中的所有对象都可以调用Object类提供的hashCode方法返回该对象自己的哈希值
public int hashcode():返回对象的哈希码值
底层原理
基于哈希表实现
哈希表是一种增删改查数据性能都较好的数据结构
适用场景
不需要存储重复元素不需要排序无索引
LinkedHashSet
package learn11;import java.util.LinkedHashSet;
import java.util.Set;public class SetLearn {public static void main(String[] args) {SetInteger set new LinkedHashSet();set.add(23);set.add(67);set.add(24);set.add(74);set.add(33);set.add(23);System.out.println(set);}
} 底层原理
基于哈希表实现的
每个元素都额外多了一个双链表的机制记录前后元素的位置
适用场景
需要记住元素的添加顺序无重复元素存储增删改查都快
TreeSet
package learn11;import java.util.Set;
import java.util.TreeSet;public class SetLearn {public static void main(String[] args) {SetInteger set new TreeSet();set.add(23);set.add(67);set.add(24);set.add(74);set.add(33);set.add(23);System.out.println(set);}
}底层原理
自定义排序规则
适用场景
需要对元素进行排序没有重复元素需要存储增删改查都快
Map集合
键值对集合
键不能重复
MapK,V
HashMapK,V
LinkedHashMapK,V
TreeMapK,V
特点
Map系列集合的特点都是由键决定的
HashMap无序、不重复、无索引
LinkedHashMap有序、不重复、无索引
TreeMap按照大小默认升序排序、不重复、无索引
常用方法
package learn11;import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapLearn {public static void main(String[] args) {MapString, Double map new HashMap();map.put(test1, 170.0);map.put(test2, 160.0);map.put(test3, 150.0);map.put(test4, 140.0);map.put(test5, 130.0);System.out.println(map);System.out.println(map.size());//根据键获取值System.out.println(map.get(test1));//找不到返回nullSystem.out.println(map.get(wy));//根据键删除元素map.remove(test5);System.out.println(map);//判断是否包含某个键System.out.println(map.containsKey(test3));//判断是否包含某个值System.out.println(map.containsValue(170.0));
// map.clear();System.out.println(map);System.out.println(map.isEmpty());//获取所有键SetString keys map.keySet();System.out.println(keys);//获取所有值CollectionDouble values map.values();System.out.println(values);//将其他map集合的数据倒入集合中MapString,Integer map1 new HashMap();map1.put(python1,10);map1.put(python2,20);MapString,Integer map2 new HashMap();map2.put(java1,10);map2.put(java2,20);map1.putAll(map2);System.out.println(map1);System.out.println(map2);}
}
遍历方式
for循环
package learn11;import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapLearn {public static void main(String[] args) {MapString, Double map new HashMap();map.put(test1, 170.0);map.put(test2, 160.0);map.put(test3, 150.0);map.put(test4, 140.0);map.put(test5, 130.0);SetString keys map.keySet();for (String key : keys) {double value map.get(key);System.out.println(key value);}}
}键找值
package learn11;import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapLearn {public static void main(String[] args) {MapString, Double map new HashMap();map.put(test1, 170.0);map.put(test2, 160.0);map.put(test3, 150.0);map.put(test4, 140.0);map.put(test5, 130.0);SetMap.EntryString, Double entries map.entrySet();for (Map.EntryString, Double entry : entries) {System.out.println(entry);}map.forEach((k, v) - {System.out.println(k - v);});}
}
Lambda表达式
package learn11;import java.util.HashMap;
import java.util.Map;public class MapLearn {public static void main(String[] args) {MapString, Double map new HashMap();map.put(test1, 170.0);map.put(test2, 160.0);map.put(test3, 150.0);map.put(test4, 140.0);map.put(test5, 130.0);map.forEach((k,v) - {System.out.println(k-v);});}
}
File
常用方法
只能删除空文件夹
package learn11;import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;public class FileLearn {public static void main(String[] args) throws IOException {File f1 new File(D:File.separatorqq\\QQWhatsnew.txt);System.out.println(f1.getName());System.out.println(f1.length());File f2 new File(D:File.separatorqq);System.out.println(f2.length());String[] names f2.list();for(String name:names){System.out.println(name);}File[] files f2.listFiles();for(File file:files){System.out.println(file.getAbsolutePath());}File f3 new File(src\\learn);System.out.println(f3.length());System.out.println(f3.getName());System.out.println(f1.isDirectory());System.out.println(f1.isFile());long time f1.lastModified();SimpleDateFormat sdf new SimpleDateFormat(yyy/MM/dd HH:mm:ss);System.out.println(sdf.format(time));System.out.println(f3.getPath());System.out.println(f3.getAbsolutePath());File f4 new File(D:/testwy.txt);System.out.println(f4.createNewFile());File f5 new File(D:/a/b/c);System.out.println(f5.mkdirs());System.out.println(f4.delete());System.out.println(f5.delete());System.out.println(f5.delete());System.out.println(f5.delete());}
}
递归
典型例子求阶乘
package learn11;public class jc {public static void main(String[] args) {System.out.println(f(5));}public static int f(int n) {if (n 1) {return 1;} else {return f(n - 1) * n;}}
}
递归应用-搜索文件
package learn11;import java.io.File;public class SearchLearn {public static void main(String[] args) {searchFile(new File(D:/), QQ.exe);}public static void searchFile(File dir, String fileName) {if (dir null || !dir.exists() || dir.isFile()) {return;}File[] files dir.listFiles();if (files ! null files.length 0) {for (File f : files) {if (f.isFile()) {if (f.getName().contains(fileName)) {System.out.println(找到了 f.getAbsolutePath());}} else {searchFile(f, fileName);}}}}
}
字符集
ASCII
首尾是01个字节存储一个字符总共表示128个字符
GBK
一个中文字符编码成两个字节的形式存储
GBK兼容了ASCII字符集
Unicode字符集
UTF-8
英文字符、数字等只占1个字节汉字字符占用3个字节
IO流
I是指input称为输入流负责把数据读到内存中
O是指output称为输出流负责写数据出去
IO流体系
字节流
字节输入流InputStream FileInputStream
字节输出流OutputStream FileOutputStream
字符流
字符输入流Reader FileReader
字符输出流Writer FileWriter
字节流
FileInputStream文件字节输入流
每次读取一个字节
package learn11;import java.io.FileInputStream;public class FileInputStreamMrjj {public static void main(String[] args) throws Exception {FileInputStream is new FileInputStream(src\\test);int b1 is.read();System.out.println((char) b1);int b2 is.read();System.out.println((char) b2);int b3 is.read();System.out.println(b3);int b;while ((b is.read()) ! -1) {System.out.println((char) b);}is.close();}
}
每次读取多个字节
package learn11;import java.io.FileInputStream;
import java.io.InputStream;public class FileInputStreamTest {public static void main(String[] args) throws Exception {InputStream is new FileInputStream(src\\test);byte[] buffer new byte[3];int len;while ((len is.read(buffer)) ! -1) {String rs new String(buffer, 0, len);System.out.println(rs);}is.close();}
}上面读取方法会有中文乱码的问题用一次性全部读取完字节可以解决中文乱码的问题
一次性全都读完全部字节
package learn11;import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;public class FileInputStreamAll {public static void main(String[] args) throws Exception {InputStream is new FileInputStream(src\\test);File f new File(src\\test);long size f.length();byte[] buffer new byte[(int) size];int len is.read(buffer);System.out.println(new String(buffer));System.out.println(size);System.out.println(len);}
}
OutputStream FileOutputStream文件字节输出流
package learn11;import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;public class FileOutputStreamTest1 {public static void main(String[] args) throws Exception {OutputStream os new FileOutputStream(src\\test, true);os.write(97);os.write(b);
// os.write(泰);byte[] bytes 中国加油.getBytes();os.write(bytes, 0, 9);os.write(\r\n.getBytes());os.close();}
}
拷贝文件
package learn11;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;public class CopyPicture {public static void main(String[] args) throws Exception {InputStream is new FileInputStream(C:/Users/HP/Desktop/1.jpg);OutputStream os new FileOutputStream(D:/1.jpg);byte[] buffer new byte[1024];int len;while ((len is.read(buffer)) ! -1){os.write(buffer,0,len);}os.close();is.close();}
}
释放资源
try-catch-finally
无论程序是正常执行还是出现异常了最后一定会执行finally
package learn11;public class test1 {public static void main(String[] args) {try {System.out.println(10 / 0);} catch (Exception e) {e.printStackTrace();} finally {System.out.println(finally执行了一次);}}
}
复制文件时应用try-catch-finally
package learn11;import java.io.*;public class CopyPicture {public static void main(String[] args) throws Exception {InputStream is null;OutputStream os null;try {is new FileInputStream(src\\test);os new FileOutputStream(src\\test1);byte[] buffer new byte[1024];int len;while ((len is.read(buffer)) ! -1) {os.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {try {if(os ! null) is.close();} catch (IOException e) {e.printStackTrace();}try {if(os ! null) os.close();} catch (IOException e) {e.printStackTrace();}}}
}try-with-resource
释放资源自动调用AutoCloseable接口
package learn11;import java.io.*;public class CopyPicture {public static void main(String[] args) throws Exception {try (InputStream is new FileInputStream(src\\test);OutputStream os new FileOutputStream(src\\test1);) {byte[] buffer new byte[1024];int len;while ((len is.read(buffer)) ! -1) {os.write(buffer, 0, len);}} catch (IOException e) {e.printStackTrace();}}
}
实用场景
字节流适合做一切文件数据的拷贝音视频、文本字节流不适合读取中文内容输出有乱码
字符流
每次读取一个字符
package learn11;import java.io.FileReader;
import java.io.Reader;public class FileReaderTest1 {public static void main(String[] args) {try (Reader fr new FileReader(src\\test);) {int c;while ((c fr.read()) ! -1) {System.out.print((char) c);}} catch (Exception e) {e.printStackTrace();}}
}
每次读取多个字符
package learn11;import java.io.FileReader;
import java.io.Reader;public class FileReaderTest1 {public static void main(String[] args) {try (Reader fr new FileReader(src\\test);) {char[] buffer new char[3];int len;while ((len fr.read(buffer)) ! -1) {System.out.println(new String(buffer, 0, len));}} catch (Exception e) {e.printStackTrace();}}
}
FileWriter文件字符输出流
需要注意关闭流包含了刷新流
字符输出数据后必须刷新流或者关闭流。
package learn11;import java.io.FileWriter;
import java.io.Writer;public class FileWriterTest1 {public static void main(String[] args) {try (Writer fw new FileWriter(src\\test,true);) {fw.write(a);fw.write(99);fw.write(测);fw.write(中国加油, 0, 3);fw.write(\r\n);char[] buffer {测, 试, a, b, c};fw.write(buffer);fw.write(buffer, 0, 2);} catch (Exception e) {e.printStackTrace();}}
}适用场景
适合做文本文件的读写操作
