day19.Map 集合
java
课前回顾:
1.ArrayList底层原理:
a.第一次add的时候会创建一个默认长度为10的数组
b.超过数组,会自动扩容
c.扩容:1.5倍
2.LinkedList:
a.特点:元素有序 无索引 元素可重复 线程不安全
b.数据结构:双向链表
c.方法:有大量直接操作首尾元素的方法
3.泛型:
a.含有泛型的类 -> new对象的时候确定类型
b.含有泛型的方法 -> 在调用的时候确定类型
c.含有泛型的接口
在实现类的时候确定类型
在实现类的时候不确定类型,需要在new的时候确定类型
d.高级使用:
上限: ? extends 类型 ->?接收的类型应该是后面的本类类型以及子类类型
下限: ? super 类型 -> ?接收的类型应该是后面的本类类型以及父类类型
4.增强for:
a.格式:
for(元素类型 变量名:集合名或者数组名){
}
b.遍历集合的时候底层原理为迭代器
遍历数组的时候底层原理为普通for
5.HashSet:
a.特点: 无序 无索引 元素唯一 线程不安全
b.数据结构:哈希表
6.LinkedHashSet:
a.特点:有序 无索引 元素唯一 线程不安全
b.数据结构:哈希表+链表
7.HashSet如何保证元素唯一的:
先比较哈希值,再比较内容
如果哈希值不一样,存
如果哈希值一样,内容不一样,存
如果哈希值一样,内容一样,去重复
8.Collections:集合工具类
addAll shuffle sort sort(集合,比较器)
今日重点:
1.知道HashMap以及LinkedHashMap的特点以及使用
2.知道HashMap和Hashtable的区别
3.会使用properties属性集
4.会遍历嵌套集合第一章.Map 集合
1.Map 的介绍
java
1.概述:双列集合顶级接口
2.双列集合:
一个元素由两部分构成 -> key和value(键值对)
我们都是通过key获取value2.HashMap 的介绍和使用
java
1.概述:是Map的实现类
2.特点:
a.无序
b.无索引
c.key唯一,value可重复
d.线程不安全
e.可以存null键null值
3.数据结构:
哈希表
4.方法:
V put(K key, V value) -> 添加元素,返回的是被替换的value值
V remove(Object key) ->根据key删除键值对,返回的是被删除的value
V get(Object key) -> 根据key获取value
boolean containsKey(Object key) -> 判断集合中是否包含指定的key
Collection<V> values() -> 获取集合中所有的value,转存到Collection集合中
Set<K> keySet()->将Map中的key获取出来,转存到Set集合中
Set<Map.Entry<K,V>> entrySet()->获取Map集合中的键值对,转存到Set集合中java
public class Demo01HashMap {
public static void main(String[] args) {
HashMap<String, String> hashMap = new HashMap<>();
//V put(K key, V value) -> 添加元素,返回的是被替换的value值
hashMap.put("涛哥","三上");
hashMap.put("文章","马伊琍");
hashMap.put("黄晓明","杨颖");
String value = hashMap.put("涛哥", "金莲");
System.out.println("value = " + value);
hashMap.put("大郎","金莲");
System.out.println(hashMap);
//V remove(Object key) ->根据key删除键值对,返回的是被删除的value
System.out.println(hashMap.remove("大郎"));
System.out.println(hashMap);
//V get(Object key) -> 根据key获取value
System.out.println(hashMap.get("黄晓明"));
//boolean containsKey(Object key) -> 判断集合中是否包含指定的key
System.out.println(hashMap.containsKey("黄晓明"));
//Collection<V> values() -> 获取集合中所有的value,转存到Collection集合中
System.out.println(hashMap.values());
}
}java
1.概述:LinkedHashMap 是 HashMap的子类
2.特点:
a.有序
b.无索引
c.key唯一,value可重复
d.线程不安全
e.可以存null键null值
3.数据结构:
哈希表+链表
4.方法:
和HashMap一样java
public class Demo02LinkedHashMap {
public static void main(String[] args) {
LinkedHashMap<String, String> hashMap = new LinkedHashMap<>();
//V put(K key, V value) -> 添加元素,返回的是被替换的value值
hashMap.put("涛哥","三上");
hashMap.put("文章","马伊琍");
hashMap.put("黄晓明","杨颖");
hashMap.put("大郎","金莲");
System.out.println(hashMap);
}
}3.HashMap 的两种遍历方式
3.1.方式 1:获取 key,根据 key 再获取 value
java
Set<K> keySet()->将Map中的key获取出来,转存到Set集合中java
public class Demo03HashMap {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("张无忌","赵敏");
map.put("段誉","王语嫣");
map.put("虚竹","梦姑");
map.put("乔峰","阿朱");
map.put("杨过","小龙女");
Set<String> set = map.keySet();
for (String key : set) {
String value = map.get(key);
System.out.println(key+"..."+value);
}
}
}3.2.方式 2:同时获取 key 和 value
java
Set<Map.Entry<K,V>> entrySet()->获取Map集合中的键值对,转存到Set集合中java
public class Demo04HashMap {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("张无忌","赵敏");
map.put("段誉","王语嫣");
map.put("虚竹","梦姑");
map.put("乔峰","阿朱");
map.put("杨过","小龙女");
Set<Map.Entry<String, String>> set = map.entrySet();
for (Map.Entry<String, String> entry : set) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"..."+value);
}
}
}4.Map 存储自定义对象时如何保证 key 唯一
java
1.细节:
HashSet存储的元素都会存到Map集合的key位置,所以map如何保证key唯一的,set集合就是如何保证元素唯一的,所以set集合保证元素唯一的原理和map保证key唯一原理是一样的
2.想要保证key唯一,key必须重写hashCode和equals方法
3.保证key唯一的过程:
先比较key的哈希值,再比较key的内容
如果哈希值不一样,存
如果哈希值一样,内容不一样,存
如果哈希值一样,内容也一样,value覆盖前面的valuejava
public class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(name, person.name) && Objects.equals(age, person.age);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}java
public class Demo05HashMap {
public static void main(String[] args) {
HashMap<Person, String> map = new HashMap<>();
map.put(new Person("张三", 20),"北京");
map.put(new Person("李四", 21),"天津");
map.put(new Person("张三", 20),"河北");
System.out.println(map);
}
}5.Map 的练习
java
需求:用Map集合统计字符串中每一个字符出现的次数
步骤:
1.创建String字符串
2.创建HashMap集合,key为字符,value为次数
3.遍历字符串,将每一个字符获取出来
4.判断集合中是否包含指定的key,如果不包含,将该字符和1存到map中
5.如果包含,根据key获取对应的value,将value+1,然后将字符和value重新存到map中
6.输出map
java
public class Demo06HashMap {
public static void main(String[] args) {
//1.创建String字符串
String data = "abdafdasfwef";
//2.创建HashMap集合,key为字符,value为次数
HashMap<String, Integer> map = new HashMap<>();
//3.遍历字符串,将每一个字符获取出来
char[] chars = data.toCharArray();
for (char cChar : chars) {
String key = cChar + "";
//4.判断集合中是否包含指定的key,如果不包含,将该字符和1存到map中
if (!map.containsKey(key)) {
map.put(key, 1);
//5.如果包含,根据key获取对应的value,将value+1,然后将字符和value重新存到map中
}else{
Integer value = map.get(key);
value++;
map.put(key, value);
}
}
//6.输出map
Set<Map.Entry<String, Integer>> set = map.entrySet();
for (Map.Entry<String, Integer> entry : set) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"..."+value);
}
}
}第二章.TreeSet
java
1.概述:是Set接口的实现类
2.特点:
a.对元素进行排序
b.无索引
c.元素唯一
d.线程不安全
3.数据结构:
红黑树
4.构造方法:
a.TreeSet() 将元素按照ASCII码排序
b.TreeSet(Comparator<? super E> comparator) 按照指定的规则排序java
public class Demo01TreeSet {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<>();
set.add("a.床前明月光");
set.add("c.举头望明月");
set.add("d.低头思故乡");
set.add("b.疑是地上霜");
System.out.println(set);
System.out.println("===========================");
TreeSet<Person> set2 = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});
set2.add(new Person("张三", 18));
set2.add(new Person("李四", 20));
set2.add(new Person("王五", 19));
System.out.println(set2);
}
}java
public class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(name, person.name) && Objects.equals(age, person.age);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}第三章.TreeMap
java
1.概述:是Map接口的实现类
2.特点:
a.可以对key进行排序
b.无索引
c.key唯一,value可重复
d.线程不安全
3.数据结构:
红黑树
4.构造:
TreeMap() -> 将key按照ASCII码排序
TreeMap(Comparator<? super K> comparator) -> 对key进行指定顺序排序java
public class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(name, person.name) && Objects.equals(age, person.age);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}java
public class Demo02TreeMap {
public static void main(String[] args) {
TreeMap<String, String> map = new TreeMap<>();
map.put("1","锄禾日当午");
map.put("3","谁知盘中餐");
map.put("4","粒粒皆辛苦");
map.put("2","汗滴禾下土");
System.out.println(map);
System.out.println("========================");
TreeMap<Person, String> map1 = new TreeMap<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.getAge()-o1.getAge();
}
});
map1.put(new Person("张三", 20), "河北");
map1.put(new Person("李四", 30), "河南");
map1.put(new Person("王五", 25), "山西");
System.out.println(map1);
}
}第四章.Hashtable 和 Vector 集合(了解)
1.Hashtable 集合
java
1.概述:是Map接口的实现类
2.特点:
a.无序
b.无索引
c.key唯一,value可重复
d.线程安全
e.不能存null
3.数据结构:
哈希表
4.用法:和HashMap一样java
public class Demo01Hashtable {
public static void main(String[] args) {
Hashtable<String, String> hashtable = new Hashtable<>();
hashtable.put("涛哥","金莲");
hashtable.put("庆庆","莲莲");
hashtable.put("松松","虎虎");
//hashtable.put(null,null);
System.out.println(hashtable);
}
}Hashtable 和 HashMap 区别:
相同点:元素无序,无索引,key 唯一,都是哈希表
不同点:HashMap 线程不安全,Hashtable 线程安全
HashMap 可以存储 null 键 null 值;Hashtable 不能
2.Vector 集合
java
1.概述:是List接口的实现类
2.特点:
a.元素有序
b.有索引
c.元素可重复
d.线程安全
3.数据结构:
数组
4.注意:
a.如果利用空参构造创建对象,扩容默认是2倍
b.如果利用有参构造创建对象,指定了容量增量,那么扩容就在数组长度的基础上加容量增量java
public class Demo02Vector {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("张三");
vector.add("李四");
vector.add("王五");
vector.add("赵六");
System.out.println(vector);
for (String s : vector) {
System.out.println(s);
}
}
}java1.Vector() 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量(扩容的长度)为零javaVector<String> vector = new Vector<>(); ======================================= public Vector() { this(10); } public Vector(int initialCapacity) { this(initialCapacity, 0); } public Vector(int initialCapacity, int capacityIncrement) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; this.capacityIncrement = capacityIncrement; } ========================================= 假如正在添加第11个元素,会自动扩容 vector.add("赵六"); public synchronized boolean add(E e) { modCount++; add(e, elementData, elementCount); return true; } private void add(E e, Object[] elementData, int s) { if (s == elementData.length) elementData = grow(); elementData[s] = e; elementCount = s + 1; } private Object[] grow() { return grow(elementCount + 1); } private Object[] grow(int minCapacity) { int oldCapacity = elementData.length; int newCapacity = ArraysSupport.newLength(oldCapacity, minCapacity - oldCapacity, /* minimum growth */ capacityIncrement > 0 ? capacityIncrement : oldCapacity /* preferred growth */); return elementData = Arrays.copyOf(elementData, newCapacity); }java1.Vector(int initialCapacity, int capacityIncrement)使用指定的初始容量和容量增量构造一个空的向量 ============================== Vector<String> vector = new Vector<>(10,15); public Vector(int initialCapacity, int capacityIncrement) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; this.capacityIncrement = capacityIncrement; } =============================== 假设存储第11个元素 public synchronized boolean add(E e) { modCount++; add(e, elementData, elementCount); return true; } private void add(E e, Object[] elementData, int s) { if (s == elementData.length) elementData = grow(); elementData[s] = e; elementCount = s + 1; } private Object[] grow() { return grow(elementCount + 1); } private Object[] grow(int minCapacity) { int oldCapacity = elementData.length; int newCapacity = ArraysSupport.newLength(oldCapacity, minCapacity - oldCapacity, /* minimum growth */ capacityIncrement > 0 ? capacityIncrement : oldCapacity /* preferred growth */); return elementData = Arrays.copyOf(elementData, newCapacity); }
第五章.Properties 集合(属性集)
java
1.概述:
是Hashtable的子类
2.特点:
a.无序
b.无索引
c.key唯一,value可重复
d.线程安全
e.不能存null
f.key和value固定为String
3.数据结构:
哈希表
4.用法:和HashMap一样
5.特有方法:
a.setProperty(String key, String value) 存键值对
b.String getProperty(String key) 根据key获取value
c.Set<String> stringPropertyNames() 获取所有的key保存到set集合中,类似于keySet
d.void load(InputStream inStream) -> 将流中的数据加载到properties集合中java
public class Demo01Properties {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("username","root");
properties.setProperty("password","123456");
Set<String> set = properties.stringPropertyNames();
for (String key : set) {
String value = properties.getProperty(key);
System.out.println(key+"..."+value);
}
}
}使用场景:解析配置文件使用
properties创建一个xxx.properties文件 username=root password=rootjavapublic class Demo02Properties { public static void main(String[] args) throws IOException { Properties properties = new Properties(); FileInputStream fis = new FileInputStream("day19_map/jdbc.properties"); properties.load(fis); Set<String> set = properties.stringPropertyNames(); for (String key : set) { String value = properties.getProperty(key); System.out.println(key+"..."+value); } } }
第六章.集合嵌套
1.List 嵌套 List
java
需求:创建2个List集合,每个集合中分别存储一些字符串,将2个集合存储到第3个List集合中java
public class Demo01ListInList {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
list1.add("张三");
list1.add("李四");
list1.add("王五");
ArrayList<String> list2 = new ArrayList<>();
list2.add("赵六");
list2.add("田七");
list2.add("朱八");
ArrayList<ArrayList<String>> list = new ArrayList<>();
list.add(list1);
list.add(list2);
/*
遍历
先遍历大集合,将小集合获取出来
再遍历小集合,将元素获取出来
*/
for (ArrayList<String> arrayList : list) {
for (String s : arrayList) {
System.out.println(s);
}
}
}
}2.List 嵌套 Map
java
1班级有三名同学，学号和姓名分别为：1=张三，2=李四，3=王五，2班有三名同学，学号和姓名分别为：1=黄晓明，2=杨颖，3=刘德华,请将同学的信息以键值对的形式存储到2个Map集合中，再将2个Map集合存储到List集合中。java
public class Demo02ListInMap {
public static void main(String[] args) {
HashMap<Integer, String> map1 = new HashMap<>();
map1.put(1,"张三");
map1.put(2,"李四");
map1.put(3,"王五");
HashMap<Integer, String> map2 = new HashMap<>();
map2.put(1,"黄晓明");
map2.put(2,"杨颖");
map2.put(3,"刘德华");
ArrayList<HashMap<Integer, String>> list = new ArrayList<>();
list.add(map1);
list.add(map2);
//先遍历list,将两个map获取出来
for (HashMap<Integer, String> map : list) {
//遍历小map
Set<Map.Entry<Integer, String>> set = map.entrySet();
for (Map.Entry<Integer, String> entry : set) {
System.out.println(entry.getKey() + "=" + entry.getValue());
}
}
}
}3.Map 嵌套 Map
java
- JavaSE 集合 存储的是 学号 键，值学生姓名
- 1(key) 张三(value)
- 2 李四
- JavaEE 集合 存储的是 学号 键，值学生姓名
- 1 王五
- 2 赵六java
作业
小map的key为学号,value为姓名
大map的key为字符串(javase,javaee),value为小map第七章.File 类
1.File 类
java
1.xxx.jpg一定是图片吗?
不一定
2.什么叫做文本文档?
用记事本打开人能看懂的文档 -> 比如.txt .java .html .css
3.F:\idea\io\1.jpg中1.jpg的父路径是谁?
F:\idea\io
4.路径名称分隔符:一个路径中,文件夹与文件夹或者与文件之间的分隔符
windows:\
linux: /
路径分隔符:一个路径和其他路径之间的分隔符
;java
1.File概述:文件和目录路径名的抽象表示形式 -> 说白了就是代表文件对象或者文件夹对象2.File 的静态成员
java
static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串
static String separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串java
public class Demo01File {
public static void main(String[] args) {
//static String pathSeparator 与系统有关的路径分隔符，为了方便，它被表示为一个字符串
System.out.println(File.pathSeparator);
//static String separator 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串
System.out.println(File.separator);
System.out.println("==================");
/*
写代码要求:一次编写,到处运行
下面的代码直接写的是\
但是代码到了linux上运行就不合适了,因为linux是/
*/
//String path = "F:\\idea\\io\\1.png";
//System.out.println(path);
String path = "F:"+File.separator+"idea"+File.separator+"io"+File.separator+"1.png";
System.out.println(path);
}
}3.File 的构造方法
java
File(String parent, String child) 根据所填写的路径创建File对象
parent:父路径
child:子路径
File(File parent, String child) 根据所填写的路径创建File对象
parent:父路径,是一个File对象
child:子路径
File(String pathname) 根据所填写的路径创建File对象
pathname:直接指定路径java
public class Demo02File {
public static void main(String[] args) {
/* File(String parent, String child) 根据所填写的路径创建File对象
parent:父路径
child:子路径*/
File file1 = new File("F:\\idea\\io", "1.png");
System.out.println("file1 = " + file1);
/* File(File parent, String child) 根据所填写的路径创建File对象
parent:父路径,是一个File对象
child:子路径*/
File parent = new File("F:\\idea\\io");
File file2 = new File(parent, "1.jpg");
System.out.println("file2 = " + file2);
/* File(String pathname) 根据所填写的路径创建File对象
pathname:直接指定路径*/
File file3 = new File("F:\\idea\\io\\1.jpg");
System.out.println("file3 = " + file3);
}
}我们表示的文件或者文件夹的对象,可以不存在,但是没意义
4.File 的获取方法
java
String getAbsolutePath() -> 获取File的绝对路径->带盘符的路径
String getPath() ->获取的是封装路径->new File对象的时候写的啥路径,获取的就是啥路径
String getName() -> 获取的是文件或者文件夹名称
long length() -> 获取的是文件的长度 -> 文件的字节数java
public class Demo03File {
public static void main(String[] args) {
//String getAbsolutePath() -> 获取File的绝对路径->带盘符的路径
File file = new File("F:\\1.jpg");
System.out.println(file.getAbsolutePath());
//String getPath() ->获取的是封装路径->new File对象的时候写的啥路径,获取的就是啥路径
System.out.println(file.getPath());
//String getName() -> 获取的是文件或者文件夹名称
File file1 = new File("F:\\idea\\io\\1.txt");
System.out.println(file1.getName());
//long length() -> 获取的是文件的长度 -> 文件的字节数
System.out.println(file1.length());
}
}5.File 的创建方法
java
boolean createNewFile() -> 创建文件
如果要创建的文件之前有,创建失败,返回false
如果要创建的文件之前没有,创建成功,返回true
boolean mkdirs() -> 创建文件夹(目录)既可以创建多级文件夹,还可以创建单级文件夹
如果要创建的文件夹之前有,创建失败,返回false
如果要创建的文件夹之前没有,创建成功,返回truejava
public class Demo04File {
public static void main(String[] args) throws IOException {
/*
boolean createNewFile() -> 创建文件
如果要创建的文件之前有,创建失败,返回false
如果要创建的文件之前没有,创建成功,返回true
*/
File file = new File("F:\\idea\\io\\2.txt");
System.out.println(file.createNewFile());
/*
boolean mkdirs() -> 创建文件夹(目录)既可以创建多级文件夹,还可以创建单级文件夹
如果要创建的文件夹之前有,创建失败,返回false
如果要创建的文件夹之前没有,创建成功,返回true
*/
File file2 = new File("F:\\idea\\io\\a\\b\\c");
System.out.println(file2.mkdirs());
}
}6.File 类的删除方法
java
boolean delete()->删除文件或者文件夹
注意:
1.如果删除文件,不走回收站
2.如果删除文件夹,必须是空文件夹,而且也不走回收站java
public class Demo05File {
public static void main(String[] args) {
/*
boolean delete()->删除文件或者文件夹
注意:
1.如果删除文件,不走回收站
2.如果删除文件夹,必须是空文件夹,而且也不走回收站
*/
File file = new File("F:\\idea\\io\\2.txt");
System.out.println(file.delete());
File file2 = new File("F:\\idea\\io\\a");
System.out.println(file2.delete());
}
}7.File 类的判断方法
java
boolean isDirectory() -> 判断是否为文件夹
boolean isFile() -> 判断是否为文件
boolean exists() -> 判断文件或者文件夹是否存在java
public class Demo06File {
public static void main(String[] args) {
File file = new File("F:\\idea\\io\\1.txt");
System.out.println(file.isFile());
System.out.println(file.isDirectory());
System.out.println(file.exists());
}
}8.File 的遍历方法
java
File[] listFiles()-> 遍历指定的文件夹,返回的是File数组 ->这个推荐使用java
public static void main(String[] args) {
File file = new File("F:\\idea\\io\\aa");
File[] files = file.listFiles();
for (File file1 : files) {
System.out.println(file1);
}
}
}练习:将指定文件夹下面的所有.jpg 的图片都获取出来
javapublic class Demo08File { public static void main(String[] args) { File file = new File("F:\\idea\\io\\aa"); method(file); } private static void method(File file) { //1.遍历file对象表示的文件夹 File[] files = file.listFiles(); for (File file1 : files) { //2.判断如果是文件,就直接获取文件名 if (file1.isFile()) { //3.判断文件名是否是以.jpg结尾的 String name = file1.getName(); if (name.endsWith(".jpg")){ System.out.println(name); } }else{ method(file1); } } } }
9.相对路径和绝对路径
java
1.绝对路径:带盘符的路径
2.相对路径:不带盘符的路径
3.什么时候使用绝对路径和相对路径:
跨盘符写路径可以使用使用绝对路径
不跨盘符可以使用相对路径
4.在idea中如何写相对路径:
a.哪个路径为参照路径,哪个路径就可以省略不写
b.什么是参照路径:当前project的绝对路径
c.举例1:在day19_map_file这个模块下创建了一个1.txt,1.txt的相对路径怎么写?
先将1.txt的绝对路径写出来:F:\idea\workspace\BJ_241229Java\day19_map_file\\1.txt
再找出参照路径:F:\idea\workspace\BJ_241229Java
干掉参照路径,剩下的就是1.txt的相对路径写法:day19_map_file\\1.txt
5.总结:
a.在idea中写相对路径从模块名开始写
b.如果不带模块名,那么默认位置就是在当前project下ArrayList
java1.元素有序 2.有索引 3.元素可重复 4.线程不安全 5.数据结构:数组LinkedList
java1.元素有序 2.无索引 3.元素可重复 4.线程不安全 5.数据结构:双向链表Vector
java1.元素有序 2.有索引 3.元素可重复 4.线程安全 5.数据结构:数组HashSet
java1.元素无序 2.无索引 3.元素唯一 4.线程不安全 5.数据结构:哈希表LinkedHashSet
java1.元素有序 2.无索引 3.元素唯一 4.线程不安全 5.数据结构:哈希表+双向链表TreeSet
java1.对元素进行排序 2.无索引 3.元素唯一 4.线程不安全 5.数据结构:红黑树
HashMap
java1.无序 2.无索引 3.key唯一,value可重复 4.线程不安全 5.可以存null键null值 6.数据结构:哈希表LinkedHashMap
java1.有序 2.无索引 3.key唯一,value可重复 4.线程不安全 5.可以存null 6.数据结构:哈希表+双向链表TreeMap
java1.可以对key进行排序 2.无索引 3.key唯一,value可重复 4.线程不安全 5.key不能为null 6.数据结构:红黑树Hashtable
java1.无序 2.无索引 3.key唯一,value可重复 4.线程安全 5.不能存null 6.数据结构:哈希表Properties
java1.无序 2.无索引 3.key唯一,value可重复 4.线程安全 5.key和value只能是String 6.数据结构:哈希表 是唯一一个能和IO流结合使用的集合,解析配置文件使用
第八章.哈希表
第九章.正则表达式
1.正则表达式的概念及演示
java
1.概述:用于校验一个字符串
2.作用:用于校验规则:比如用户名 密码 手机号 身份证号 邮箱等
3.方法:String中的方法:
boolean matches(正则表达式)-> 判断字符串是否符合指定的正则规则
4.举例: 校验QQ号:
不能以0开头,都是数字,5-15位java
public class Demo01Regex {
public static void main(String[] args) {
/*
不能以0开头,都是数字,5-15位
*/
boolean result = "03112312312".matches("[1-9][0-9]{4,14}");
System.out.println("result = " + result);
}
}2.正则表达式-字符类
java
java.util.regex.Pattern:正则表达式的编译表示形式。
正则表达式-字符类:[]表示一个区间,范围可以自己定义
语法示例：
1. [abc]：代表a或者b，或者c字符中的一个。
2. [^abc]：代表除a,b,c以外的任何字符。
3. [a-z]：代表a-z的所有小写字符中的一个。
4. [A-Z]：代表A-Z的所有大写字符中的一个。
5. [0-9]：代表0-9之间的某一个数字字符。
6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
7. [a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符java
//1.验证字符串是否以h开头,d结尾,中间是aeiou的某一个字符
//2.验证字符串是否以h开头,d结尾,中间不是aeiou的某一个字符
//3.验证字符串是否是开头a-z的任意一个小写字母,后面跟adjava
public class Demo02Regex {
public static void main(String[] args) {
//1.验证字符串是否以h开头,d结尾,中间是aeiou的某一个字符
boolean result01 = "had".matches("[h][aeiou][d]");
System.out.println("result01 = " + result01);
//2.验证字符串是否以h开头,d结尾,中间不是aeiou的某一个字符
boolean result02 = "had".matches("[h][^aeiou][d]");
System.out.println("result02 = " + result02);
//3.验证字符串是否是开头a-z的任意一个小写字母,后面跟ad
boolean result03 = "aad".matches("[a-z][a][d]");
System.out.println("result03 = " + result03);
}
}3.正则表达式-逻辑运算符
java
正则表达式-逻辑运算符
语法示例：
1. &&：并且
2. | ：或者java
//1.要求字符串是小写字母并且字符不能以[aeiou]开头,后面跟ad
//2.要求字符是aeiou的某一个字符开头,后面跟adjava
public class Demo03Regex {
public static void main(String[] args) {
//1.要求字符串是小写字母并且字符不能以[aeiou]开头,后面跟ad
boolean result01 = "yad".matches("[[a-z]&&[^aeiou]][a][d]");
System.out.println("result01 = " + result01);
//2.要求字符是aeiou的某一个字符开头,后面跟ad
boolean result02 = "aad".matches("[a|e|i|o|u][a][d]");
System.out.println("result02 = " + result02);
}
}4.正则表达式-预定义字符
java
正则表达式-预定义字符
语法示例：
1. "." ： 匹配任何字符。(重点) 不能加[]
2. "\\d"：任何数字[0-9]的简写；(重点)
3. "\\D"：任何非数字[^0-9]的简写；
4. "\\s"： 空白字符：[ \t\n\x0B\f\r] 的简写
5. "\\S"： 非空白字符：[^\s] 的简写
6. "\\w"：单词字符：[a-zA-Z_0-9]的简写(重点)
7. "\\W"：非单词字符：[^\w]java
//1.验证字符串是否是三位数字
//2.验证手机号: 1开头 第二位3 5 8 剩下的都是0-9的数字
//3.验证字符串是否以h开头,d结尾,中间是任意一个字符java
public class Demo04Regex {
public static void main(String[] args) {
//1.验证字符串是否是三位数字
//boolean result01 = "111".matches("[0-9][0-9][0-9]");
boolean result01 = "111".matches("\\d\\d\\d");
System.out.println("result01 = " + result01);
//2.验证手机号: 1开头 第二位3 5 8 剩下的都是0-9的数字
boolean result02 = "13838381438".matches("[1][358]\\d\\d\\d\\d\\d\\d\\d\\d\\d");
System.out.println("result02 = " + result02);
//3.验证字符串是否以h开头,d结尾,中间是任意一个字符
boolean result03 = "h1d".matches("[h].[d]");
System.out.println("result03 = " + result03);
}
}5. 正则表达式-数量词
java
正则表达式-数量词
语法示例：x代表字符
1. X? : x出现的数量为 0次或1次
2. X* : x出现的数量为 0次到多次 任意次
3. X+ : x出现的数量为 1次或多次 X>=1次
4. X{n} : x出现的数量为 恰好n次 X=n次
5. X{n,} : x出现的数量为 至少n次 X>=n次 x{3,}
6. X{n,m}: x出现的数量为 n到m次(n和m都是包含的) n=<X<=mjava
//1.验证字符串是否是三位数字
//2.验证手机号: 1开头 第二位3 5 8 剩下的都是0-9的数字
//3.验证qq号: 不能是0开头,都是数字,长度为5-15java
public class Demo05Regex {
public static void main(String[] args) {
//1.验证字符串是否是三位数字
boolean result01 = "111".matches("\\d{3}");
System.out.println("result01 = " + result01);
//2.验证手机号: 1开头 第二位3 5 8 剩下的都是0-9的数字
boolean result02 = "13838381438".matches("[1][358]\\d{9}");
System.out.println("result02 = " + result02);
//3.验证qq号: 不能是0开头,都是数字,长度为5-15
boolean result03 = "11111".matches("[1-9][0-9]{4,14}");
System.out.println("result03 = " + result03);
}
}6.正则表达式-分组括号( )
java
正则表达式-分组括号( ) (abc)java
public class Demo06Regex {
public static void main(String[] args) {
boolean result = "abcabcabcabcab".matches("(abc)*");
System.out.println("result = " + result);
}
}7.String 类中和正则表达式相关的方法
java
String类中和正则表达式相关的方法
boolean matches(String regex) 判断字符串是否匹配给定的正则表达式。
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符java
public class Demo07Regex {
public static void main(String[] args) {
//String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
String s1 = "abc sdfads sadfasd ";
String[] arr = s1.split(" +");
System.out.println(Arrays.toString(arr));
//String replaceAll(String regex, String replacement)把满足正则表达式的字符串,替换为新的字符
String s = s1.replaceAll(" +", "z");
System.out.println("s = " + s);
}
}8.正则表达式生成网址:
html
https://www.sojson.com/regex/generate