1.Set接口特点
- Set接口是无序的
- Set接口中的数据不允许重复
- Set接口无法通过下标访问数据
- 查找慢,插入删除快(底层数据结构是哈希表和红黑树)
- Set集合使用equals()和hashCode()方法实现元素去重
2.HashSet特点:
- HashSet是Set接口的实现类
- 线程不安全
HashSet避免对象重复的规则:
1)如果对象的hashCode值不同,则不用判断equals方法,就直接存到HashSet中。
2)如果对象的hashCode值相同,需要用equals方法进行比较,如果结果为true,则视为相同元素,不存储。如果结果为false,视为不同元素,进行存储。
如果对象元素要存储到HashSet中,必须覆盖hashCode方法和equals方法。才能保证从对象中的内容的角度保证唯一。
3.迭代器Iterator
迭代器(iterator)有时又称游标(cursor)是程序设计的软件设计模式,可在容器对象(container,例如链表或数组)上遍访的接口,设计人员无需关心容器对象的内存分配的实现细节。
HashSet类中没有提供根据集合索引获取索引对应的值的⽅法,
因此遍历HashSet时需要使⽤Iterator迭代器。Iterator的主要⽅法如下
返回类型 | 方法 | 描述 |
boolean | hasNext() | 如果有元素可迭代 |
Object | next() | 返回迭代的下⼀个元素 |
4 TreeSet
TreeSet 基于TreeMap 实现。TreeSet可以实现有序集合,但是有序性需要通过比较器实现。
TreesSet特点:
- 有序
- 不重复
- 添加、删除、判断元素存在性效率比较高
- 线程不安全
TreeSet对元素进行排序的方式:
1) 如果是基本数据类型和String类型,无需其它操作,可以直接进行排序。
2) 对象类型元素排序,需要实现Comparable接口,并覆盖其compareTo方法。
3) 自己定义实现了Comparator接口的排序类,并将其传给TreeSet,实现自定义的排序规则。
5 LinkedHashSet
LinkedHashSet是一种有序的Set集合,其元素的存入和取出顺序是相同的。
public class Test {
public static void main(String[] args) {
// LinkedHashSet:链表结构的Set集合
// 1.不重复 2.能保证添加的次序(添加和输出次序一致)
Set set = new LinkedHashSet();
set.add("c");
set.add("a");
set.add("d");
set.add("b");
System.out.println(set);
}
}
//迭代器遍历
Iterator iterator = hashSet.iterator();//获取迭代器对象 有序:有下标
while (iterator.hasNext()){//判断是否指定能够移动
Object next = iterator.next();//指定移动并获取当前的元素
System.out.println(next);
}
//遍历--- foreach
for(Object o: hashSet){
System.out.println(o);
}
}
}
6. Map 属于键值对模式
map中得每个元素属于键值对模式。 如果往map中添加元素时 需要添加key 和 value. 它也属于一个接口,该接口常见得实现类有: HashMap.
6.1 如何创建Map对象
//默认初始化大小为16 负载因子为0.75 Map map=new HashMap(); //初始化大小 Map map2=new HashMap(16); //初始化大小 负载因子 Map map3=new HashMap(16,0.78f);
6.2 添加操作
//默认初始化大小为16 负载因子为0.75 Map map=new HashMap(); //添加操作 key: name value: 高景霞 map.put("name","张三"); //注意: 要求map得key必须唯一。 map.put("age",18); map.put("name","李四"); //因为key不能重复,所以后者会把前者覆盖 Map m1=new HashMap(); m1.put("k1","v1"); m1.put("k2","v2"); map.putAll(m1); //把m1中得每个元素 添加到map中 map.putIfAbsent("age",28) ;//如果指定得key存在,则不放入map中,如果不存在则放入map中 System.out.println(map);
6.3 删除操作
//删除操作 map.remove("age2");//根据指定得key移除元素 System.out.println(map); map.clear(); //清空map容器 System.out.println(map);
6.4 修改操作
//修改操作 map.replace("name","王五");//替换元素 System.out.println(map);
6.5 查询
public static void main(String[] args) { Map map=new HashMap(); map.put("k1","v1"); map.put("k4","v4"); map.put("k2","v2"); map.put("k3","v3"); //查询操作 boolean f = map.containsKey("k5");//判断map是否存在指定得key Object v = map.get("k5"); //根据指定的key获取对应得value值 System.out.println(v); Set keys = map.keySet();//返回该map中所有得key System.out.println(keys); //遍历map. for(Object k:keys){ Object value= map.get(k);// System.out.println(k+"================>"+value); } }
7. 泛型
7.1 什么是泛型?
1. 泛型就是限制我们得数据类型。 2.为什么使用泛型? 我们原来在定义集合时,是如下得定义方式: List list=new ArrayList();//该集合没有使用泛型 list.add("java01"); list.add("java02"); String str= (String) list.get(0);//获取元素 需要进行强制类型转换 System.out.println(str); 获取元素时,不方便对元素进行相应得其他操作。
7.2 如何使用泛型
List<类型> list=new ArrayList<类型>(); 只能在该集合中存储指定得类型。
public static void main(String[] args) { List<String> list=new ArrayList<>();//这里就限制了集合中每个元素得类型。 list.add("java01"); list.add("hello"); //因为集合中只能添加String类型 list.add("world"); //因为集合中只能添加String类型 String s = list.get(0); //在获取元素时 默认就是相应得数据类型 而无需在进行转换 //<K,V>:K:表示键得泛型 V:表示值得泛型 HashMap<String,Integer> map=new HashMap<>(); map.put("name",15); map.put("age",25); Set<String> keys = map.keySet(); }
7.3 我们自己能否定义泛型类
肯定可以
public class 类名<标识,标识....> { 标识 变量名; public 标识 方法名(){ } public void 方法名(标识 参数名){ } ......... }
定义坐标类:
public class Test03 {
public static void main(String[] args) {
//在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型
Point p1=new Point();
p1.setX(15);
p1.setX("北纬50度");
//这里得泛型必须都是对象类型
Point<Integer> p2=new Point<Integer>() ;
p2.setX(25);
p2.setY(65);
Integer x = p2.getX();
Integer y = p2.getY();
p2.show();
Point<String> p3=new Point<>();
}
}
class Point<T>{
private T x;
private T y;
public void show(){
System.out.println("x坐标为:"+x+";y坐标为:"+y);
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
8. File对象
8.1 file得介绍
File 类 就是当前系统中 文件或者文件夹的抽象表示 通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件夹 学习File类 其实就是学习 如果通过file对象 对系统中的文件/文件夹进行增删改查
8.2 创建File对象
1. 磁盘准备一个目录AAA。以后对文件得操作都放在该目录下。
public static void main(String[] args) { //创建一个File对象 并指定文件得路径 \转移字符串 File file01 = new File("D:\\AAA\\aaa.txt"); /* \\目录层级 在window系统下层级分割符为\ 但是在linux和mac系统上分割符为 / 我们得java代码是一种跨平台得语言。 我们得开发在window 但是我们项目得部署在linux. 我们使我们得代码能在任意系统下来用。 我们有两种解决办法 (1)第一种 因为window 兼容 / 和 \ */ File file02 = new File("D:/AAA/bbb.txt"); // 第二种 File.separator根据当前代码所在得系统自动获取相应得分割符 System.out.println(File.separator); // \因为我们当前在window下 File file03 = new File("D:"+File.separator+"AAA"+File.separator+"ccc.txt"); }
8.3 增加操作
public class Test05 {
public static void main(String[] args) throws IOException {
File file01 =new File("D:/AAA/aaaa.txt"); //创建File对象
file01.createNewFile();//创建相应得文件
File file02 = new File("D:/AAA/bbb");
file02.mkdir();//创建目录 make directory 单层目录
File file03 = new File("D:/AAA/ccc/fff");
file03.mkdirs(); //创建多层目录
File file04 = new File("D:/AAA/eee");
file04.createNewFile();
//使根据你调用得方法不同 而创建不同得类型
}
}
8.4 删除
public static void main(String[] args) throws InterruptedException {
File file01 = new File("D:/AAA/a.txt");
file01.delete();//删除文件
File file02 = new File("D:/AAA/eee");
file02.deleteOnExit(); // 当程序退出后 删除
// Thread.sleep(5000); //休眠10秒
File file03 = new File("D://AAA/bbb");
file03.delete();//删除空目录
}
8.5 修改
public static void main(String[] args) throws IOException {
File file=new File("D:/AAA/c.txt");
file.createNewFile();
// file.setReadable(false);//设置该文件得权限为不能读
// file.setWritable(false);//设置该文件不能写
// file.setReadOnly();//设置只读得权限
file.renameTo(new File("D:/AAA/d.txt"));//重命名
}
8.6 查询
public static void main(String[] args) {
File file=new File("D:/AAA/ccc/fff/a.txt");
String name = file.getName(); //得到文件得名称
System.out.println("name======"+name);
String parent = file.getParent(); //得到父级路径得名称
System.out.println("parent===="+parent);
String path = file.getPath(); //得到文件得路径名称
System.out.println("path======"+path);
boolean f1 = file.isFile(); //判断该文件对象是否为文件类型
System.out.println("f1========="+f1);
boolean f2 = file.isDirectory(); //判断该文件对象是否为目录类型
System.out.println("f2========="+f2);
File file2 = new File("D:/AAA");
String[] list = file2.list(); //列出AAA目录下所有子文件得名称
System.out.println(Arrays.toString(list));
File[] files = file2.listFiles(); //列出AAA目录下所有文件对象
for(File f:files){
System.out.println(f.toString());
}
}
经典题目: 用的方法的递归调用。
显示指定目录下的所有文件。D:/AAA下所有的文件.
public static void main(String[] args) {
showAllFiles("D:/AAA");
}
public static void showAllFiles(String path){
//使用传入的路径构建文件对象
File file=new File(path); //判断文件是否存在 或者文件是否为目录. if(!file.exists() || !file.isDirectory()){
return;
} //列出该目录下所有的文件对象。
File[] files = file.listFiles();
//遍历数组 for(File f:files){
if(f.isDirectory()){
System.out.println(f.getPath()+" <Dir>");
showAllFiles(f.getPath());//继续调用本方法
}else{
System.out.println(f.getPath()+" ");
}
}
}
9.IO流
1. IO 表示有两个单词的缩写。 I: Input 输入 O: Output 输出 2. IO的作用:就是对文件中的内容进行操作。 输入: 读操作(读取文件的内容) 输出: 写操作(往文件中写内容) 3. IO流的分类: (1)根据流的方向: ---输入流: 程序可以从中读取数据的流。 ---输出流: 程序能向其中写入数据的流。 (2)根据流的单位: ---字节流: 以字节为单位传输数据的流 ---字符流: 以字符为单位传输数据的流 (3)根据功能 ---节点流: 直接和文件进行交互 ---处理流: 不是直接作用在文件上。 四个基本的流: 其他的流都是在这四个流的基础上进行扩展的 字节输入流 字节输出流 字符输入流 字符输出流
9.1 Writer字符输出流
public static void main(String[] args) throws Exception{
//字符输出流 ---指定对哪个文件(路径)进行写操作
Writer writer=new FileWriter("D:/AAA/d.txt");
String str="hello AAA 今天要开演唱会";
writer.write(str);
writer.flush(); //刷新流
writer.close(); //关闭流资源
}
9.2 Reader字符输入流
public static void main(String[] args) throws Exception {
//创建字符输入流对象. 作用:就是读取aaaa.txt里的内容
Reader reader=new FileReader("D:/AAA/aaaa.txt");
int count=0;//表示读取字符的个数
char[] cs=new char[10]; //每次读取到元素存入该数组中
while( (count=reader.read(cs)) !=-1 ){
String str=new String(cs,0,count);
System.out.print(str);
}
10. 字节流
10.1 字节输出流--OutputStream
它可以对任意文件进行操作,对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类, FileOutputStream
//测试字节输出流 @Test public void testOutStream() throws Exception{ OutputStream os=new FileOutputStream("D:/AAA/f.txt"); String str="abcd"; //把字符串转换为字节数组. byte[] bytes = str.getBytes(); os.write(bytes); os.flush(); os.close(); }
10.2 字节输入流---InputStream
它可以对任意文件进行读操作 ,以字节为单位,它是所有字节输入流的父类,子类有FileInputStream
//一次一次的读取 @Test public void testInputStream() throws Exception{ InputStream is=new FileInputStream("D:/AAA/f.txt"); byte [] bytes=new byte[3]; int c=is.read(bytes); //一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数 System.out.println(bytes+"=============>个数:"+c); c=is.read(bytes); //一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数 System.out.println(bytes+"=============>个数:"+c); c=is.read(bytes); //一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数 System.out.println(bytes+"=============>个数:"+c); } //如果文件中内容非常大 使用循环来读取 @Test public void testInputStream2() throws Exception{ InputStream is=new FileInputStream("D:/AAA/f.txt"); byte [] bytes=new byte[300]; int c=0; //读取到的个数 while( (c=is.read(bytes))!=-1 ){ //把byte数组转换为字符串 String str=new String(bytes,0,c); System.out.println(str); } is.close(); }
使用字节输入和输出流完成文件的复制功能:
@Test public void testCopy() throws Exception{ //1.创建字节输入流 视频 InputStream is=new FileInputStream("D:/AAA/1.jpg"); //2.字节输出流 OutputStream fos=new FileOutputStream("C:/AAA/2.jpg"); byte[] bytes=new byte[10]; int c=0; while( (c=is.read(bytes)) !=-1 ){ fos.write(bytes,0,c); } is.close(); fos.close(); }
11.缓存流
缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能. BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率,降低IO的次数。
@Test public void TestBuffer() throws Exception{ OutputStream out=new FileOutputStream("D:/AAA/g.txt"); BufferedOutputStream bos=new BufferedOutputStream(out);//缓存流要作用再基础流上 String str="abcdefhijglmn"; byte[] bytes = str.getBytes(); bos.write(bytes); //因为你写的内容 暂时放入缓存池中 并没有直接放入文件中。 所以文件中没有你的内容。 //bos.flush();//刷新缓存池---把池子中的内容输入到文件上 bos.close(); //关闭----先刷新缓冲池 再关闭流资源 }
12.对象流--对java对象进行IO操作
@Test //存档:----序列化:
public void testObjectStream() throws Exception{
OutputStream out=new FileOutputStream("D:/AAA/a.txt");
//对象输出流
ObjectOutputStream oos=new ObjectOutputStream(out);
//使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
Role r=new Role("吕布","7级",1,"弑父");
oos.writeObject(r);
oos.close();
}
//测试 读档: ----反序列化:
@Test
public void testObjectStream2()throws Exception{
InputStream input=new FileInputStream("D:/AAA/a.txt");
ObjectInputStream ois=new ObjectInputStream(input);
Object o = ois.readObject();
System.out.println(o);
ois.close();
}
1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
---java对象所属的类必须实现序列化接口.implements Serializable
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。